PyTorch 튜토리얼: 회귀, 이미지 분류 예

Pytorch 튜토리얼 요약

이 pytorch 튜토리얼에서는 모든 개념을 처음부터 배우게 됩니다. 이 튜토리얼은 pytorch 정의, pytorch의 장단점, 비교, 설치, pytorch 프레임워크, 회귀, 이미지 분류와 같은 기본에서 고급 주제까지 다룹니다. 이 pytorch 튜토리얼은 완전 무료입니다.

파이토치는 무엇입니까?

파이 토치 다음을 사용하여 자연어 처리를 위한 오픈 소스 Torch 기반 기계 학습 라이브러리입니다. Python. NumPy와 유사하지만 강력한 GPU 지원을 제공합니다. autograd의 도움으로 이동 중에도 수정할 수 있는 동적 계산 그래프를 제공합니다. PyTorch는 다른 프레임워크보다 빠릅니다. 2016년 페이스북 AI 연구그룹이 개발했다.

PyTorch의 장점과 단점

PyTorch의 장단점은 다음과 같습니다.

PyTorch의 장점

1. 간단한 라이브러리
   PyTorch 코드는 간단합니다. 이해하기 쉽고, 즉시 라이브러리를 사용할 수 있습니다. 예를 들어 아래 코드 조각을 살펴보세요.

class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

위에서 언급한 것처럼 네트워크 모델을 쉽게 정의할 수 있고, 많은 교육 없이도 코드를 빠르게 이해할 수 있습니다.

2. 동적 계산 그래프

이미지 출처: PyTorch를 사용한 딥 러닝 탐색

Pytorch는 Dynamic Computational Graph(DAG)를 제공합니다. Computational Graph는 노드와 에지와 같은 그래프 모델이나 이론에서 수학적 표현식을 표현하는 방법입니다. 노드는 수학적 연산을 수행하고 에지는 노드에 공급되고 텐서에서 노드의 출력을 전달하는 텐서입니다.

DAG는 임의의 모양을 유지하고 서로 다른 입력 그래프 간에 연산을 수행할 수 있는 그래프입니다. 모든 반복에서 새 그래프가 생성됩니다. 따라서 동일한 그래프 구조를 갖거나 다른 연산으로 새 그래프를 만들거나 동적 그래프라고 부를 수 있습니다.

3. 더 나은 성능

커뮤니티와 연구자들은 프레임워크를 벤치마킹하고 비교하여 어느 것이 더 빠른지 확인합니다. GitHub 저장소 딥 러닝 프레임워크 및 GPU에 대한 벤치마크 초당 이미지 처리 측면에서 PyTorch가 다른 프레임워크보다 빠르다고 보고했습니다.

아래에서 볼 수 있듯이 vgg16 및 resnet152와의 비교 그래프

4. 출신 Python

PyTorch는 Python 기반입니다. 예를 들어, 모델을 교육하려는 경우 실행을 위해 특수 변수나 세션을 추가할 필요 없이 루프 및 재귀와 같은 기본 제어 흐름을 사용할 수 있습니다. 이는 훈련 과정에 매우 도움이 됩니다.

Pytorch는 또한 명령형 프로그래밍을 구현하며 확실히 더 유연합니다. 따라서 계산 과정 중에 텐서 값을 출력하는 것이 가능합니다.

PyTorch의 단점

PyTorch에는 시각화를 위한 타사 애플리케이션이 필요합니다. 또한 프로덕션을 위한 API 서버도 필요합니다.

다음으로 이 PyTorch 튜토리얼에서는 PyTorch와 TensorFlow의 차이점에 대해 알아봅니다.

PyTorch 대. 텐서플로우

매개 변수	파이 토치	텐서 플로우
모델 정의	모델은 하위 클래스에 정의되어 있으며 사용하기 쉬운 패키지를 제공합니다.	모델은 여러 개로 정의되므로 구문을 이해해야 합니다.
GPU Support	가능	가능
그래프 유형	동적	정적인
도구	시각화 도구 없음	Tensorboard 시각화 도구를 사용할 수 있습니다
커뮤니티	커뮤니티는 계속 성장하고 있습니다	대규모 활성 커뮤니티

파이토치 설치

Linux

리눅스에 설치하는 방법은 간단합니다. 가상 환경을 사용하거나 루트 액세스로 직접 설치할 수 있습니다. 터미널에 이 명령을 입력하세요

pip3 install --upgrade torch torchvision

AWS 세이지메이커

Sagemaker는 플랫폼 중 하나입니다. Amazon 웹 서비스 이는 데이터 과학자 또는 개발자가 모든 규모의 모델을 구축, 교육 및 배포할 수 있도록 사전 설치된 딥 러닝 구성과 함께 강력한 기계 학습 엔진을 제공합니다.

먼저 열기 Amazon 현인 콘솔을 열고 노트북 인스턴스 만들기를 클릭한 후 노트북에 대한 모든 세부 정보를 입력합니다.

다음 단계에서는 열기를 클릭하여 노트북 인스턴스를 시작합니다.

