PyTorch veiledning

Pytorch opplæringssammendrag

I denne pytorch-opplæringen lærer du alle konseptene fra bunnen av. Denne opplæringen dekker grunnleggende til avanserte emner som pytorch-definisjon, fordeler og ulemper med pytorch, sammenligning, installasjon, pytorch-rammeverk, regresjon og bildeklassifisering. Denne pytorch-opplæringen er helt gratis.

Hva er PyTorch?

PyTorch er et åpen kildekode Torch-basert maskinlæringsbibliotek for naturlig språkbehandling ved hjelp av Python. Det ligner på NumPy, men med kraftig GPU-støtte. Den tilbyr Dynamic Computational Graphs som du kan endre mens du er på farten ved hjelp av autograd. PyTorch er også raskere enn noen andre rammeverk. Den ble utviklet av Facebooks AI Research Group i 2016.

PyTorch fordeler og ulemper

Følgende er fordelene og ulempene med PyTorch:

Fordeler med PyTorch

Enkelt bibliotek
PyTorch-koden er enkel. Det er lett å forstå, og du bruker biblioteket umiddelbart. Ta for eksempel en titt på kodebiten 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 nevnt ovenfor kan du enkelt definere nettverksmodellen, og du kan raskt forstå koden uten mye trening.

Dynamisk beregningsgraf

Bildekilde: Exploring Deep Learning med PyTorch

Pytorch tilbyr Dynamic Computational Graph (DAG). Beregningsgrafer er en måte å uttrykke matematiske uttrykk i grafmodeller eller teorier som noder og kanter. Noden vil utføre den matematiske operasjonen, og kanten er en Tensor som vil mates inn i nodene og bærer utgangen fra noden i Tensor.

DAG er en graf som har vilkårlig form og i stand til å utføre operasjoner mellom forskjellige inndatagrafer. Hver iterasjon opprettes en ny graf. Så det er mulig å ha samme grafstruktur eller lage en ny graf med en annen operasjon, eller vi kan kalle det en dynamisk graf.

Bedre ytelse

Fellesskap og forskere, benchmark og sammenligne rammeverk for å se hvilken som er raskere. En GitHub-repo Benchmark på Deep Learning Frameworks og GPUer rapporterte at PyTorch er raskere enn det andre rammeverket når det gjelder bilder behandlet per sekund.

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

Innfødt Python

PyTorch er mer pythonbasert. Hvis du for eksempel ønsker å trene en modell, kan du bruke innfødt kontrollflyt som looping og rekursjoner uten å måtte legge til flere spesielle variabler eller økter for å kunne kjøre dem. Dette er veldig nyttig for opplæringsprosessen.

Pytorch implementerer også imperativ programmering, og det er definitivt mer fleksibelt. Så det er mulig å skrive ut tensorverdien midt i en beregningsprosess.

Ulempen med PyTorch

PyTorch krever tredjepartsapplikasjoner for visualisering. Den trenger også en API-server for produksjon.

Neste i denne PyTorch-opplæringen vil vi lære om forskjellen mellom PyTorch og TensorFlow.

PyTorch vs. Tensorflow

Parameter	PyTorch	tensorflow
Modelldefinisjon	Modellen er definert i en underklasse og tilbyr en brukervennlig pakke	Modellen er definert med mange, og du må forstå syntaksen
GPU-støtte	Ja	Ja
Graftype	Dynamisk	Statisk
verktøy	Ingen visualiseringsverktøy	Du kan bruke Tensorboard visualiseringsverktøy
Samfunn	Samfunnet vokser fortsatt	Store aktive samfunn

Installerer PyTorch

Linux

Det er enkelt å installere det i Linux. Du kan velge å bruke et virtuelt miljø eller installere det direkte med root-tilgang. Skriv inn denne kommandoen i terminalen

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker er en av plattformene i Amazon Nettjeneste som tilbyr en kraftig maskinlæringsmotor med forhåndsinstallerte dyplæringskonfigurasjoner for dataforskere eller utviklere for å bygge, trene og distribuere modeller i alle skalaer.

Først Åpne Amazon Sagemaker konsollen og klikk på Opprett notatbokforekomst og fyll ut alle detaljene for notatboken.

Neste trinn, klikk på Åpne for å starte din bærbare forekomst.

Til slutt, In Jupyter, Klikk på Ny og velg conda_pytorch_p36 og du er klar til å bruke din bærbare instans med Pytorch installert.

Neste i denne PyTorch-opplæringen vil vi lære om grunnleggende PyTorch-rammeverk.

Grunnleggende om PyTorch Framework

La oss lære de grunnleggende konseptene til PyTorch før vi dypdykker. PyTorch bruker Tensor for hver variabel som ligner på numpys ndarray, men med GPU-beregningsstøtte. Her vil vi forklare nettverksmodellen, tapsfunksjonen, Backprop og Optimizer.

