Tutorial PyTorch

Rezumatul tutorialului Pytorch

În acest tutorial pytorch, veți învăța toate conceptele de la zero. Acest tutorial acoperă subiecte de la bază până la avansate, cum ar fi definiția pytorch, avantajele și dezavantajele pytorch, compararea, instalarea, cadrul pytorch, regresia și clasificarea imaginilor. Acest tutorial pytorch este absolut gratuit.

Ce este PyTorch?

PyTorch este o bibliotecă de învățare automată bazată pe Torch cu sursă deschisă pentru utilizarea procesării limbajului natural Python. Este similar cu NumPy, dar cu suport puternic GPU. Oferă grafice computaționale dinamice pe care le puteți modifica din mers cu ajutorul autogradului. PyTorch este, de asemenea, mai rapid decât alte cadre. A fost dezvoltat de Grupul de cercetare AI al Facebook în 2016.

Avantajele și dezavantajele PyTorch

Următoarele sunt avantajele și dezavantajele PyTorch:

Avantajele PyTorch

1. Biblioteca simplă
   Codul PyTorch este simplu. Este ușor de înțeles și utilizați biblioteca instantaneu. De exemplu, aruncați o privire la fragmentul de cod de mai jos:

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

După cum am menționat mai sus, puteți defini cu ușurință modelul de rețea și puteți înțelege rapid codul fără prea multă pregătire.

2. Graficul de calcul dinamic

Sursa imagine: Exploring Deep Learning cu PyTorch

Pytorch oferă Dynamic Computational Graph (DAG). Graficele computaționale reprezintă o modalitate de a exprima expresii matematice în modele de grafice sau în teorii, cum ar fi nodurile și muchiile. Nodul va face operația matematică, iar muchia este un Tensor care va fi introdus în noduri și va transporta ieșirea nodului în Tensor.

DAG este un grafic care are o formă arbitrară și capabil să facă operații între diferite grafice de intrare. La fiecare iterație, este creat un nou grafic. Deci, este posibil să aveți aceeași structură de grafic sau să creați un nou grafic cu o operație diferită, sau îl putem numi un grafic dinamic.

3. Performanță mai bună

Comunitățile și cercetătorii, comparați și comparați cadrele pentru a vedea care dintre ele este mai rapidă. Un depozit GitHub Benchmark privind cadrele de învățare profundă și GPU-uri a raportat că PyTorch este mai rapid decât celălalt cadru în ceea ce privește imaginile procesate pe secundă.

După cum puteți vedea mai jos, graficele de comparație cu vgg16 și resnet152

4. Nativ Python

PyTorch se bazează mai mult pe python. De exemplu, dacă doriți să antrenați un model, puteți utiliza fluxul de control nativ, cum ar fi bucla și recursiuni, fără a fi nevoie să adăugați mai multe variabile sau sesiuni speciale pentru a le putea rula. Acest lucru este foarte util pentru procesul de instruire.

Pytorch implementează și programarea imperativă și este cu siguranță mai flexibil. Deci, este posibil să tipăriți valoarea tensorului în mijlocul unui proces de calcul.

Dezavantajul PyTorch

PyTorch necesită aplicații terțe pentru vizualizare. De asemenea, are nevoie de un server API pentru producție.

În continuare, în acest tutorial PyTorch, vom afla despre diferența dintre PyTorch și TensorFlow.

PyTorch vs. Tensorflow

Parametru	PyTorch	flux tensor
Definiția modelului	Modelul este definit într-o subclasă și oferă pachet ușor de utilizat	Modelul este definit cu multe și trebuie să înțelegeți sintaxa
Suport GPU	Da	Da
Tipul graficului	Dinamic	Static
Instrumente	Nici un instrument de vizualizare	Puteți utiliza instrumentul de vizualizare Tensorboard
Comunitate	Comunitatea încă în creștere	Comunități mari active

Instalarea PyTorch

Linux

Este simplu să îl instalați în Linux. Puteți alege să utilizați un mediu virtual sau să îl instalați direct cu acces root. Tastați această comandă în terminal

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker este una dintre platformele din Amazon Serviciu web care oferă un motor puternic de învățare automată cu configurații de învățare profundă preinstalate pentru ca cercetătorii de date sau dezvoltatorii să construiască, să antreneze și să implementeze modele la orice scară.

Mai întâi Deschideți Amazon Sagemaker console și faceți clic pe Creare o instanță de blocnotes și completați toate detaliile pentru blocnotesul dvs.

Pasul următor, faceți clic pe Deschidere pentru a lansa instanța de notebook.

În cele din urmă, în Jupyter, Faceți clic pe Nou și alegeți conda_pytorch_p36 și sunteți gata să utilizați instanța de notebook cu Pytorch instalat.

