Vodič za PyTorch: regresija, primjer klasifikacije slike

Sažetak vodiča za Pytorch

U ovom vodiču za pytorch naučit ćete sve koncepte od nule. Ovaj vodič pokriva osnovne do napredne teme kao što su definicija pytorcha, prednosti i nedostaci pytorcha, usporedba, instalacija, okvir pytorcha, regresija i klasifikacija slika. Ovaj vodič za pytorch je potpuno besplatan.

Što je PyTorch?

PyTorch je biblioteka strojnog učenja temeljena na Torchu otvorenog koda za korištenje obrade prirodnog jezika Python. Sličan je NumPyju, ali sa snažnom GPU podrškom. Nudi dinamičke računalne grafikone koje možete mijenjati u pokretu uz pomoć autograda. PyTorch je također brži od nekih drugih okvira. Razvila ga je Facebookova AI Research Group 2016.

Prednosti i nedostaci PyTorcha

Slijede prednosti i nedostaci PyTorcha:

Prednosti PyTorcha

1. Jednostavna knjižnica
   PyTorch kod je jednostavan. Lako ga je razumjeti, a knjižnicu koristite odmah. Na primjer, pogledajte isječak koda u nastavku:

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

Kao što je gore spomenuto, možete lako definirati mrežni model i možete brzo razumjeti kod bez puno obuke.

2. Dinamički računalni grafikon

Izvor slike: Istraživanje dubokog učenja s PyTorchom

Pytorch nudi Dynamic Computational Graph (DAG). Računalni grafovi način su izražavanja matematičkih izraza u modelima grafova ili teorijama kao što su čvorovi i rubovi. Čvor će izvršiti matematičku operaciju, a rub je tenzor koji će se unijeti u čvorove i prenosi izlaz čvora u tenzoru.

DAG je graf koji ima proizvoljan oblik i može obavljati operacije između različitih ulaznih grafova. Svakim ponavljanjem stvara se novi graf. Dakle, moguće je imati istu strukturu grafa ili stvoriti novi graf s različitim operacijama, ili to možemo nazvati dinamičkim grafom.

3. Bolja izvedba

Zajednice i istraživači, mjerite i usporedite okvire da vidite koji je brži. GitHub repo Referentna vrijednost za Deep Learning Frameworks i GPU-ove izvijestio je da je PyTorch brži od drugog okvira u smislu obrađenih slika u sekundi.

Kao što možete vidjeti ispod, usporedni grafikoni s vgg16 i resnet152

4. Domorodac Python

PyTorch se više temelji na pythonu. Na primjer, ako želite uvježbati model, možete koristiti izvorni tok kontrole kao što su petlje i rekurzije bez potrebe za dodavanjem više posebnih varijabli ili sesija da biste ih mogli pokrenuti. Ovo je vrlo korisno za proces obuke.

Pytorch također implementira imperativno programiranje i definitivno je fleksibilniji. Dakle, moguće je ispisati vrijednost tenzora usred procesa izračunavanja.

Nedostatak PyTorcha

PyTorch zahtijeva aplikacije trećih strana za vizualizaciju. Također mu je potreban API poslužitelj za proizvodnju.

Zatim ćemo u ovom vodiču za PyTorch naučiti o razlici između PyTorcha i TensorFlowa.

PyTorch vs. Tensorflow

Parametar	PyTorch	Tenzor protok
Definicija modela	Model je definiran u podklasi i nudi paket jednostavan za korištenje	Model je definiran s mnogo, a vi morate razumjeti sintaksu
GPU podrška	Da	Da
Vrsta grafikona	Dinamičan	statički
Alati	Nema alata za vizualizaciju	Možete koristiti alat za vizualizaciju Tensorboard
Zajednica	Zajednica i dalje raste	Velike aktivne zajednice

Instaliranje PyTorcha

Linux

Jednostavno ga je instalirati u Linuxu. Možete odabrati korištenje virtualnog okruženja ili ga instalirati izravno s root pristupom. Upišite ovu naredbu u terminal

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker je jedna od platformi u Amazon Web usluge koji nudi snažan stroj za strojno učenje s unaprijed instaliranim konfiguracijama dubokog učenja za podatkovne znanstvenike ili programere za izradu, obuku i implementaciju modela u bilo kojoj mjeri.

Prvo otvorite Amazon Sagemaker konzolu i kliknite na Stvori instancu bilježnice i ispunite sve detalje za svoju bilježnicu.

Sljedeći korak, kliknite na Otvori kako biste pokrenuli svoju bilježnicu.

Konačno, In Jupyter, Kliknite Novo i odaberite conda_pytorch_p36 i spremni ste za korištenje svoje instance prijenosnog računala s instaliranim Pytorchom.