Nettverksmodell

Nettverket kan konstrueres ved å underklassifisere fakkelen.nn. Det er 2 hoveddeler,

Den første delen er å definere parameterne og lagene du skal bruke
Den andre delen er hovedoppgaven kalt foroverprosessen som vil ta et input og forutsi utgangen.

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, oppretter du en klasse av nn.Module kalt Model. Den inneholder 2 Conv2d-lag og et lineært lag. Det første conv2d-laget tar en inngang på 3 og utgangsformen på 20. Det andre laget vil ha en input på 20 og vil produsere en utgangsform på 40. Det siste laget er et fullstendig koblet lag i form av 320 og vil produsere en utgang på 10.

Fremoverprosessen vil ta en inngang fra X og mate den til conv1-laget og utføre ReLU-funksjonen,

På samme måte vil den også mate conv2-laget. Etter det vil x-en omformes til (-1, 320) og føres inn i det endelige FC-laget. Før du sender utdataene, vil du bruke softmax aktiveringsfunksjonen.

Bakover prosessen er automatisk definert av autograd, så du trenger bare å definere fremover prosessen.

Tap Funksjon

Tapsfunksjonen brukes til å måle hvor godt prediksjonsmodellen er i stand til å forutsi de forventede resultatene. PyTorch har allerede mange standard tapsfunksjoner i torch.nn-modulen. For eksempel kan du bruke Cross-Entropy Loss for å løse et flerklasses PyTorch-klassifiseringsproblem. Det er enkelt å definere tapsfunksjonen og beregne tapene:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Det er enkelt å bruke din egen tapsfunksjonsberegning med PyTorch.

Ryggpropp

For å utføre tilbakepropageringen kaller du ganske enkelt los.backward(). Feilen vil bli beregnet, men husk å fjerne den eksisterende gradienten med zero_grad()

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

Optimizer

Torch.optim gir vanlige optimaliseringsalgoritmer. Du kan definere en optimizer med et enkelt trinn:

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

Du må sende nettverksmodellparametrene og læringshastigheten slik at parameterne ved hver iterasjon vil bli oppdatert etter backprop-prosessen.

Enkel regresjon med PyTorch

La oss lære enkel regresjon med PyTorch-eksempler:

Trinn 1) Opprette vår nettverksmodell

Nettverksmodellen vår er et enkelt lineært lag med en inngangs- og utgangsform 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 nettverksutgangen skal være slik

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

Trinn 2) Testdata

Før du starter opplæringsprosessen, må du kjenne til dataene våre. Du lager en tilfeldig funksjon for å teste modellen vår. 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 funksjonen vår:

Før du starter treningsprosessen, må du konvertere numpy-matrisen til variabler som støttes av Torch og autograd som vist i PyTorch-regresjonseksemplet nedenfor.

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

Trinn 3) Optimalisering og tap

Deretter bør du definere optimaliserings- og tapsfunksjonen for treningsprosessen vår.

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

Trinn 4) Trening

La oss nå starte treningsprosessen. Med en epoke på 250 vil du iterere dataene våre for å finne den beste verdien for hyperparametrene våre.

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

Trinn 5) Resultat

Som du kan se nedenfor, utførte du PyTorch-regresjon med et nevralt nettverk. Faktisk, ved hver iterasjon, vil den røde linjen i plottet oppdatere og endre posisjonen for å passe til dataene. Men i dette bildet viser det deg bare det endelige resultatet som vist i PyTorch-eksemplet nedenfor:

Eksempel på bildeklassifisering med PyTorch

En av de populære metodene å lære det grunnleggende om dyp læring er med MNIST-datasettet. Det er "Hello World" innen dyp læring. Datasettet inneholder håndskrevne tall fra 0 – 9 med totalt 60,000 10,000 treningsprøver og 28 28 testprøver som allerede er merket med størrelsen XNUMX×XNUMX piksler.

Trinn 1) Forbehandle dataene

I det første trinnet i dette PyTorch-klassifiseringseksemplet vil du laste inn datasettet ved hjelp av torchvision-modulen.

Før du starter opplæringsprosessen, må du forstå dataene. Torchvision vil laste inn datasettet og transformere bildene med passende krav til nettverket, for eksempel form og normalisering av bildene.

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

Transformasjonsfunksjonen konverterer bildene til tensor og normaliserer verdien. Funksjonen torchvision.transforms.MNIST vil laste ned datasettet (hvis det ikke er tilgjengelig) i katalogen, sette datasettet for opplæring om nødvendig og utføre transformasjonsprosessen.

For å visualisere datasettet bruker du data_iterator for å få den neste gruppen med bilder og etiketter. Du bruker matplott til å plotte disse bildene og deres passende etikett. Som du kan se nedenfor bildene våre og deres etiketter.

