PyTorch 에 간단 한 신경 망 을 구축 하여 회귀 와 분 류 를 실현 하 는 예

본 고 는 PyTorch 에 간단 한 신경 망 을 구축 하여 회귀 와 분 류 를 실현 하 는 예 를 소개 하고 구체 적 으로 다음 과 같다.

1.PyTorch 입문
1.설치 방법
PyTorch 홈 페이지 에 접속 하면http://pytorch.org아래 화면 을 볼 수 있 습 니 다.

위 그림 의 옵션 을 선택 하면 Linux 아래 conda 명령 을 받 을 수 있 습 니 다.

conda install pytorch torchvision -c soumith

현재 PyTorch 는 MacOS 와 Linux 만 지원 하고 Windows 는 지원 하지 않 습 니 다.PyTorch 를 설치 하면 두 개의 모듈 을 설치 할 수 있 습 니 다.하 나 는 torch,하 나 는 torchvision,torch 는 메 인 모듈 로 신경 망 을 구축 하 는 데 사 용 됩 니 다.torchvision 은 보조 모듈 이 고 데이터 베이스 가 있 으 며 이미 훈련 된 신경 망 도 있 습 니 다.예 를 들 어(VGG,AlexNet,ResNet).
2.Numpy 와 Torch
torch_data = torch.from_numpy(np_data)numpy(array)형식 을 torch(tensor)형식 으로 변환 할 수 있 습 니 다.torch_data.numpy()는 torch 의 tensor 형식 을 numpy 의 array 형식 으로 변환 할 수 있 습 니 다.Torch 의 Tensor 와 numpy 의 array 는 저장 공간 을 공유 하고 하 나 를 수정 하면 다른 하 나 를 수정 할 수 있 습 니 다.
1 차원(1-D)의 데이터 에 대해 numpy 는 행 벡터 로 출력 되 고 torch 는 열 벡터 로 출력 됩 니 다.
기타 예 를 들 어 sin,cos,abs,mean 등 numpy 의 함 수 는 torch 에서 사용 하 는 방법 이 같 습 니 다.주의해 야 할 것 은 numpy 에서 np.matmul(data,data)과 data.dot(data)행렬 을 곱 하면 같은 결 과 를 얻 을 수 있 습 니 다.torch 에서 torch.mm(tensor,tensor)는 행렬 을 곱 하 는 방법 으로 행렬 을 얻 을 수 있 습 니 다.tensor.dot(tensor)는 tensor 를 1 차원 tensor 로 바 꾼 다음 에 요 소 를 곱 한 후에 화 해 를 구 해서 하나의 실 수 를 얻 을 수 있 습 니 다.
관련 코드:

import torch 
import numpy as np 
 
np_data = np.arange(6).reshape((2, 3)) 
torch_data = torch.from_numpy(np_data) #  numpy(array)     torch(tensor)   
tensor2array = torch_data.numpy()  
print( 
  '
numpy array:
', np_data,  
  '
torch tensor:', torch_data,  
  '
tensor to array:
', tensor2array,  
) # torch     print             
 
# abs 
data = [-1, -2, 2, 2] 
tensor = torch.FloatTensor(data)  
print( 
  '
abs', 
  '
numpy: 
', np.abs(data),     
  '
torch: ', torch.abs(tensor)  
) # 1    ，numpy        ，torch         
 
# sin 
print( 
  '
sin', 
  '
numpy: 
', np.sin(data),    
  '
torch: ', torch.sin(tensor)  
) 
 
# mean 
print( 
  '
mean', 
  '
numpy: ', np.mean(data),   
  '
torch: ', torch.mean(tensor)  
) 
 
#      
data = [[1,2], [3,4]] 
tensor = torch.FloatTensor(data)  
 
print( 
  '
matrix multiplication (matmul)', 
  '
numpy: 
', np.matmul(data, data),   
  '
torch: ', torch.mm(tensor, tensor)  
) 
 
data = np.array(data) 
print( 
  '
matrix multiplication (dot)', 
  '
numpy: 
', data.dot(data),    
  '
torch: ', tensor.dot(tensor)   
) 

