PyTorch-vejledning

Hvad er PyTorh?

PyTorch er en open source Torch-baseret maskinlæringsbibliotek til behandling af naturligt sprog ved hjælp af PythonDet ligner NumPy, men med kraftig GPU-understøttelse. Det tilbyder dynamiske beregningsgrafer, som du kan ændre på farten ved hjælp af autograd. PyTorch er også hurtigere end nogle andre frameworks. Det blev udviklet af Facebooks AI Research Group i 2016.

At vide hvad PyTorch giver et afbalanceret blik på sine styrker og ulemper.

PyTorFordele og ulemper ved ch

Følgende er fordele og ulemper ved PyTorch:

Fordele ved PyTorch

1. Simpelt bibliotek
   PyTorch-koden er enkel. Den er let at forstå, og du bruger biblioteket med det samme. Se for eksempel kodestykket nedenfor:

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ævnt ovenfor kan du nemt definere netværksmodellen, og du kan hurtigt forstå koden uden meget træning.

2. Dynamisk beregningsgraf

Billedkilde: Udforskning af dyb læring med PyTorch

PyTorch tilbyder dynamisk beregningsgraf (DAG). Beregningsgrafer er en måde at udtrykke matematiske udtryk i grafmodeller eller teorier såsom noder og kanter. Noden udfører den matematiske operation, og kanten er en tensor, der føres ind i noderne og bærer nodens output i tensoren.

DAG er en graf, der har vilkårlig form og i stand til at udføre operationer mellem forskellige inputgrafer. Hver iteration oprettes en ny graf. Så det er muligt at have den samme grafstruktur eller oprette en ny graf med en anden operation, eller vi kan kalde det en dynamisk graf.

3. Bedre ydeevne

Fællesskaber og forskere, benchmark og sammenligne rammer for at se, hvilken der er hurtigere. En GitHub-repo Benchmark på Deep Learning Frameworks og GPU'er rapporterede, at PyTorch er hurtigere end det andet framework med hensyn til billeder behandlet pr. sekund.

Som du kan se nedenfor, viser sammenligningsgraferne med vgg16 og resnet152

4. Native Python

PyTorch er mere Python-baseret. Hvis du for eksempel vil træne en model, kan du bruge et native kontrolflow som f.eks. loo.ping og rekursioner uden behov for at tilføje flere specielle variabler eller sessioner for at kunne køre dem. Dette er meget nyttigt for træningsprocessen.

PyTorch implementerer også imperativ programmering, og det er bestemt mere fleksibelt. Så det er muligt at udskrive tensorværdien midt i en beregningsproces.

Ulempe ved PyTorch

PyTorch kræver tredjepartsapplikationer til visualisering. Den kræver også en API-server til produktion.

Næste i denne PyTorch-tutorial, vi lærer om forskellen mellem PyTorch og TensorFlow.

PyTorch vs. TensorFlow

Med sammenligningen i tankerne er næste skridt at få PyTorch kører lokalt eller i skyen.

Installation af PyTorch

Linux

Det er ligetil at installere det i Linux. Du kan vælge at bruge et virtuelt miljø eller installere det direkte med root-adgang. Indtast denne kommando i terminalen

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker er en af ​​platformene i Amazon Web Service der tilbyder en kraftfuld Machine Learning-motor med forudinstallerede deep learning-konfigurationer til dataforskere eller udviklere til at bygge, træne og implementere modeller i enhver skala.

Åbn først Amazon Sagemager konsollen og klik på Opret notesbogsforekomst og udfyld alle detaljerne for din notesbog.

Næste trin, klik på Åbn for at starte din notebook-forekomst.

Endelig, In JupyterKlik på Ny, og vælg conda_pytorch_p36, så er du klar til at bruge din notesbogsinstans med Py.Torch installeret.

Næste i denne PyTorch tutorial, vi lærer om PyTorGrundlæggende om ch-frameworket.

Installationen er på plads, selve API'en er næste stop.

PyTorGrundlæggende om ch-rammeværket