마지막으로, Jupyter, 새로 만들기를 클릭하고 conda_pytorch_p36을 선택하면 Pytorch가 설치된 노트북 인스턴스를 사용할 준비가 됩니다.

다음으로 이 PyTorch 튜토리얼에서는 PyTorch 프레임워크 기본 사항에 대해 알아봅니다.

PyTorch 프레임워크 기본 사항

심층적으로 알아보기 전에 PyTorch의 기본 개념을 알아보겠습니다. PyTorch는 numpy의 ndarray와 비슷하게 모든 변수에 Tensor를 사용하지만 GPU 계산을 지원합니다. 여기서는 네트워크 모델, 손실 함수, Backprop, Optimizer에 대해 설명합니다.

네트워크 모델

네트워크는 torch.nn을 서브클래싱하여 구성할 수 있습니다. 2개의 주요 부분이 있습니다,

1. 첫 번째 부분은 사용할 매개변수와 레이어를 정의하는 것입니다.
2. 두 번째 부분은 입력을 받아 출력을 예측하는 정방향 프로세스라는 주요 작업입니다.

Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

위에서 볼 수 있듯이 Model이라는 nn.Module 클래스를 만듭니다. 여기에는 2개의 Conv2d 레이어와 2개의 선형 레이어가 포함되어 있습니다. 첫 번째 conv3d 레이어는 20의 입력과 20의 출력 형태를 취합니다. 두 번째 레이어는 40의 입력을 취하고 320의 출력 형태를 생성합니다. 마지막 레이어는 10 형태의 완전 연결 레이어이며 다음을 생성합니다. XNUMX의 출력.

순방향 프로세스는 X를 입력으로 받아 이를 conv1 계층에 공급하고 ReLU 기능을 수행합니다.

마찬가지로, CNN2 레이어에도 피드를 제공합니다. 그 후 x는 (-1, 320)으로 모양이 변경되어 최종 FC 레이어에 입력됩니다. 출력을 보내기 전에 소프트맥스 활성화 기능을 사용합니다.

Backward 프로세스는 autograd에 의해 자동으로 정의되므로 Forward 프로세스만 정의하면 됩니다.

손실 기능

손실 함수는 예측 모델이 예상 결과를 얼마나 잘 예측할 수 있는지 측정하는 데 사용됩니다. PyTorch에는 이미 torch.nn 모듈에 많은 표준 손실 기능이 있습니다. 예를 들어 교차 엔트로피 손실을 사용하여 다중 클래스 PyTorch 분류 문제를 해결할 수 있습니다. 손실 함수를 정의하고 손실을 계산하는 것은 쉽습니다.

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

PyTorch를 사용하면 자신만의 손실 함수 계산을 쉽게 사용할 수 있습니다.

역전파

역전파를 수행하려면 간단히 los.backward()를 호출하면 됩니다. 오류가 계산되지만 zero_grad()를 사용하여 기존 그래디언트를 지우는 것을 기억하세요.

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

최적화

torch.optim은 일반적인 최적화 알고리즘을 제공합니다. 간단한 단계로 최적화 프로그램을 정의할 수 있습니다.

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

매 반복마다 매개변수가 역전파 프로세스 후에 업데이트되도록 네트워크 모델 매개변수와 학습률을 전달해야 합니다.

PyTorch를 사용한 단순 회귀

PyTorch 예제를 통해 간단한 회귀를 배워보겠습니다.

1단계) 네트워크 모델 생성

우리의 네트워크 모델은 입력과 출력 모양이 1인 간단한 선형 레이어입니다.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

그리고 네트워크 출력은 다음과 같아야 합니다

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

2단계) 테스트 데이터

훈련 과정을 시작하기 전에 데이터를 알아야 합니다. 모델을 테스트하기 위해 임의의 함수를 만듭니다. Y = x³ 죄(x)+ 3x+0.8 랜드(100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

다음은 함수의 산점도입니다.

교육 프로세스를 시작하기 전에 아래 PyTorch 회귀 예제에 표시된 대로 numpy 배열을 Torch 및 autograd에서 지원하는 변수로 변환해야 합니다.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

3단계) ​​옵티마이저와 손실

다음으로 훈련 프로세스에 대한 최적화 도구와 손실 함수를 정의해야 합니다.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

4단계) 훈련

이제 훈련 과정을 시작하겠습니다. 에포크가 250이면 데이터를 반복하여 하이퍼파라미터에 대한 최상의 값을 찾습니다.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

5단계) 결과

아래에서 볼 수 있듯이 신경망을 사용하여 PyTorch 회귀를 성공적으로 수행했습니다. 실제로 매 반복마다 플롯의 빨간색 선이 업데이트되고 데이터에 맞게 위치가 변경됩니다. 하지만 이 그림에서는 아래 PyTorch 예제와 같이 최종 결과만 보여줍니다.

PyTorch를 사용한 이미지 분류 예

기초를 익히는 인기 있는 방법 중 하나 깊은 학습 MNIST 데이터셋을 사용합니다. 딥러닝의 "Hello World"입니다. 데이터셋에는 0~9까지의 손으로 쓴 숫자가 포함되어 있으며 총 60,000개의 학습 샘플과 10,000×28픽셀 크기로 이미 레이블이 지정된 28개의 테스트 샘플이 있습니다.