3. Variable
PyTorch 의 신경 망 은 autograd 가방 에서 나 왔 고 autograd 가방 은 Tensor 의 모든 조작 에 대한 자동 가이드 방법 을 제공 합 니 다.
autograd.Variable 은 이 가방 의 가장 핵심 적 인 클래스 입 니 다.Variable 을 tensor 가 들 어 있 는 용기 로 이해 할 수 있 습 니 다.Tensor 를 포장 하고 거의 모든 정 의 를 지원 합 니 다.연산 이 완료 되면.backward()를 호출 하여 모든 경사도 를 자동 으로 계산 할 수 있 습 니 다.tensor 를 Variable 에 넣 어야 신경 망 에서 역방향 전달,자동 유도 등 연산 이 가능 하 다 는 것 이다.
속성.data 를 통 해 원본 tensor 에 접근 할 수 있 으 며,이 Variable 에 대한 경사도 는.grad 속성 을 통 해 볼 수 있 습 니 다.
관련 코드:

import torch 
from torch.autograd import Variable 
 
tensor = torch.FloatTensor([[1,2],[3,4]]) 
variable = Variable(tensor, requires_grad=True) 
#     Variable   
print(tensor) 
print(variable) 
 
t_out = torch.mean(tensor*tensor) #      ^ 2 
v_out = torch.mean(variable*variable) 
print(t_out) 
print(v_out) 
 
v_out.backward() # Variable        
 
