PyTorch-handledning

Vad är PyTorch?

PyTorch är en öppen källkod Torch-baserat maskininlärningsbibliotek för naturlig språkbehandling med hjälp av PythonDet liknar NumPy men med kraftfullt GPU-stöd. Det erbjuder dynamiska beräkningsgrafer 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-forskningsgrupp år 2016.

Att veta vad PyTorch ger en balanserad bild av dess styrkor och nackdelar.

PyTorFördelar och nackdelar med ch

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

Fördelar med PyTorch

1. Enkelt bibliotek
   PyTorch-koden är enkel. Den ä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: Utforska djupinlärning med PyTorch

PyTorch erbjuder dynamisk beräkningsgraf (DAG). Beräkningsgrafer är ett sätt att uttrycka matematiska uttryck i grafmodeller eller teorier som noder och kanter. Noden utför den matematiska operationen, och kanten är en tensor som matas in i noderna och bär nodens utdata i tensorn.

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 som bearbetas per sekund.

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

4. Native Python

PyTorch är mer python-baserat. Om du till exempel vill träna en modell kan du använda ett inbyggt kontrollflöde som loo.ping och rekursioner utan att behöva lägga till fler specialvariabler eller sessioner för att kunna köra dem. Detta är mycket användbart för träningsprocessen.

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

Nackdel med PyTorch

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

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

PyTorch kontra TensorFlow

Med jämförelsen i åtanke är nästa steg att få PyTorch som körs lokalt eller i molnet.

Installera 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 JupyterKlicka på Ny och välj conda_pytorch_p36 så är du redo att använda din anteckningsbokinstans med Py.Torch installerad.

Nästa i denna PyTorch-handledning, vi kommer att lära oss om PyTorGrunderna i ch-ramverket.

Installationen är på plats, själva API:et är nästa stopp.

PyTorGrunderna i ch-ramverket

Låt oss lära oss de grundläggande begreppen inom PyTorch innan vi djupdyker. PyTorch använder Tensor för varje variabel, ungefär som 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 standardförlustfunktioner i torch.nn-modulen. Till exempel kan du använda Cross-Entropy Loss för att lösa ett flerklassigt Py-fel.Torch-klassificeringsproblem. 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.

Det renaste sättet att lära sig API:et är ett litet, heltäckande exempel.

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 börjar träningsprocessen måste du konvertera numpy-arrayen till variabler som stöds av Torch och autograd som visas i Py nedanTorexempel på ch-regression.

# 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. Faktum är att den röda linjen i diagrammet uppdateras och ändrar sin position för att passa data. Men i den här bilden visas bara det slutliga resultatet som visas i Py nedan.Torch-exempel:

Regression är en uppvärmning; bildklassificering tränar Pys djupinlärningsmusklerTorch.

Exempel på bildklassificering 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 av denna PyTorch-klassificeringsexempel, du kommer att ladda datamängden med hjälp av Torchvision-modulen.

Innan du börjar träningsprocessen behöver du förstå data. Torchvision kommer att ladda datamängden och transformera bilderna med lämpliga krav för nätverket, såsom form 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 denna PyTorch exempel, du ska skapa ett enkelt neuralt nätverk för PyTorch-bildklassificering.

Här presenterar vi ett annat sätt att skapa nätverksmodellen i PyTorkap. Vi kommer att använda nn.Sequential för att skapa en sekvensmodell istället för att skapa en underklass av 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 använder du CrossEntropyLoss. För optimeraren använder du SGD med en inlärningshastighet på 0.001 och ett momentum på 0.9, vilket visas i Py-diagrammet nedan.Torch-exempel.

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

Vanliga frågor