Trinn 2) Nettverksmodellkonfigurasjon

Nå i dette PyTorch-eksemplet vil du lage et enkelt nevralt nettverk for PyTorch-bildeklassifisering.

Her introduserer vi deg en annen måte å lage nettverksmodellen på i PyTorch. Vi vil bruke nn.Sequential for å lage en sekvensmodell i stedet for å lage en underklasse 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)

Her er resultatet av nettverksmodellen vår

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

Nettverksforklaring

Sekvensen er at det første laget er et Conv2D-lag med en inngangsform på 1 og utgangsform på 10 med en kjernestørrelse på 5
Deretter har du et MaxPool2D-lag
En ReLU-aktiveringsfunksjon
et frafallslag for å slippe lave sannsynlighetsverdier.
Deretter en andre Conv2d med inngangsformen 10 fra det siste laget og utgangsformen 20 med en kjernestørrelse på 5
Neste et MaxPool2d-lag
ReLU aktiveringsfunksjon.
Etter det vil du flate ut tensoren før du mater den inn i det lineære laget
Linear Layer vil kartlegge produksjonen vår ved det andre lineære laget med softmax aktiveringsfunksjon

Trinn 3) Tren opp modellen

Før du starter treningsprosessen, er det nødvendig å sette opp kriteriet og optimaliseringsfunksjonen.

For kriteriet vil du bruke CrossEntropyLoss. For Optimizer vil du bruke SGD med en læringsrate på 0.001 og et momentum på 0.9 som vist i PyTorch-eksemplet nedenfor.

import torch.optim as optim

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

Fremoverprosessen vil ta inndataformen og sende den til det første conv2d-laget. Derfra vil den mates inn i maxpool2d og til slutt settes inn i ReLU-aktiveringsfunksjonen. Den samme prosessen vil skje i det andre conv2d-laget. Etter det vil inngangen omformes til (-1,320 XNUMX) og føres inn i fc-laget for å forutsi utgangen.

Nå starter du treningsprosessen. Du vil iterere gjennom datasettet vårt 2 ganger eller med en epoke på 2 og skrive ut gjeldende tap 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 telleren få neste tuppel med inndata og tilsvarende etiketter. Før vi mater input til nettverksmodellen vår, må vi fjerne den forrige gradienten. Dette er nødvendig fordi etter bakoverprosessen (tilbakeforplantningsprosessen), vil gradienten akkumuleres i stedet for å bli erstattet. Deretter vil vi beregne tapene fra den forutsagte produksjonen fra den forventede produksjonen. Etter det vil vi gjøre en backpropagation for å beregne gradienten, og til slutt vil vi oppdatere parametrene.

Her er resultatet av treningsprosessen

[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

Trinn 4) Test modellen

Etter at du har trent modellen vår, må du teste eller evaluere med andre sett med bilder.

Vi vil bruke en iterator for test_loader, og den vil generere en gruppe bilder og etiketter som sendes til den trente modellen. Den forutsagte utgangen vil vises og sammenlignes med den forventede utgangen.

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

Sammendrag

PyTorch er en åpen kildekode Torch-basert Maskinlæring bibliotek for naturlig språkbehandling ved hjelp av Python.
Fordeler med PyTorch: 1) Enkelt bibliotek, 2) Dynamic Computational Graph, 3) Bedre ytelse, 4) Native Python
PyTorch bruker Tensor for hver variabel som ligner på numpys ndarray, men med GPU-beregningsstøtte.
En av de populære metodene for å lære det grunnleggende om dyp læring er med MNIST-datasettet.

PyTorch veiledning

Pytorch opplæringssammendrag

Hva er PyTorch?

PyTorch fordeler og ulemper

Fordeler med PyTorch

Ulempen med PyTorch

PyTorch vs. Tensorflow

Installerer PyTorch

Linux

AWS Sagemaker

Grunnleggende om PyTorch Framework

Nettverksmodell

Tap Funksjon

Ryggpropp

Optimizer

Enkel regresjon med PyTorch

Eksempel på bildeklassifisering med PyTorch

Nettverksforklaring

Sammendrag

Oppsummer dette innlegget med:

Registrer deg for nyhetsbrevet

Pytorch opplæringssammendrag

Hva er PyTorch?

PyTorch fordeler og ulemper

Fordeler med PyTorch

Ulempen med PyTorch

RELATERTE ARTIKLER

PyTorch vs. Tensorflow

Installerer PyTorch

Linux

AWS Sagemaker

Grunnleggende om PyTorch Framework

Nettverksmodell

Tap Funksjon

Ryggpropp

Optimizer

RELATERTE ARTIKLER

Enkel regresjon med PyTorch

Eksempel på bildeklassifisering med PyTorch

Nettverksforklaring

Sammendrag

Oppsummer dette innlegget med:

Registrer deg for nyhetsbrevet