#   Variable    grad  、data      numpy   
print('variable:
', variable) 
# v_out = 1/4 * sum(variable*variable)         v_out      
#     v_out      , d(v_out)/d(variable) = 1/4*2*variable = variable/2 
print('variable.grad:
', variable.grad) # Variable    
print('variable.data:
', variable.data) # Variable    
print(variable.data.numpy()) #Variable    numpy   

부분 출력 결과:
variable:
Variable containing:
1 2
3 4
[torch.FloatTensor of size 2x2]
variable.grad:
Variable containing:
0.5000 1.0000
1.5000 2.0000
[torch.FloatTensor of size 2x2]
variable.data:
1 2
3 4
[torch.FloatTensor of size 2x2]
[[ 1. 2.]
[ 3. 4.]]
4.격려 함수 활성화 기능
Torch 의 격려 함 수 는 모두 torch.nn.functional 에 있 습 니 다.relu,sigmoid,tanh,softplus 는 모두 자주 사용 하 는 격려 함수 입 니 다.

관련 코드:

import torch 
import torch.nn.functional as F 
from torch.autograd import Variable 
import matplotlib.pyplot as plt 
 
x = torch.linspace(-5, 5, 200) 
x_variable = Variable(x) # x  Variable 
x_np = x_variable.data.numpy() 
 
#   4           numpy        
y_relu = F.relu(x_variable).data.numpy() 
y_sigmoid = F.sigmoid(x_variable).data.numpy() 
y_tanh = F.tanh(x_variable).data.numpy() 
y_softplus = F.softplus(x_variable).data.numpy() 
 
plt.figure(1, figsize=(8, 6)) 
 
plt.subplot(221) 
plt.plot(x_np, y_relu, c='red', label='relu') 
plt.ylim((-1, 5)) 
plt.legend(loc='best') 
 
plt.subplot(222) 
plt.plot(x_np, y_sigmoid, c='red', label='sigmoid') 
plt.ylim((-0.2, 1.2)) 
plt.legend(loc='best') 
 
plt.subplot(223) 
plt.plot(x_np, y_tanh, c='red', label='tanh') 
plt.ylim((-1.2, 1.2)) 
plt.legend(loc='best') 
 
plt.subplot(224) 
plt.plot(x_np, y_softplus, c='red', label='softplus') 
plt.ylim((-0.2, 6)) 
plt.legend(loc='best') 
 
plt.show() 

2.PyTorch 의 귀환 실현
전체 코드 먼저 보기:

import torch 
from torch.autograd import Variable 
import torch.nn.functional as F 
import matplotlib.pyplot as plt 
 
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) #  1       2    
y = x.pow(2) + 0.2 * torch.rand(x.size()) 
 
#  tensor  Variable  
x, y = Variable(x), Variable(y) 
 
#plt.scatter(x.data.numpy(), y.data.numpy()) 
#plt.show() 
 
#              
class Net(torch.nn.Module): #   torch.nn.Module  
  def __init__(self, n_feature, n_hidden, n_output): 
    super(Net, self).__init__() #   Net    （  ）      
    #               
    #         Net       
    self.hidden = torch.nn.Linear(n_feature, n_hidden) #         
    self.predict = torch.nn.Linear(n_hidden, n_output) #         
 
  #                        
  def forward(self, x): 
    x = F.relu(self.hidden(x)) #          relu   
    x = self.predict(x) 
    return x 
 
#        
net = Net(1, 10, 1) 
print(net) #     net    
 
#            
optimizer = torch.optim.SGD(net.parameters(), lr=0.5) #            
loss_function = torch.nn.MSELoss() #        
 
#          
plt.ion()  #          
plt.show() 
 
for t in range(300): 
  prediction = net(x) #    x  net，      
  loss = loss_function(prediction, y) #        ，           
  optimizer.zero_grad() #             
  loss.backward() #       ，          
  optimizer.step() #            net.parameters() 
 
  #         
  if (t+1) % 10 == 0: 
    plt.cla() 
    plt.scatter(x.data.numpy(), y.data.numpy()) 
    plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5) 
    plt.text(0.5, 0, 'L=%.4f' % loss.data[0], fontdict={'size': 20, 'color': 'red'}) 
    plt.pause(0.1) 

먼저 소음 이 있 는 2 차 함수 적합 데 이 터 를 만들어 Variable 에 넣 습 니 다.신경 네트워크 를 구축 하 는 클래스 Net 를 정의 하고 torch.nn.Module 클래스 를 계승 합 니 다.Net 류 의 구조 방법 에 서 는 뉴 런,숨겨 진 층 뉴 런,출력 뉴 런 의 수 를 입력 하 는 매개 변 수 를 정의 하고 슈퍼()방법 으로 Net 부모 류 의 구조 방법 을 얻어 속성 적 인 방식 으로 Net 의 각 층 의 구조 형식 을 정의 합 니 다.Net 의 forward()방법 을 정의 하여 각 층 의 신경 원 을 완전한 신경 망 앞 방향 으로 구축 합 니 다.
Net 클래스 를 정의 한 후 신경 망 인 스 턴 스 를 정의 합 니 다.Net 클래스 인 스 턴 스 는 신경 망 의 구조 정 보 를 직접 인쇄 하여 출력 할 수 있 습 니 다.이 어 신경 망 의 최적화 기와 손실 함 수 를 정의 한다.이 정 의 를 내리 면 훈련 을 할 수 있 습 니 다.optimizer.zero_grad(),loss.backward(),optimizer.step()는 각각 이전 단계 의 업데이트 매개 변수 값 을 비우 고 오차 의 역방향 전 파 를 하 며 새로운 업데이트 매개 변수 값 을 계산 하고 계 산 된 업데이트 값 을 net.parameters()에 부여 합 니 다.반복 훈련 과정.
실행 결과:
Net (
 (hidden): Linear (1 -> 10)
 (predict): Linear (10 -> 1)
)

3.PyTorch 는 간단 한 분 류 를 실현 합 니 다.
전체 코드:

import torch 
from torch.autograd import Variable 
import torch.nn.functional as F 
import matplotlib.pyplot as plt 
 
#      
#     2  100    ，      ，    y0=0 y1=1    ，  cat      
n_data = torch.ones(100,2) 
# torch.normal(means, std=1.0, out=None) 
x0 = torch.normal(2*n_data, 1) #  tensor       tensor      ，      
y0 = torch.zeros(100) 
x1 = torch.normal(-2*n_data, 1) 
y1 = torch.ones(100) 
 
x = torch.cat((x0, x1), 0).type(torch.FloatTensor) #   （  ） 
y = torch.cat((y0, y1), 0).type(torch.LongTensor) 
 
#   Variable  
x, y = Variable(x), Variable(y) 
 
class Net(torch.nn.Module): 
  def __init__(self, n_feature, n_hidden, n_output): 
    super(Net, self).__init__() 
    self.hidden = torch.nn.Linear(n_feature, n_hidden) 
    self.out = torch.nn.Linear(n_hidden, n_output) 
 
  def forward(self, x): 
    x = F.relu(self.hidden(x)) 
    x = self.out(x) 
    return x 
 
net = Net(n_feature=2, n_hidden=10, n_output=2) 
print(net) 
 
optimizer = torch.optim.SGD(net.parameters(), lr=0.012) 
loss_func = torch.nn.CrossEntropyLoss() 
 
plt.ion() 
plt.show() 
 
for t in range(100): 
  out = net(x) 
  loss = loss_func(out, y) # loss                y   ，  softmax    
 
  optimizer.zero_grad() 
  loss.backward() 
  optimizer.step() 
 
  if t % 2 == 0: 
    plt.cla() 
    #      softmax                  
    # torch.max            ，             
    prediction = torch.max(F.softmax(out), 1)[1] #   1             
    pred_y = prediction.data.numpy().squeeze() 
    target_y = y.data.numpy() 
    plt.scatter(x.data.numpy()[:, 0], x.data.numpy()[:, 1], c=pred_y, s=100, lw=0, cmap='RdYlGn') 
    accuracy = sum(pred_y == target_y)/200 #              
    plt.text(1.5, -4, 'Accu=%.2f' % accuracy, fontdict={'size': 20, 'color': 'red'}) 
    plt.pause(0.1) 
 
plt.ioff() 
plt.show() 

신경 망 구조 부분의 넷 류 는 앞의 회귀 부분의 구조 와 같다.
주의해 야 할 것 은 순환 교체 훈련 부분 에서 out 은 신경 망 의 출력 결과 로 정의 하고 오차 loss 를 계산 할 때 one-hot 형식 을 사용 하 는 것 이 아니 라 loss 는 out 과 y 에 있 는 torch.nn.Cross Entropy Loss()로 정의 하 며 예측 치 prediction 은 out 이 Softmax 를 거 친 후(결 과 를 확률 값 으로 전환)의 결과 로 정의 합 니 다.
실행 결과:
Net (
 (hidden): Linear (2 -> 10)
  (out):Linear (10 -> 2)
)

보충 지식
1.슈퍼()함수
Net 류 의 구조 방법 을 정의 할 때 슈퍼(Net,self)를 사 용 했 습 니 다.init__()문 구 는 현재 클래스 와 대상 을 슈퍼 함수 의 매개 변수 로 사용 합 니 다.이 문 구 는 Net 류 의 구조 방법 으로 초 클래스(부모 클래스)의 구조 방법 을 얻 게 하 는 기능 입 니 다.Net 류 에 대한 단독 정의 구조 방법 에 영향 을 주지 않 고 Net 류 의 부모 클래스 가 무엇 인지 주목 할 필요 가 없습니다.Net 류 의 부모 클래스 를 수정 하려 면 class 문장의 내용 만 수정 하면 됩 니 다.
2. torch.normal()
torch.normal()은 세 가지 상황 으로 나 눌 수 있 습 니 다.(1)torch.normal(means,std,out=None)에서 means 와 std 는 모두 Tensor 입 니 다.이들 의 모양 은 같 지 않 아 도 되 지만 Tensor 안의 요소 수량 은 같 아야 합 니 다.이에 대응 하 는 요 소 는 출력 된 각 요소 의 평균 값 과 표준 차이 입 니 다.(2)torch.normal(mean=0.0,std,out=None)에서 mean 은 정의 가능 한 float 로 각 요소 가 이 평균 값 을 공유 합 니 다.(3)torch.normal(means,std=1.0,out=None)에서 std 는 정의 가능 한 float 로 각 요소 가 이 표준 차 이 를 공유 합 니 다.
3. torch.cat(seq, dim=0)
torch.cat 는 여러 개의 Tensor 를 조립 하여 연결 할 수 있 으 며,dim 은 어느 차원 에서 조립 할 지 지정 합 니 다.
4. torch.max()
（1）torch.max(input)→ float
input 는 tensor 로 input 의 최대 값 인 float 를 되 돌려 줍 니 다.
（2）torch.max(input,dim, keepdim=True, max=None, max_indices=None) -> (Tensor, LongTensor)
지정 한 차원=dim 의 최대 값 과 이 차원 의 색인 값 을 되 돌려 줍 니 다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.