PyTorch handledning

Pytorch Tutorial Sammanfattning

I denna pytorch-handledning kommer du att lära dig alla begrepp från grunden. Denna handledning täcker grundläggande till avancerade ämnen som pytorch-definition, fördelar och nackdelar med pytorch, jämförelse, installation, pytorch-ramverk, regression och bildklassificering. Denna pytorch-handledning är helt gratis.

Vad är PyTorch?

PyTorch är ett Torch-baserat maskininlärningsbibliotek med öppen källkod för naturlig språkbehandling Python. Det liknar NumPy men med kraftfullt GPU-stöd. Den erbjuder Dynamic Computational Graphs som du kan modifiera när du är på språng med hjälp av autograd. PyTorch är också snabbare än vissa andra ramverk. Det utvecklades av Facebooks AI Research Group 2016.

PyTorch fördelar och nackdelar

Följande är fördelarna och nackdelarna med PyTorch:

Fördelar med PyTorch

1. Enkelt bibliotek
   PyTorch-koden är enkel. Det är lätt att förstå och du använder biblioteket direkt. Ta till exempel en titt på kodavsnittet nedan:

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

Som nämnts ovan kan du enkelt definiera nätverksmodellen och du kan förstå koden snabbt utan mycket träning.

2. Dynamisk beräkningsgraf

Bildkälla: Exploring Deep Learning med PyTorch

Pytorch erbjuder Dynamic Computational Graph (DAG). Beräkningsgrafer är ett sätt att uttrycka matematiska uttryck i grafmodeller eller teorier som noder och kanter. Noden kommer att utföra den matematiska operationen, och kanten är en Tensor som kommer att matas in i noderna och bär utdata från noden i Tensor.

DAG är en graf som håller godtycklig form och kan utföra operationer mellan olika inmatningsgrafer. Varje iteration skapas en ny graf. Så det är möjligt att ha samma grafstruktur eller skapa en ny graf med en annan operation, eller så kan vi kalla det en dynamisk graf.

3. Bättre prestanda

Gemenskaper och forskare, benchmark och jämför ramverk för att se vilken som är snabbare. En GitHub-repo Benchmark på Deep Learning Frameworks och GPU:er rapporterade att PyTorch är snabbare än det andra ramverket när det gäller bilder bearbetade per sekund.

Som du kan se nedan visar jämförelsegraferna med vgg16 och resnet152

4. Native Python

PyTorch är mer pythonbaserat. Om du till exempel vill träna en modell kan du använda native control flow som looping och rekursioner utan att behöva lägga till fler speciella variabler eller sessioner för att kunna köra dem. Detta är mycket användbart för utbildningsprocessen.

Pytorch implementerar också imperativ programmering, och det är definitivt mer flexibelt. Så det är möjligt att skriva ut tensorvärdet mitt i en beräkningsprocess.

Nackdelen med PyTorch

PyTorch kräver tredjepartsapplikationer för visualisering. Den behöver också en API-server för produktion.

Nästa i denna PyTorch-handledning kommer vi att lära oss om skillnaden mellan PyTorch och TensorFlow.

PyTorch vs. Tensorflöde

Parameter	PyTorch	Tensorflöde
Modelldefinition	Modellen är definierad i en underklass och erbjuder ett lättanvänt paket	Modellen är definierad med många, och du måste förstå syntaxen
GPU-support	Ja	Ja
Graftyp	Dynamisk	Statisk
verktyg	Inget visualiseringsverktyg	Du kan använda Tensorboard visualiseringsverktyg
Community	Samhället växer fortfarande	Stora aktiva samhällen

Installerar PyTorch

Linux

Det är enkelt att installera det i Linux. Du kan välja att använda en virtuell miljö eller installera den direkt med root-åtkomst. Skriv detta kommando i terminalen

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker är en av plattformarna i Amazon Webbtjänst som erbjuder en kraftfull maskininlärningsmotor med förinstallerade djupinlärningskonfigurationer för datavetare eller utvecklare att bygga, träna och distribuera modeller i vilken skala som helst.

Öppna först Amazon Sagemaker konsolen och klicka på Skapa anteckningsbokförekomst och fyll i alla detaljer för din anteckningsbok.

Nästa steg, klicka på Öppna för att starta din anteckningsbokförekomst.

Slutligen, In Jupyter, Klicka på Ny och välj conda_pytorch_p36 och du är redo att använda din notebook-instans med Pytorch installerad.