În continuare, în acest tutorial PyTorch, vom afla despre elementele de bază ale cadrului PyTorch.

Noțiuni de bază ale cadrului PyTorch

Să învățăm conceptele de bază ale PyTorch înainte de a ne arunca în adâncime. PyTorch folosește Tensor pentru fiecare variabilă similară cu ndarray-ul lui numpy, dar cu suport de calcul GPU. Aici vom explica modelul de rețea, funcția de pierdere, Backprop și Optimizer.

Model de rețea

Rețeaua poate fi construită prin subclasificarea torței.nn. Există 2 părți principale,

1. Prima parte este să definiți parametrii și straturile pe care le veți folosi
2. A doua parte este sarcina principală numită proces de avans, care va prelua o intrare și va prezice rezultatul.

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()

După cum puteți vedea mai sus, creați o clasă de nn.Module numită Model. Conține 2 straturi Conv2d și un strat Linear. Primul strat conv2d are o intrare de 3 și forma de ieșire de 20. Al doilea strat va avea o intrare de 20 și va produce o formă de ieșire de 40. Ultimul strat este un strat complet conectat în forma de 320 și va produce o ieșire de 10.

Procesul înainte va prelua o intrare de X și o va alimenta stratul conv1 și va efectua funcția ReLU,

În mod similar, va alimenta și stratul conv2. După aceea, x-ul va fi remodelat în (-1, 320) și va fi alimentat în stratul FC final. Înainte de a trimite ieșirea, veți folosi funcția de activare softmax.

Procesul înapoi este definit automat de autograd, așa că trebuie doar să definiți procesul înainte.

Funcția de pierdere

Funcția de pierdere este utilizată pentru a măsura cât de bine este capabil modelul de predicție să prezică rezultatele așteptate. PyTorch are deja multe funcții standard de pierdere în modulul torch.nn. De exemplu, puteți utiliza Pierderea încrucișată pentru a rezolva o problemă de clasificare PyTorch cu mai multe clase. Este ușor să definiți funcția de pierdere și să calculați pierderile:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Este ușor să utilizați propriul calcul al funcției de pierdere cu PyTorch.

Propul din spate

Pentru a efectua backpropagation, apelați pur și simplu los.backward(). Eroarea va fi calculată, dar nu uitați să ștergeți gradientul existent cu zero_grad()

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

Instrumentul de optimizare a

Torch.optim oferă algoritmi comuni de optimizare. Puteți defini un optimizator cu un pas simplu:

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

Trebuie să treceți parametrii modelului de rețea și rata de învățare, astfel încât la fiecare iterație parametrii să fie actualizați după procesul de backprop.

Regresie simplă cu PyTorch

Să învățăm regresia simplă cu exemple PyTorch:

Pasul 1) Crearea modelului nostru de rețea

Modelul nostru de rețea este un strat liniar simplu, cu o formă de intrare și o formă de ieșire de 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)

Și ieșirea din rețea ar trebui să fie așa

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

Pasul 2) Datele de testare

Înainte de a începe procesul de formare, trebuie să cunoașteți datele noastre. Faceți o funcție aleatorie pentru a testa modelul nostru. Y = x³ sin(x)+ 3x+0.8 rand(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()

Iată diagrama de dispersie a funcției noastre:

Înainte de a începe procesul de antrenament, trebuie să convertiți matricea numpy în Variabile acceptate de Torch și autograd, așa cum se arată în exemplul de regresie PyTorch de mai jos.

# 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)

Pasul 3) Optimizer și pierdere

În continuare, ar trebui să definiți Optimizatorul și Funcția de pierdere pentru procesul nostru de antrenament.

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

Pasul 4) Antrenament

Acum să începem procesul nostru de formare. Cu o epocă de 250, veți repeta datele noastre pentru a găsi cea mai bună valoare pentru hiperparametrii noștri.

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()

Pasul 5) Rezultat

După cum puteți vedea mai jos, ați efectuat cu succes regresia PyTorch cu o rețea neuronală. De fapt, la fiecare iterație, linia roșie din diagramă se va actualiza și își va schimba poziția pentru a se potrivi cu datele. Dar în această imagine, vă arată doar rezultatul final, așa cum se arată în exemplul PyTorch de mai jos:

Exemplu de clasificare a imaginilor cu PyTorch

Una dintre metodele populare de a învăța elementele de bază învățare profundă este cu setul de date MNIST. Este „Hello World” în învățarea profundă. Setul de date conține numere scrise de mână de la 0 la 9, cu un total de 60,000 de mostre de antrenament și 10,000 de mostre de testare care sunt deja etichetate cu dimensiunea de 28×28 pixeli.

