PyTorch 선형 회귀 와 논리 회귀 실전 예시
PyTorch 를 사용 하여 선형 회귀 모델 을 정의 하 는 것 은 보통 다음 과 같은 몇 단계 로 나 뉜 다.
1.네트워크 구조 설계
2.손실 함수(loss)와 최적화 기(optimizer)구축
3.훈련(피 드 포워드 포함),역방향 전파(backward),모델 파라미터 업데이트(update)
#author:yuquanle
#data:2018.2.5
#Study of LinearRegression use PyTorch
import torch
from torch.autograd import Variable
# train data
x_data = Variable(torch.Tensor([[1.0], [2.0], [3.0]]))
y_data = Variable(torch.Tensor([[2.0], [4.0], [6.0]]))
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
self.linear = torch.nn.Linear(1, 1) # One in and one out
def forward(self, x):
y_pred = self.linear(x)
return y_pred
# our model
model = Model()
criterion = torch.nn.MSELoss(size_average=False) # Defined loss function
optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # Defined optimizer
# Training: forward, loss, backward, step
# Training loop
for epoch in range(50):
# Forward pass
y_pred = model(x_data)
# Compute loss
loss = criterion(y_pred, y_data)
print(epoch, loss.data[0])
# Zero gradients
optimizer.zero_grad()
# perform backward pass
loss.backward()
# update weights
optimizer.step()
# After training
hour_var = Variable(torch.Tensor([[4.0]]))
print("predict (after training)", 4, model.forward(hour_var).data[0][0])
열 번 반복 인쇄 결과:0 123.87958526611328
1 55.19491195678711
2 24.61777114868164
3 11.005026817321777
4 4.944361686706543
5 2.2456750869750977
6 1.0436556339263916
7 0.5079189538955688
8 0.2688019871711731
9 0.16174012422561646
predict (after training) 4 7.487752914428711
loss 는 계속 떨 어 지고 있 습 니 다.이때 입력 4 가 얻 은 결 과 는 아직 예측 이 정확 하지 않 습 니 다.
교체 횟수 가 50 으로 설정 되 었 을 때:
0 35.38422393798828
5 0.6207122802734375
10 0.012768605723977089
15 0.0020055510103702545
20 0.0016929294215515256
25 0.0015717096393927932
30 0.0014619173016399145
35 0.0013598509831354022
40 0.0012649153359234333
45 0.00117658288218081
50 0.001094428705982864
predict (after training) 4 8.038028717041016
이때 함 수 는 이미 적합 한 것 이 비교적 좋다.
다시 실행:
0 159.48605346679688
5 2.827991485595703
10 0.08624256402254105
15 0.03573693335056305
20 0.032463930547237396
25 0.030183646827936172
30 0.02807590737938881
35 0.026115568354725838
40 0.02429218217730522
45 0.022596003487706184
50 0.0210183784365654
predict (after training) 4 7.833342552185059
같은 교체 50 회 발견 되 었 으 나 입력 이 4 일 때 결과 가 다 르 기 때문에 pytorch 를 사용 하여 선형 회귀 모델 을 정의 해 야 할 때:
torch.nn.Linear(1,1)는 입력 과 출력 차원 만 알 아야 합 니 다.안의 매개 변수 행렬 은 무 작위 로 초기 화 되 었 습 니 다(구체 적 으로 무 작위 인지 일정한 제약 조건 에 따라 초기 화 되 었 는 지 확실 하지 않 습 니 다).모든 계산 loss 는 서로 다른 위치(모델 의 매개 변수 업데이트 로 도 다 릅 니 다)로 내 려 가 결과 가 다 릅 니 다.
논리 회귀 실전
선형 회 귀 는 회귀 문 제 를 해결 하 는 것 으로 논리 회귀 와 선형 회 귀 는 매우 비슷 하지만 분류 문 제 를 해결 하 는 것 이다(일반 2 분류 문제:0 or 1).문 제 를 많이 분류 할 수도 있다.
pytorch 를 사용 하여 논리 회 귀 를 실현 하 는 기본 과정 과 선형 회 귀 는 차이 가 많 지 않 지만 다음 과 같은 몇 가지 차이 가 있다.
다음은 sigmoid 함수:
논리 회귀 에서 우 리 는 출력 이 0.5 보다 클 때 y=1 을 예측 합 니 다.그렇지 않 으 면 y=0.
손실 함 수 는 일반적으로 교차 엔트로피 loss 를 사용한다.
# date:2018.2.6
# LogisticRegression
import torch
from torch.autograd import Variable
x_data = Variable(torch.Tensor([[0.6], [1.0], [3.5], [4.0]]))
y_data = Variable(torch.Tensor([[0.], [0.], [1.], [1.]]))
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
self.linear = torch.nn.Linear(1, 1) # One in one out
self.sigmoid = torch.nn.Sigmoid()
def forward(self, x):
y_pred = self.sigmoid(self.linear(x))
return y_pred
# Our model
model = Model()
# Construct loss function and optimizer
criterion = torch.nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# Training loop
for epoch in range(500):
# Forward pass
y_pred = model(x_data)
# Compute loss
loss = criterion(y_pred, y_data)
if epoch % 20 == 0:
print(epoch, loss.data[0])
# Zero gradients
optimizer.zero_grad()
# Backward pass
loss.backward()
# update weights
optimizer.step()
# After training
hour_var = Variable(torch.Tensor([[0.5]]))
print("predict (after training)", 0.5, model.forward(hour_var).data[0][0])
hour_var = Variable(torch.Tensor([[7.0]]))
print("predict (after training)", 7.0, model.forward(hour_var).data[0][0])
입력 결과:0 0.9983477592468262
20 0.850886881351471
40 0.7772406339645386
60 0.7362991571426392
80 0.7096697092056274
100 0.6896909475326538
120 0.6730546355247498
140 0.658246636390686
160 0.644534170627594
180 0.6315458416938782
200 0.6190851330757141
220 0.607043981552124
240 0.5953611731529236
260 0.5840001106262207
280 0.5729377269744873
300 0.5621585845947266
320 0.5516515970230103
340 0.5414079427719116
360 0.5314203500747681
380 0.5216821432113647
400 0.512187123298645
420 0.5029295086860657
440 0.49390339851379395
460 0.4851033389568329
480 0.47652381658554077
predict (after training) 0.5 0.49599987268447876
predict (after training) 7.0 0.9687209129333496
Process finished with exit code 0
모델 을 훈련 한 후에 새로운 데 이 터 를 0.5 입력 하면 이때 출력 이 0.5 보다 적 으 면 0 유형 이 고 입력 7 출력 이 0.5 보다 크 면 1 유형 이다.softmax 를 사용 하여 다 중 분 류 를 할 때 그 차원 의 수치 가 크 면 그 수치 에 대응 하 는 위치의 분류 입 니 다.
더 깊 고 넓 은 네트워크
앞의 예 는 모두 얕 은 층 의 입력 을 1 차원 으로 하 는 네트워크 입 니 다.더 깊 고 넓 은 네트워크 가 필요 하 다 면 pytorch 를 사용 해도 잘 이 루어 질 수 있 습 니 다.논리 적 회 귀 를 예 로 들 면:
x 를 입력 할 때 더 넓 은 네트워크 가 필요 합 니 다.
더 깊 은 네트워크:
아래 데이터 세트 사용(다운로드 주소:https://github.com/hunkim/PyTorchZeroToAll/tree/master/data)
입력 차원 은 8 이다.
#author:yuquanle
#date:2018.2.7
#Deep and Wide
import torch
from torch.autograd import Variable
import numpy as np
xy = np.loadtxt('./data/diabetes.csv', delimiter=',', dtype=np.float32)
x_data = Variable(torch.from_numpy(xy[:, 0:-1]))
y_data = Variable(torch.from_numpy(xy[:, [-1]]))
#print(x_data.data.shape)
#print(y_data.data.shape)
class Model(torch.nn.Module):
def __init__(self):
super(Model, self).__init__()
self.l1 = torch.nn.Linear(8, 6)
self.l2 = torch.nn.Linear(6, 4)
self.l3 = torch.nn.Linear(4, 1)
self.sigmoid = torch.nn.Sigmoid()
def forward(self, x):
x = self.sigmoid(self.l1(x))
x = self.sigmoid(self.l2(x))
y_pred = self.sigmoid(self.l3(x))
return y_pred
# our model
model = Model()
cirterion = torch.nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
hour_var = Variable(torch.Tensor([[-0.294118,0.487437,0.180328,-0.292929,0,0.00149028,-0.53117,-0.0333333]]))
print("(Before training)", model.forward(hour_var).data[0][0])
# Training loop
for epoch in range(1000):
y_pred = model(x_data)
# y_pred,y_data ( loss)
loss = cirterion(y_pred, y_data)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch % 50 == 0:
print(epoch, loss.data[0])
# After training
hour_var = Variable(torch.Tensor([[-0.294118,0.487437,0.180328,-0.292929,0,0.00149028,-0.53117,-0.0333333]]))
print("predict (after training)", model.forward(hour_var).data[0][0])
결과:(Before training) 0.5091859698295593
0 0.6876295208930969
50 0.6857835650444031
100 0.6840178370475769
150 0.6823290586471558
200 0.6807141900062561
250 0.6791688203811646
300 0.6776910424232483
350 0.6762782335281372
400 0.6749269366264343
450 0.6736343502998352
500 0.6723981499671936
550 0.6712161302566528
600 0.6700847744941711
650 0.6690039038658142
700 0.667969822883606
750 0.666980504989624
800 0.6660353541374207
850 0.6651310324668884
900 0.664265513420105
950 0.6634389758110046
predict (after training) 0.5618339776992798
Process finished with exit code 0
참고:
1. https://github.com/hunkim/PyTorchZeroToAll
2. http://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
IceVision에서 형식별 데이터를 읽는 방법2021년에 가장 멋있는 물체 검출 프레임워크라고 해도 과언이 아닌 IceVision을 사용해, VOC format과 COCO format의 데이터 세트에 대해 Object Detection을 간단하게 실시하기 위한...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.