Nästa i denna PyTorch-handledning kommer vi att lära oss om PyTorch-ramverkets grunder.

Grunderna i PyTorch Framework

Låt oss lära oss de grundläggande begreppen PyTorch innan vi djupdyker. PyTorch använder Tensor för varje variabel som liknar numpys ndarray men med stöd för GPU-beräkning. Här kommer vi att förklara nätverksmodellen, förlustfunktionen, Backprop och Optimizer.

Nätverksmodell

Nätverket kan konstrueras genom att underklassa torch.nn. Det finns 2 huvuddelar,

1. Den första delen är att definiera parametrarna och lagren som du ska använda
2. Den andra delen är huvuduppgiften som kallas framåtprocessen som tar en input och förutsäger utdata.

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

Som du kan se ovan skapar du en klass av nn.Module som heter Model. Den innehåller 2 Conv2d-lager och ett linjärt lager. Det första conv2d-lagret har en ingång på 3 och utmatningsformen 20. Det andra lagret kommer att ta en ingång på 20 och producerar en outputform på 40. Det sista lagret är ett helt anslutet lager i formen 320 och kommer att producera en utgång på 10.

Framåtprocessen kommer att ta en ingång av X och mata den till konv1-lagret och utföra ReLU-funktion,

På samma sätt kommer det också att mata konv2-lagret. Efter det kommer x:et att omformas till (-1, 320) och matas in i det sista FC-lagret. Innan du skickar utdata kommer du att använda softmax-aktiveringsfunktionen.

Bakåtprocessen definieras automatiskt av autograd, så du behöver bara definiera framåtprocessen.

Förlustfunktion

Förlustfunktionen används för att mäta hur väl prediktionsmodellen kan förutsäga de förväntade resultaten. PyTorch har redan många vanliga förlustfunktioner i torch.nn-modulen. Till exempel kan du använda Cross-Entropy Loss för att lösa ett PyTorch-klassificeringsproblem i flera klasser. Det är enkelt att definiera förlustfunktionen och beräkna förlusterna:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Det är enkelt att använda din egen förlustfunktionsberäkning med PyTorch.

Backprop

För att utföra backpropagation, anropar du helt enkelt los.backward(). Felet kommer att beräknas men kom ihåg att rensa den befintliga gradienten med zero_grad()

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

Optimizer

Torch.optim tillhandahåller vanliga optimeringsalgoritmer. Du kan definiera en optimerare med ett enkelt steg:

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

Du måste skicka nätverksmodellens parametrar och inlärningshastigheten så att parametrarna uppdateras vid varje iteration efter backprop-processen.

Enkel regression med PyTorch

Låt oss lära oss enkel regression med PyTorch-exempel:

Steg 1) Skapa vår nätverksmodell

Vår nätverksmodell är ett enkelt linjärt lager med en ingångs- och en utgångsform på 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)

Och nätverksutgången ska vara så här

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

Steg 2) Testa data

Innan du påbörjar utbildningsprocessen måste du känna till våra uppgifter. Du gör en slumpmässig funktion för att testa vår modell. 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()

Här är spridningsdiagrammet för vår funktion:

Innan du startar träningsprocessen måste du konvertera numpy-arrayen till variabler som stöds av Torch och autograd som visas i PyTorch-regressionsexemplet nedan.

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

Steg 3) Optimizer och förlust

Därefter bör du definiera optimeraren och förlustfunktionen för vår träningsprocess.

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

Steg 4) Träning

Låt oss nu börja vår träningsprocess. Med en epok på 250, kommer du att iterera våra data för att hitta det bästa värdet för våra hyperparametrar.

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

Steg 5) Resultat

Som du kan se nedan har du framgångsrikt utfört PyTorch-regression med ett neuralt nätverk. Faktiskt, vid varje iteration kommer den röda linjen i diagrammet att uppdateras och ändra sin position för att passa data. Men i den här bilden visar den bara det slutliga resultatet som visas i PyTorch-exemplet nedan:

Bildklassificeringsexempel med PyTorch

En av de populära metoderna att lära sig grunderna i djupt lärande är med MNIST-datauppsättningen. Det är "Hej världen" inom djupinlärning. Datauppsättningen innehåller handskrivna siffror från 0 – 9 med totalt 60,000 10,000 träningsprover och 28 28 testprover som redan är märkta med storleken XNUMX×XNUMX pixlar.

Steg 1) Förbearbeta data