Pasul 1) Preprocesează datele

În primul pas al acestui exemplu de clasificare PyTorch, veți încărca setul de date folosind modulul torchvision.

Înainte de a începe procesul de formare, trebuie să înțelegeți datele. Torchvision va încărca setul de date și va transforma imaginile cu cerințele adecvate pentru rețea, cum ar fi forma și normalizarea imaginilor.

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()

Funcția de transformare convertește imaginile în tensor și normalizează valoarea. Funcția torchvision.transforms.MNIST, va descărca setul de date (dacă nu este disponibil) în director, va seta setul de date pentru antrenament dacă este necesar și va face procesul de transformare.

Pentru a vizualiza setul de date, utilizați data_iterator pentru a obține următorul lot de imagini și etichete. Folosiți matplot pentru a reprezenta aceste imagini și eticheta corespunzătoare. După cum puteți vedea mai jos imaginile noastre și etichetele lor.

Pasul 2) Configurarea modelului de rețea

Acum, în acest exemplu PyTorch, veți crea o rețea neuronală simplă pentru clasificarea imaginilor PyTorch.

Aici, vă prezentăm o altă modalitate de a crea modelul de rețea în PyTorch. Vom folosi nn.Sequential pentru a face un model de secvență în loc să facem o subclasă de nn.Module.

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)

Iată rezultatul modelului nostru de rețea

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()
)

Explicația rețelei

1. Secvența este că primul strat este un strat Conv2D cu o formă de intrare de 1 și o formă de ieșire de 10 cu o dimensiune a nucleului de 5
2. Apoi, aveți un strat MaxPool2D
3. O funcție de activare ReLU
4. un strat de abandon pentru a elimina valorile cu probabilitate scăzută.
5. Apoi un al doilea Conv2d cu forma de intrare de 10 din ultimul strat și forma de ieșire de 20 cu o dimensiune a nucleului de 5
6. Apoi un strat MaxPool2d
7. Funcția de activare ReLU.
8. După aceea, veți aplatiza tensorul înainte de a-l introduce în stratul Linear
9. Stratul liniar va mapa rezultatul nostru la al doilea strat liniar cu funcția de activare softmax

Pasul 3) Antrenează modelul

Înainte de a începe procesul de antrenament, este necesar să configurați funcția de criteriu și de optimizare.

Pentru criteriu, veți folosi CrossEntropyLoss. Pentru Optimizer, veți folosi SGD cu o rată de învățare de 0.001 și un impuls de 0.9, așa cum se arată în exemplul PyTorch de mai jos.

import torch.optim as optim

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

Procesul de transmitere va lua forma de intrare și o va trece la primul strat conv2d. Apoi, de acolo, va fi alimentat în maxpool2d și, în final, va fi introdus în funcția de activare ReLU. Același proces va avea loc în al doilea strat conv2d. După aceea, intrarea va fi remodelată în (-1,320) și va fi alimentată în stratul fc pentru a prezice ieșirea.

Acum, veți începe procesul de antrenament. Veți parcurge setul de date de 2 ori sau cu o epocă de 2 și veți imprima pierderea curentă la fiecare 2000 de lot.

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

La fiecare epocă, enumeratorul va primi următorul tuplu de intrare și etichetele corespunzătoare. Înainte de a alimenta intrarea în modelul nostru de rețea, trebuie să ștergem gradientul anterior. Acest lucru este necesar deoarece după procesul invers (procesul de backpropagation), gradientul va fi acumulat în loc să fie înlocuit. Apoi, vom calcula pierderile de la ieșirea prezisă de la ieșirea așteptată. După aceea, vom face o retropropagare pentru a calcula gradientul și, în final, vom actualiza parametrii.

Iată rezultatul procesului de instruire

[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

Pasul 4) Testați modelul

După ce ne instruiți modelul, trebuie să testați sau să evaluați cu alte seturi de imagini.

Vom folosi un iterator pentru test_loader și va genera un lot de imagini și etichete care vor fi transmise modelului antrenat. Ieșirea estimată va fi afișată și comparată cu rezultatul așteptat.

#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()

Rezumat

• PyTorch este un open-source bazat pe Torch Invatare mecanica biblioteca pentru prelucrarea limbajului natural folosind Python.
• Avantajele PyTorch: 1) Bibliotecă simplă, 2) Grafic de calcul dinamic, 3) Performanță mai bună, 4) Nativ Python
• PyTorch folosește Tensor pentru fiecare variabilă similară cu ndarray-ul lui numpy, dar cu suport de calcul GPU.
• Una dintre metodele populare de a învăța elementele de bază ale învățării profunde este cu setul de date MNIST.