Lad os lære de grundlæggende begreber i PyTorch før vi dykker ned. PyTorch bruger Tensor for hver variabel, ligesom numpys ndarray, men med GPU-beregningsunderstøttelse. Her vil vi forklare netværksmodellen, tabsfunktionen, Backprop og Optimizer.

Netværksmodel

Netværket kan konstrueres ved at underklassificere torch.nn. Der er 2 hoveddele,

1. Den første del er at definere de parametre og lag, du vil bruge
2. Den anden del er hovedopgaven kaldet den fremadrettede proces, der vil tage et input og forudsige outputtet.

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 ovenfor, opretter du en klasse af nn.Module kaldet Model. Den indeholder 2 Conv2d lag og et lineært lag. Det første conv2d-lag tager et input på 3 og output-formen på 20. Det andet lag vil tage et input på 20 og vil producere en output-form på 40. Det sidste lag er et fuldt forbundet lag i form af 320 og vil producere et output på 10.

Fremadgående proces vil tage et input af X og føre det til conv1 laget og udføre ReLU funktion,

På samme måde vil det også fodre conv2-laget. Derefter omformes x'et til (-1, 320) og føres ind i det endelige FC-lag. Før du sender output, skal du bruge softmax aktiveringsfunktionen.

Baglæns processen er automatisk defineret af autograd, så du behøver kun at definere fremad processen.

Tabsfunktion

Tabsfunktionen bruges til at måle, hvor godt prædiktionsmodellen er i stand til at forudsige de forventede resultater. PyTorch har allerede mange standard tabsfunktioner i torch.nn-modulet. For eksempel kan du bruge Cross-Entropy Loss til at løse et Py-problem med flere klasser.Torch klassifikationsproblem. Det er nemt at definere tabsfunktionen og beregne tabene:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Det er nemt at bruge din egen tabsfunktionsberegning med PyTorch.

Rygprop

For at udføre backpropagation, kalder du blot los.backward(). Fejlen vil blive beregnet, men husk at rydde den eksisterende gradient med zero_grad()

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

Optimizer

Torch.optim giver almindelige optimeringsalgoritmer. Du kan definere en optimering med et enkelt trin:

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

Du skal videregive netværksmodelparametrene og indlæringshastigheden, så parametrene ved hver iteration vil blive opdateret efter backprop-processen.

Den reneste måde at lære API'en at kende på er et lille, end-to-end eksempel.

Simpel regression med PyTorch

Lad os lære simpel regression med PyTorch eksempler:

Trin 1) Oprettelse af vores netværksmodel

Vores netværksmodel er et simpelt lineært lag med en input- og en outputform 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)

Og netværksudgangen skal være sådan

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

Trin 2) Testdata

Før du starter uddannelsesprocessen, skal du kende vores data. Du laver en tilfældig funktion for at teste vores 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()

Her er spredningsplottet for vores funktion:

Før du starter træningsprocessen, skal du konvertere numpy-arrayet til variabler, der understøttes af Torch og autograd som vist i nedenstående PyToreksempel 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)

Trin 3) Optimering og tab

Dernæst skal du definere optimerings- og tabsfunktionen for vores træningsproces.

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

Trin 4) Træning

Lad os nu starte vores træningsproces. Med en epoke på 250 vil du iterere vores data for at finde den bedste værdi for vores hyperparametre.

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

Trin 5) Resultat

Som du kan se nedenfor, har du udført Py med succesTorch-regression med et neuralt netværk. Faktisk vil den røde linje i plottet ved hver iteration opdatere og ændre sin position for at passe til dataene. Men på dette billede viser den kun det endelige resultat, som vist i Py-diagrammet nedenfor.Torch eksempel:

Regression er en opvarmning; billedklassificering træner Py's dybdelæringsmusklerTorch.

Eksempel på billedklassificering med PyTorch

En af de populære metoder til at lære det grundlæggende dyb læring er med MNIST-datasættet. Det er "Hej verden" i dyb læring. Datasættet indeholder håndskrevne tal fra 0 – 9 med i alt 60,000 træningsprøver og 10,000 testprøver, der allerede er mærket med størrelsen 28×28 pixels.