Zatim ćemo u ovom vodiču za PyTorch naučiti o osnovama PyTorch okvira.

Osnove PyTorch okvira

Naučimo osnovne koncepte PyTorcha prije nego što duboko zaronimo. PyTorch koristi Tensor za svaku varijablu slično numpyjevom ndarrayu, ali s podrškom za GPU računanje. Ovdje ćemo objasniti mrežni model, funkciju gubitka, Backprop i Optimizer.

Model mreže

Mreža se može konstruirati podklasom baklje.nn. Postoje 2 glavna dijela,

1. Prvi dio je definiranje parametara i slojeva koje ćete koristiti
2. Drugi dio je glavni zadatak koji se zove prosljeđivanje procesa koji će uzeti ulaz i predvidjeti izlaz.

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

Kao što možete vidjeti gore, kreirate klasu nn.Module pod nazivom Model. Sadrži 2 Conv2d sloja i linearni sloj. Prvi sloj conv2d ima ulaz 3 i izlazni oblik 20. Drugi sloj će uzeti ulaz 20 i proizvest će izlazni oblik 40. Posljednji sloj je potpuno povezani sloj u obliku 320 i proizvest će izlaz od 10.

Proces prosljeđivanja će uzeti ulaz X i unijeti ga u sloj conv1 i izvršiti ReLU funkciju,

Slično će hraniti i sloj conv2. Nakon toga, x će se preoblikovati u (-1, 320) i unijeti u konačni FC sloj. Prije nego što pošaljete izlaz, upotrijebit ćete funkciju aktivacije softmax.

Autograd automatski definira proces unatrag, tako da trebate definirati samo proces naprijed.

Funkcija gubitka

Funkcija gubitaka koristi se za mjerenje koliko dobro model predviđanja može predvidjeti očekivane rezultate. PyTorch već ima mnogo standardnih funkcija gubitka u modulu torch.nn. Na primjer, možete upotrijebiti Cross-Entropy Loss za rješavanje problema klasifikacije PyTorcha za više klasa. Jednostavno je definirati funkciju gubitka i izračunati gubitke:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Lako je koristiti vlastiti izračun funkcije gubitka s PyTorchom.

Podupirač za leđa

Da biste izvršili povratno širenje, jednostavno pozovite los.backward(). Pogreška će se izračunati, ali ne zaboravite izbrisati postojeći gradijent pomoću zero_grad()

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

optimizaciju

Torch.optim pruža uobičajene algoritme optimizacije. Optimizator možete definirati jednostavnim korakom:

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

Morate proslijediti parametre mrežnog modela i stopu učenja tako da će se u svakoj iteraciji parametri ažurirati nakon procesa povratne podrške.

Jednostavna regresija s PyTorchom

Naučimo jednostavnu regresiju s primjerima PyTorcha:

Korak 1) Stvaranje našeg mrežnog modela

Naš mrežni model je jednostavan linearni sloj s ulaznim i izlaznim oblikom 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)

A mrežni izlaz bi trebao biti ovakav

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

Korak 2) Testni podaci

Prije nego što započnete proces obuke, morate znati naše podatke. Napravite slučajnu funkciju da testirate naš model. 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()

Ovo je dijagram raspršenosti naše funkcije:

Prije nego započnete proces obuke, trebate pretvoriti niz numpy u varijable koje podržavaju Torch i autograd kao što je prikazano u donjem primjeru PyTorch regresije.

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

Korak 3) Optimizator i gubitak

Zatim biste trebali definirati Optimizer i Loss Function za naš proces obuke.

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

Korak 4) Trening

Sada započnimo naš proces obuke. S epohom od 250 ponavljat ćete naše podatke kako biste pronašli najbolju vrijednost za naše hiperparametre.

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

Korak 5) Rezultat

Kao što možete vidjeti u nastavku, uspješno ste izveli PyTorch regresiju s neuronskom mrežom. Zapravo, pri svakoj iteraciji, crvena linija u dijagramu će se ažurirati i promijeniti svoj položaj kako bi odgovarala podacima. Ali na ovoj slici prikazuje vam samo konačni rezultat kao što je prikazano u donjem primjeru PyTorcha:

Primjer klasifikacije slike s PyTorchom

Jedna od popularnih metoda za učenje osnova duboko učenje je s MNIST skupom podataka. To je "Hello World" u dubokom učenju. Skup podataka sadrži rukom pisane brojeve od 0 – 9 s ukupno 60,000 uzoraka za obuku i 10,000 uzoraka za testiranje koji su već označeni veličinom od 28×28 piksela.