I det första steget i detta PyTorch-klassificeringsexempel kommer du att ladda datamängden med hjälp av torchvision-modulen.

Innan du börjar utbildningsprocessen måste du förstå data. Torchvision kommer att ladda datamängden och transformera bilderna med lämpliga krav för nätverket såsom formen och normalisering av bilderna.

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

Transformfunktionen omvandlar bilderna till tensor och normaliserar värdet. Funktionen torchvision.transforms.MNIST laddar ner datasetet (om det inte är tillgängligt) i katalogen, ställer in datasetet för träning om det behövs och gör omvandlingsprocessen.

För att visualisera datamängden använder du data_iterator för att få nästa sats med bilder och etiketter. Du använder matplot för att plotta dessa bilder och deras lämpliga etikett. Som du kan se nedan våra bilder och deras etiketter.

Steg 2) Konfiguration av nätverksmodell

Nu i detta PyTorch-exempel kommer du att skapa ett enkelt neuralt nätverk för PyTorch-bildklassificering.

Här presenterar vi ett annat sätt att skapa nätverksmodellen i PyTorch. Vi kommer att använda nn.Sequential för att göra en sekvensmodell istället för att göra en underklass till 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)

Här är resultatet av vår nätverksmodell

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

Nätverksförklaring

1. Sekvensen är att det första lagret är ett Conv2D-lager med en ingångsform på 1 och en utmatningsform på 10 med en kärnstorlek på 5
2. Därefter har du ett MaxPool2D-lager
3. En ReLU-aktiveringsfunktion
4. ett Dropout-lager för att släppa låga sannolikhetsvärden.
5. Sedan en andra Conv2d med ingångsformen 10 från det sista lagret och utgångsformen 20 med en kärnstorlek på 5
6. Nästa ett MaxPool2d-lager
7. ReLU aktiveringsfunktion.
8. Efter det kommer du att platta till tensorn innan du matar in den i det linjära lagret
9. Linear Layer kommer att kartlägga vår utdata vid det andra linjära lagret med softmax aktiveringsfunktion

Steg 3) Träna modellen

Innan du startar utbildningsprocessen krävs det att du ställer in kriteriet och optimeringsfunktionen.

För kriteriet kommer du att använda CrossEntropyLoss. För Optimizer kommer du att använda SGD med en inlärningshastighet på 0.001 och ett momentum på 0.9 som visas i PyTorch-exemplet nedan.

import torch.optim as optim

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

Framåtprocessen kommer att ta ingångsformen och skicka den till det första conv2d-lagret. Sedan kommer den att matas in i maxpool2d och slutligen föras in i ReLU-aktiveringsfunktionen. Samma process kommer att ske i det andra conv2d-lagret. Efter det kommer ingången att omformas till (-1,320 XNUMX) och matas in i fc-lagret för att förutsäga utdata.

Nu börjar du träningsprocessen. Du kommer att gå igenom vår datauppsättning 2 gånger eller med en epok på 2 och skriva ut den aktuella förlusten var 2000:e batch.

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

Vid varje epok kommer enumeratorn att få nästa tupel av input och motsvarande etiketter. Innan vi matar ingången till vår nätverksmodell måste vi rensa den föregående gradienten. Detta krävs eftersom efter bakåtprocessen (återförökningsprocessen) kommer gradienten att ackumuleras istället för att ersättas. Sedan kommer vi att beräkna förlusterna från den förväntade produktionen från den förväntade produktionen. Efter det kommer vi att göra en backpropagation för att beräkna gradienten, och slutligen kommer vi att uppdatera parametrarna.

Här är resultatet av utbildningsprocessen

[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

Steg 4) Testa modellen

När du har tränat vår modell måste du testa eller utvärdera med andra uppsättningar bilder.

Vi kommer att använda en iterator för test_loader, och den kommer att generera en grupp bilder och etiketter som kommer att skickas till den tränade modellen. Den förväntade uteffekten kommer att visas och jämföras med den förväntade uteffekten.

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

Sammanfattning

• PyTorch är en Torch-baserad med öppen källkod Maskininlärning bibliotek för naturlig språkbehandling med hjälp av Python.
• Fördelar med PyTorch: 1) Enkelt bibliotek, 2) Dynamic Computational Graph, 3) Bättre prestanda, 4) Native Python
• PyTorch använder Tensor för varje variabel som liknar numpys ndarray men med stöd för GPU-beräkning.
• En av de populära metoderna för att lära sig grunderna för djupinlärning är med MNIST-datauppsättningen.