Trin 1) Forbehandle dataene

I det første trin af denne PyTorch-klassifikationseksempel, du skal indlæse datasættet ved hjælp af torchvision-modulet.

Før du starter træningsprocessen, skal du forstå dataene. Torchvision vil indlæse datasættet og transformere billederne med de passende krav til netværket, såsom form og normalisering af billederne.

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

Transformationsfunktionen konverterer billederne til tensor og normaliserer værdien. Funktionen torchvision.transforms.MNIST vil downloade datasættet (hvis det ikke er tilgængeligt) i biblioteket, indstille datasættet til træning om nødvendigt og udføre transformationsprocessen.

For at visualisere datasættet bruger du data_iterator til at få den næste batch af billeder og etiketter. Du bruger matplot til at plotte disse billeder og deres passende etiket. Som du kan se nedenfor vores billeder og deres etiketter.

Trin 2) Konfiguration af netværksmodel

Nu i denne PyTorch eksempel, du vil lave et simpelt neuralt netværk til PyTorch-billedklassificering.

Her introducerer vi dig til en anden måde at oprette netværksmodellen i PyTorkap. Vi vil bruge nn.Sequential til at lave en sekvensmodel i stedet for at lave en underklasse af 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)

Her er output fra vores netværksmodel

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

Netværksforklaring

1. Sekvensen er, at det første lag er et Conv2D-lag med en input-form på 1 og output-form på 10 med en kernestørrelse på 5
2. Dernæst har du et MaxPool2D-lag
3. En ReLU aktiveringsfunktion
4. et Dropout-lag for at droppe lave sandsynlighedsværdier.
5. Derefter en anden Conv2d med input-formen på 10 fra det sidste lag og output-formen på 20 med en kernestørrelse på 5
6. Dernæst et MaxPool2d-lag
7. ReLU aktiveringsfunktion.
8. Derefter vil du flade tensoren, før du fører den ind i det lineære lag
9. Linear Layer vil kortlægge vores output på det andet Lineære lag med softmax aktiveringsfunktion

Trin 3) Træn modellen

Før du starter træningsprocessen, er det nødvendigt at opsætte kriteriet og optimeringsfunktionen.

Som kriterium bruger du CrossEntropyLoss. Som optimizer bruger du SGD med en læringsrate på 0.001 og et momentum på 0.9, som vist i Py-diagrammet nedenfor.Torch eksempel.

import torch.optim as optim

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

Fremadgående proces vil tage inputformen og videregive den til det første conv2d-lag. Derefter vil den blive ført ind i maxpool2d og til sidst sat ind i ReLU-aktiveringsfunktionen. Den samme proces vil forekomme i det andet conv2d-lag. Derefter omformes inputtet til (-1,320) og føres ind i fc-laget for at forudsige outputtet.

Nu vil du starte træningsprocessen. Du vil gentage vores datasæt 2 gange eller med en epoke på 2 og udskrive det aktuelle tab for hver 2000 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

Ved hver epoke vil tælleren få den næste tuple af input og tilsvarende etiketter. Før vi leverer input til vores netværksmodel, skal vi rydde den forrige gradient. Dette er påkrævet, fordi gradienten vil blive akkumuleret i stedet for at blive erstattet efter baglæns processen (tilbageudbredelsesprocessen). Derefter vil vi beregne tabene fra det forudsagte output fra det forventede output. Derefter vil vi lave en backpropagation for at beregne gradienten, og til sidst opdaterer vi parametrene.

Her er resultatet af træningsprocessen

[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

Trin 4) Test modellen

Når du har trænet vores model, skal du teste eller evaluere med andre sæt billeder.

Vi vil bruge en iterator til test_loader, og den vil generere en batch af billeder og etiketter, som vil blive videregivet til den trænede model. Det forudsagte output vil blive vist og sammenlignet med det forventede output.

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

Ofte Stillede Spørgsmål