1단계) 데이터 전처리

이 PyTorch 분류 예제의 첫 번째 단계에서는 torchvision 모듈을 사용하여 데이터 세트를 로드합니다.

훈련 과정을 시작하기 전에 데이터를 이해해야 합니다. Torchvision은 데이터 세트를 로드하고 모양 및 이미지 정규화와 같은 네트워크에 대한 적절한 요구 사항으로 이미지를 변환합니다.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

변환 함수는 이미지를 텐서로 변환하고 값을 정규화합니다. torchvision.transforms.MNIST 함수는 디렉토리에 데이터 세트(사용할 수 없는 경우)를 다운로드하고, 필요한 경우 훈련용 데이터 세트를 설정하고 변환 프로세스를 수행합니다.

데이터세트를 시각화하려면 data_iterator를 사용하여 이미지와 라벨의 다음 배치를 가져옵니다. matplot을 사용하여 이러한 이미지와 적절한 레이블을 표시합니다. 아래에서 볼 수 있듯이 이미지와 라벨이 표시됩니다.

2단계) 네트워크 모델 구성

이제 이 PyTorch 예제에서는 PyTorch 이미지 분류를 위한 간단한 신경망을 만들어 보겠습니다.

여기서는 PyTorch에서 네트워크 모델을 생성하는 또 다른 방법을 소개합니다. nn.Module의 하위 클래스를 만드는 대신 nn.Sequential을 사용하여 시퀀스 모델을 만듭니다.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

다음은 네트워크 모델의 출력입니다.

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

네트워크 설명

1. 순서는 첫 번째 레이어가 입력 모양이 2이고 출력 모양이 1이고 커널 크기가 10인 Conv5D 레이어입니다.
2. 다음으로 MaxPool2D 레이어가 있습니다.
3. ReLU 활성화 함수
4. 낮은 확률 값을 삭제하는 드롭아웃 레이어.
5. 그런 다음 마지막 레이어의 입력 모양이 2이고 출력 모양이 10이고 커널 크기가 20인 두 번째 Conv5d
6. 다음 MaxPool2d 레이어
7. ReLU 활성화 함수.
8. 그런 다음 선형 레이어에 공급하기 전에 텐서를 평면화합니다.
9. 선형 레이어는 소프트맥스 활성화 함수를 사용하여 두 번째 선형 레이어에서 출력을 매핑합니다.

3단계) ​​모델 학습

학습 과정을 시작하기 전에 기준 및 최적화 기능을 설정해야 합니다.

기준에 대해 CrossEntropyLoss를 사용합니다. Optimizer에 대해 아래 PyTorch 예제에서 보듯이 학습률이 0.001이고 모멘텀이 0.9인 SGD를 사용합니다.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

순방향 프로세스는 입력 형태를 취하여 첫 번째 conv2d 레이어로 전달합니다. 그런 다음 거기에서 maxpool2d에 공급되고 마지막으로 ReLU 활성화 기능에 배치됩니다. 두 번째 conv2d 레이어에서도 동일한 프로세스가 발생합니다. 그 후 입력은 (-1,320)으로 재구성되고 fc 레이어에 공급되어 출력을 예측합니다.

이제 훈련 과정을 시작하겠습니다. 데이터 세트를 2번 또는 2세대로 반복하고 2000개 배치마다 현재 손실을 인쇄합니다.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

각 시대마다 열거자는 입력 및 해당 레이블의 다음 튜플을 가져옵니다. 네트워크 모델에 입력을 공급하기 전에 이전 그래디언트를 지워야 합니다. 이는 역방향 프로세스(역전파 프로세스) 후에 기울기가 대체되는 대신 누적되기 때문에 필요합니다. 그런 다음 예상 출력에서 ​​예측 출력의 손실을 계산합니다. 그런 다음 역전파를 수행하여 그래디언트를 계산하고 마지막으로 매개변수를 업데이트합니다.

학습 프로세스의 결과는 다음과 같습니다.

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

4단계) 모델 테스트

모델을 훈련한 후에는 다른 이미지 세트를 사용하여 테스트하거나 평가해야 합니다.

우리는 test_loader에 반복자를 사용할 것이고, 그것은 훈련된 모델에 전달될 이미지와 라벨의 배치를 생성할 것입니다. 예측된 출력이 표시되고 예상 출력과 비교될 것입니다.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

요약

• PyTorch는 오픈 소스 Torch 기반입니다. 기계 학습 라이브러리 자연어 처리 사용 Python.
• PyTorch의 장점: 1) 간단한 라이브러리, 2) 동적 계산 그래프, 3) 더 나은 성능, 4) 기본 Python
• PyTorch는 numpy의 ndarray와 유사하지만 GPU 계산을 지원하는 모든 변수에 Tensor를 사용합니다.
• 딥러닝의 기본을 학습하는 인기 있는 방법 중 하나는 MNIST 데이터세트를 사용하는 것입니다.