Korak 1) Predobradite podatke

U prvom koraku ovog primjera klasifikacije PyTorcha učitat ćete skup podataka pomoću modula torchvision.

Prije nego započnete proces obuke, morate razumjeti podatke. Torchvision će učitati skup podataka i transformirati slike s odgovarajućim zahtjevima za mrežu kao što su oblik i normalizacija slika.

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

Funkcija transformacije pretvara slike u tenzor i normalizira vrijednost. Funkcija torchvision.transforms.MNIST će preuzeti skup podataka (ako nije dostupan) u direktoriju, postaviti skup podataka za obuku ako je potrebno i izvršiti proces transformacije.

Da biste vizualizirali skup podataka, koristite data_iterator za dobivanje sljedeće serije slika i oznaka. Koristite matplot za iscrtavanje ovih slika i njihove odgovarajuće oznake. Kao što možete vidjeti ispod naših slika i njihovih oznaka.

Korak 2) Konfiguracija mrežnog modela

U ovom primjeru PyTorcha izradit ćete jednostavnu neuronsku mrežu za PyTorch klasifikaciju slika.

Ovdje vam predstavljamo još jedan način za stvaranje mrežnog modela u PyTorchu. Koristit ćemo nn.Sequential da napravimo model sekvence umjesto da napravimo podklasu od 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)

Ovo je rezultat našeg mrežnog modela

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

Objašnjenje mreže

1. Slijed je da je prvi sloj Conv2D sloj s ulaznim oblikom 1 i izlaznim oblikom 10 s veličinom kernela 5
2. Zatim, imate MaxPool2D sloj
3. Funkcija aktivacije ReLU
4. Dropout sloj za ispuštanje vrijednosti male vjerojatnosti.
5. Zatim drugi Conv2d s ulaznim oblikom 10 iz posljednjeg sloja i izlaznim oblikom 20 s veličinom kernela 5
6. Zatim sloj MaxPool2d
7. ReLU aktivacijska funkcija.
8. Nakon toga ćete izravnati tenzor prije nego što ga unesete u sloj Linear
9. Linearni sloj će mapirati naš izlaz na drugom linearnom sloju s funkcijom aktivacije softmax

Korak 3) Uvježbajte model

Prije nego što započnete proces obuke, potrebno je postaviti kriterij i funkciju optimizatora.

Za kriterij ćete koristiti CrossEntropyLoss. Za Optimizer ćete koristiti SGD sa stopom učenja od 0.001 i zamahom od 0.9 kao što je prikazano u donjem primjeru PyTorcha.

import torch.optim as optim

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

Proces prosljeđivanja će uzeti ulazni oblik i proslijediti ga prvom sloju conv2d. Zatim će se odatle unijeti u maxpool2d i konačno staviti u ReLU aktivacijsku funkciju. Isti proces će se dogoditi u drugom sloju conv2d. Nakon toga, ulaz će se preoblikovati u (-1,320) i unijeti u fc sloj za predviđanje izlaza.

Sada ćete započeti proces obuke. Iterirati ćete kroz naš skup podataka 2 puta ili s epohom od 2 i ispisati trenutni gubitak na svakoj seriji od 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

U svakoj epohi, popisivač će dobiti sljedeću torku unosa i odgovarajuće oznake. Prije nego što unosimo podatke u naš mrežni model, moramo očistiti prethodni gradijent. Ovo je potrebno jer će se nakon procesa unatrag (postupak širenja unazad), gradijent akumulirati umjesto da se zamijeni. Zatim ćemo izračunati gubitke od predviđenog outputa iz očekivanog outputa. Nakon toga, izvršit ćemo povratno širenje kako bismo izračunali gradijent, i na kraju ćemo ažurirati parametre.

Ovo je rezultat procesa obuke

[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

Korak 4) Testirajte model

Nakon što uvježbate naš model, trebate testirati ili procijeniti s drugim skupovima slika.

Koristit ćemo iterator za test_loader, a on će generirati skup slika i oznaka koje će se proslijediti uvježbanom modelu. Prikazat će se predviđeni rezultat i usporediti s očekivanim rezultatom.

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

rezime

• PyTorch je temeljen na Torchu otvorenog koda Strojno učenje knjižnica za obrada prirodnog jezika koristeći Python.
• Prednosti PyTorcha: 1) Jednostavna biblioteka, 2) Dinamički računalni grafikon, 3) Bolja izvedba, 4) Nativni Python
• PyTorch koristi Tensor za svaku varijablu slično numpyjevom ndarrayu, ali s podrškom za GPU računanje.
• Jedna od popularnih metoda za učenje osnova dubokog učenja je skup podataka MNIST.