PyTorch tutorial

Pytorch selvstudieoversigt

I denne pytorch-tutorial lærer du alle begreberne fra bunden. Denne vejledning dækker grundlæggende til avancerede emner som pytorch definition, fordele og ulemper ved pytorch, sammenligning, installation, pytorch framework, regression og billedklassificering. Denne pytorch-tutorial er helt gratis.

Hvad er PyTorch?

PyTorch er et open source Torch-baseret maskinlæringsbibliotek til naturlig sprogbehandling ved hjælp af Python. Det ligner NumPy, men med kraftig GPU-understøttelse. Det tilbyder Dynamic Computational Graphs, 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.

PyTorch fordele og ulemper

Følgende er fordele og ulemper ved PyTorch:

Fordele ved PyTorch

Simpelt bibliotek
PyTorch-koden er enkel. Det er let at forstå, og du bruger biblioteket med det samme. Tag for eksempel et kig på 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.

Dynamisk beregningsgraf

Billedkilde: Exploring Deep Learning med PyTorch

Pytorch tilbyder Dynamic Computational Graph (DAG). Beregningsgrafer er en måde at udtrykke matematiske udtryk i grafmodeller eller teorier såsom noder og kanter. Noden vil udføre den matematiske operation, og kanten er en Tensor, der vil blive ført ind i noderne og bærer output fra noden i Tensor.

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.

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 den anden ramme med hensyn til billeder behandlet pr. sekund.

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

Native Python

PyTorch er mere pythonbaseret. Hvis du for eksempel vil træne en model, kan du bruge native kontrolflow såsom looping og rekursioner uden at skulle 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.

Ulempen ved PyTorch

PyTorch kræver tredjepartsapplikationer til visualisering. Det har også brug for en API-server til produktion.

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

PyTorch vs. Tensorflow

Parameter	PyTorch	Tensorflow
Model definition	Modellen er defineret i en underklasse og tilbyder en nem at bruge pakke	Modellen er defineret med mange, og du skal forstå syntaksen
GPU Support	Ja	Ja
Graftype	Dynamisk	statisk
Værktøjer	Intet visualiseringsværktøj	Du kan bruge Tensorboard visualiseringsværktøj
Fællesskab	Samfundet vokser stadig	Store aktive fællesskaber

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 Jupyter, Klik på Ny og vælg conda_pytorch_p36, og du er klar til at bruge din notebook-instans med Pytorch installeret.

Næste i denne PyTorch tutorial, vil vi lære om PyTorch framework grundlæggende.

Grundlæggende om PyTorch Framework

Lad os lære de grundlæggende begreber i PyTorch, før vi dykker i dybden. PyTorch bruger Tensor for hver variabel, der ligner 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,

Den første del er at definere de parametre og lag, du vil bruge
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 forudsigelsesmodellen er i stand til at forudsige de forventede resultater. PyTorch har allerede mange standardtabsfunktioner i torch.nn-modulet. For eksempel kan du bruge Cross-Entropy Loss til at løse et flerklasses PyTorch-klassificeringsproblem. 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.

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 PyTorch-regressionseksempel.

# 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, udførte du med succes PyTorch-regression med et neuralt netværk. Faktisk vil den røde linje i plottet ved hver iteration opdatere og ændre sin position, så den passer til dataene. Men på dette billede viser det dig kun det endelige resultat som vist i nedenstående PyTorch-eksempel:

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 i dette PyTorch-klassificeringseksempel vil du 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 relevante krav til netværket, såsom formen 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 dette PyTorch-eksempel vil du lave et simpelt neuralt netværk til PyTorch-billedklassificering.

Her introducerer vi dig en anden måde at skabe netværksmodellen på i PyTorch. 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

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
Dernæst har du et MaxPool2D-lag
En ReLU aktiveringsfunktion
et Dropout-lag for at droppe lave sandsynlighedsværdier.
Derefter en anden Conv2d med input-formen på 10 fra det sidste lag og output-formen på 20 med en kernestørrelse på 5
Dernæst et MaxPool2d-lag
ReLU aktiveringsfunktion.
Derefter vil du flade tensoren, før du fører den ind i det lineære lag
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.

Til kriteriet skal du bruge CrossEntropyLoss. Til Optimizer vil du bruge SGD med en indlæringshastighed på 0.001 og et momentum på 0.9 som vist i nedenstående PyTorch-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()

Resumé

PyTorch er en open source Torch baseret Maskinelæring bibliotek for naturlig sprogbehandling ved brug af Python.
Fordele ved PyTorch: 1) Simple Library, 2) Dynamic Computational Graph, 3) Bedre ydeevne, 4) Native Python
PyTorch bruger Tensor for hver variabel, der ligner numpys ndarray, men med GPU-beregningsunderstøttelse.
En af de populære metoder til at lære det grundlæggende i deep learning er med MNIST-datasættet.

PyTorch tutorial

Pytorch selvstudieoversigt

Hvad er PyTorch?

PyTorch fordele og ulemper

Fordele ved PyTorch

Ulempen ved PyTorch

PyTorch vs. Tensorflow

Installation af PyTorch

Linux

AWS Sagemaker

Grundlæggende om PyTorch Framework

Netværksmodel

Tabsfunktion

Rygprop

Optimizer

Simpel regression med PyTorch

Eksempel på billedklassificering med PyTorch

Netværksforklaring

Resumé

Opsummer dette indlæg med:

Tilmeld dig nyhedsbrevet

Pytorch selvstudieoversigt

Hvad er PyTorch?

PyTorch fordele og ulemper

Fordele ved PyTorch

Ulempen ved PyTorch

RELATEREDE ARTIKLER

PyTorch vs. Tensorflow

Installation af PyTorch

Linux

AWS Sagemaker

Grundlæggende om PyTorch Framework

Netværksmodel

Tabsfunktion

Rygprop

Optimizer

RELATEREDE ARTIKLER

Simpel regression med PyTorch

Eksempel på billedklassificering med PyTorch

Netværksforklaring

Resumé

Opsummer dette indlæg med:

Tilmeld dig nyhedsbrevet