PyTorTutorialul cap.

Ce este PyTorh?

PyTorch este un open-source TorBibliotecă de învățare automată bazată pe ch pentru procesarea limbajului natural folosind PythonEste similar cu NumPy, dar cu suport puternic pentru GPU. Oferă grafice computaționale dinamice pe care le puteți modifica din mers cu ajutorul funcției Autograd. PyTorch este, de asemenea, mai rapid decât alte framework-uri. A fost dezvoltat de Grupul de Cercetare AI al Facebook în 2016.

Știind ce PyTorch oferă o perspectivă echilibrată asupra punctelor forte și dezavantajelor sale.

PyTorAvantaje și dezavantaje

Următoarele sunt avantajele și dezavantajele PyTorcH:

Avantajele PyTorch

1. Biblioteca simplă
   PyTorCodul ch este simplu. Este ușor de înțeles și folosești biblioteca instantaneu. De exemplu, aruncă 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 imaginii: Explorarea învățării profunde cu PyTorch

PyTorch oferă Grafuri Computaționale Dinamice (DAG). Grafurile computaționale sunt o modalitate de a exprima expresii matematice în modele grafice sau teorii, cum ar fi noduri și muchii. Nodul va efectua 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 framework î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 este mai mult bazat pe Python. De exemplu, dacă vrei să antrenezi un model, poți folosi un flux de control nativ, cum ar fi loo.ping și recursivități 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 antrenament.

PyTorch implementează și Programarea Imperativă, fiind cu siguranță mai flexibilă. Prin urmare, este posibil să se afișeze 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.

Următorul în acest PyTorÎn tutorialul ch, vom învăța despre diferența dintre PyTorch și TensorFlow.

PyTorch vs. TensorFlow

Având în vedere comparația, următorul pas este obținerea lui PyTorch care rulează local sau în cloud.

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.

Următorul în acest PyTortutorial ch, vom învăța despre PyTorNoțiuni de bază ale cadrului CH.

Odată instalarea finalizată, API-ul în sine este următoarea oprire.

PyTorNoțiuni de bază despre framework-ul ch

Să învățăm conceptele de bază ale PyTorînainte de a ne aprofunda. PyTorch folosește Tensor pentru fiecare variabilă, similar cu ndarray din 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 de entropie încrucișată pentru a rezolva o problemă Py multi-clasă.Torproblemă de clasificare ch. Este ușor să definim funcția de pierdere și să calculăm pierderile:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Este ușor să folosești 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.

Cea mai clară modalitate de a învăța API-ul este un exemplu mic, complet.

Regresie simplă cu PyTorch

Să învățăm regresie simplă cu PyTorexemple de ch:

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 Py de mai josTorexemplu de regresie ch.

# 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 executat cu succes PyTorRegresie ch cu o rețea neuronală. De fapt, la fiecare iterație, linia roșie din grafic se va actualiza și își va schimba poziția pentru a se potrivi datelor. Dar în această imagine, se afișează doar rezultatul final, așa cum se arată în diagrama Py de mai jos.Torexemplu ch:

Regresia este o încălzire; clasificarea imaginilor exersează mușchii de învățare profundă ai lui PyTorch.

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 prima etapă a acestui PyTorexemplu de clasificare ch, veți încărca setul de date folosind modulul torchvision.

Înainte de a începe procesul de antrenament, trebuie să înțelegeți datele. Torchvision va încărca setul de date și va transforma imaginile cu cerințele corespunzătoare 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 PyTorDe exemplu, veți crea o rețea neuronală simplă pentru PyTorClasificarea imaginilor ch.

Aici, vă prezentăm o altă modalitate de a crea modelul de rețea în PyTorcap. Vom folosi nn.Sequential pentru a crea un model de secvență în loc să creăm o subclasă a 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 utiliza CrossEntropyLoss. Pentru optimizator, veți utiliza SGD cu o rată de învățare de 0.001 și un impuls de 0.9, așa cum se arată în diagrama Py de mai jos.Torexemplu.

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

Întrebări frecvente