PyTorch õpetus

Mis on PyTorh?

PyTorch on avatud lähtekoodiga Torch-põhine masinõppe teek loomuliku keele töötlemiseks, kasutades PythonSee on sarnane NumPy-ga, kuid võimsa GPU-toega. See pakub dünaamilisi arvutusgraafe, mida saate autogradi abil liikvel olles muuta. PyTorch on ka kiirem kui mõned teised raamistikud. Selle töötas välja Facebooki tehisintellekti uurimisrühm 2016. aastal.

Teades, mida PyTorch annab tasakaalustatud ülevaate selle tugevustest ja puudustest.

PyTorch eelised ja puudused

Järgnevalt on toodud Py eelised ja puudusedTorch:

Py eelisedTorch

1. Lihtne raamatukogu
   PyTorch-kood on lihtne. Seda on kerge mõista ja teeki saab koheselt kasutada. Näiteks vaadake allolevat koodijuppi:

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

Nagu eespool mainitud, saate võrgumudeli hõlpsalt määratleda ja koodist saate kiiresti aru ilma suurema koolituseta.

2. Dünaamiline arvutusgraafik

Pildi allikas: Süvaõppe uurimine Py abilTorch

PyTorch pakub dünaamilist arvutusgraafi (DAG). Arvutusgraafikud on viis matemaatiliste avaldiste väljendamiseks graafimudelites või teooriates, näiteks sõlmedes ja servades. Sõlm teeb matemaatilise tehte ja serv on tensor, mis suunatakse sõlmedesse ja kannab sõlme väljundit tensoris.

DAG on graafik, millel on suvaline kuju ja mis suudab teha toiminguid erinevate sisendgraafikute vahel. Iga iteratsiooniga luuakse uus graafik. Seega on võimalik kasutada sama graafi struktuuri või luua uus graafik erineva toiminguga või nimetada seda dünaamiliseks graafikuks.

3. Parem jõudlus

Kogukonnad ja teadlased tehke võrdlusuuringuid ja võrrelge raamistikke, et näha, milline neist on kiirem. GitHubi repo Süvaõppe raamistike ja GPU-de võrdlusalus teatas, et PyTorch on sekundis töödeldavate piltide arvu poolest kiirem kui teine ​​raamistik.

Nagu allpool näete, on vgg16 ja resnet152 võrdlusgraafikud

4. Pärit Python

PyTorch on rohkem Pythoni-põhine. Näiteks kui soovite mudelit treenida, saate kasutada natiivset juhtimisvoogu, näiteks looping ja rekursioone ilma vajaduseta lisada rohkem spetsiaalseid muutujaid või seansse nende käivitamiseks. See on treeningprotsessi jaoks väga kasulik.

PyTorch rakendab ka imperatiivset programmeerimist ja on kindlasti paindlikum. Seega on võimalik tensori väärtus arvutusprotsessi keskel välja printida.

Py puudusTorch

PyTorch vajab visualiseerimiseks kolmanda osapoole rakendusi. Samuti vajab see tootmiseks API-serverit.

Järgmine selles Py-sTorch õpetuses õpime Py erinevuse kohtaTorch ja TensorFlow.

PyTorch vs. TensorFlow

Võrdlust silmas pidades on järgmine samm Py hankimineTorch töötab lokaalselt või pilves.

Py installimineTorch

Linux

Selle installimine Linuxi on lihtne. Saate valida, kas kasutada virtuaalset keskkonda või installida see otse juurjuurdepääsuga. Tippige see käsk terminali

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker on üks platvormidest Amazon Veebiteenus mis pakub võimsat masinõppemootorit koos eelinstallitud süvaõppe konfiguratsioonidega andmeteadlastele või arendajatele, et luua, koolitada ja juurutada mis tahes mastaabis mudeleid.

Esmalt avage Amazon Salveitegija konsooli ja klõpsake nuppu Loo märkmiku eksemplar ja täitke kõik oma märkmiku üksikasjad.

Järgmises etapis klõpsake märkmiku eksemplari käivitamiseks nuppu Ava.

Lõpuks, In Jupyter, Klõpsake nuppu Uus ja valige conda_pytorch_p36 ning oletegi valmis oma märkmiku eksemplari Py-ga kasutama.Torch installitud.

Järgmine selles Py-sTorch õpetus, õpime Py kohtaTorch raamistiku põhitõed.

Paigaldamine on tehtud ja API ise on järgmine samm.

PyTorch raamistiku põhitõed

Õpime Py põhimõisteidTorenne kui süvitsi läheme. PyTorch kasutab iga muutuja jaoks Tensorit sarnaselt numpy funktsioonile ndarray, aga GPU arvutuste toega. Siin selgitame võrgumudelit, kadufunktsiooni, Backpropi ja optimeerijat.

Võrgu mudel

Võrgu saab ehitada tõrviku.nn alamklassides. Seal on 2 põhiosa,

1. Esimene osa on kasutatavate parameetrite ja kihtide määratlemine
2. Teine osa on põhiülesanne, mida nimetatakse edasisuunamisprotsessiks, mis võtab sisendi ja ennustab väljundit.

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

Nagu ülalt näha, loote nn.Module klassi nimega Model. See sisaldab 2 Conv2d kihti ja lineaarset kihti. Esimese konv2d kihi sisendiks on 3 ja väljundi kujuks 20. Teise kihi sisendiks on 20 ja väljundiks on 40. Viimane kiht on täielikult ühendatud kiht 320 kujuga ja annab väljund 10.

Edasisuunamisprotsess võtab X-i sisendi ja suunab selle konv1-kihile ning täidab funktsiooni ReLU,

Samamoodi toidab see ka konv2 kihti. Pärast seda kujundatakse x ümber (-1, 320) ja sisestatakse lõplikku FC-kihti. Enne väljundi saatmist kasutate softmaxi aktiveerimisfunktsiooni.

Autograd määrab automaatselt tagasisuunamise protsessi, seega peate määratlema ainult edasisuunamise protsessi.

Kaotuse funktsioon

Kahjumisfunktsiooni kasutatakse selleks, et mõõta, kui hästi ennustusmudel suudab eeldatavaid tulemusi ennustada. PyTorch-l on torch.nn moodulis juba palju standardseid kaotusfunktsioone. Näiteks saate kasutada ristentroopiakaotust mitmeklassilise Py lahendamiseks.Torch klassifitseerimise probleem. Kahjumisfunktsiooni defineerimine ja kahjude arvutamine on lihtne:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Py abil on lihtne oma kahjumifunktsiooni arvutadaTorptk.

Backprop

Tagasi levitamiseks helistage lihtsalt los.backward(). Viga arvutatakse, kuid ärge unustage olemasolevat gradienti kustutada käsuga zero_grad()

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

Optimeerija

Torch.optim pakub ühiseid optimeerimisalgoritme. Optimeerija saate määratleda lihtsa sammuga:

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

Peate edastama võrgumudeli parameetrid ja õppimiskiiruse, nii et iga iteratsiooni korral värskendataks parameetreid pärast backprop protsessi.

Kõige puhtam viis API õppimiseks on väike, otsast lõpuni näide.

Lihtne regressioon Py abilTorch

Õpime lihtsat regressiooni Py abilTorch näited:

Samm 1) Võrgumudeli loomine

Meie võrgumudel on lihtne lineaarne kiht, mille sisend- ja väljundkuju on 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)

Ja võrguväljund peaks olema selline

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

Samm 2) Testi andmed

Enne koolitusprotsessi alustamist peate teadma meie andmeid. Teete meie mudeli testimiseks juhusliku funktsiooni. 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()

Siin on meie funktsiooni hajuvusdiagramm:

Enne treeningprotsessi alustamist peate numpy massiivi teisendama muutujateks, mida toetab Torch ja autograd, nagu on näidatud allpool Py-sTorch regressiooni näide.

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

3. samm) optimeerija ja kadu

Järgmisena peaksite meie koolitusprotsessi jaoks määratlema optimeerija ja kadumise funktsiooni.

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

4. samm) Koolitus

Nüüd alustame oma koolitusprotsessi. 250 epohhiga kordate meie andmeid, et leida meie hüperparameetrite jaoks parim väärtus.

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

5. samm) Tulemus

Nagu allpool näete, sooritasite edukalt PyTorch regressioon närvivõrguga. Tegelikult uuendab punane joon graafikul iga iteratsiooni korral oma asukohta, et see sobiks andmetega. Kuid sellel pildil näitab see ainult lõpptulemust, nagu on näidatud allolevas Py-s.Torch näide:

Regressioon on soojendusharjutus; piltide klassifitseerimine treenib Py süvaõppe lihaseidTorptk.

Näide piltide klassifitseerimisest Py abilTorch

Üks populaarsemaid meetodeid põhitõdede õppimiseks sügav õpe on koos MNIST-i andmestikuga. See on "Tere maailm" sügavas õppimises. Andmekogum sisaldab käsitsi kirjutatud numbreid 0–9 koos kokku 60,000 10,000 treeningnäidisega ja 28 28 testnäidisega, mis on juba märgistatud suurusega XNUMX × XNUMX pikslit.

1. samm) Andmete eeltöötlemine

Selle Py esimeses etapisTorch klassifitseerimise näites laadite andmestiku torchvisioni mooduli abil.

Enne koolitusprotsessi alustamist peate andmetest aru saama. Torchvision laadib andmestiku ja teisendab pildid vastavalt võrgu nõuetele, näiteks kuju ja piltide normaliseerimine.

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

Teisendusfunktsioon teisendab pildid tensoriks ja normaliseerib väärtuse. Funktsioon torchvision.transforms.MNIST laadib andmestiku (kui see pole saadaval) kataloogis alla, määrab vajaduse korral andmestiku treenimiseks ja teostab teisendusprotsessi.

Andmestiku visualiseerimiseks kasutate järgmise kujutiste ja siltide partii hankimiseks parameetrit data_iterator. Nende piltide ja nende sobiva sildi joonistamiseks kasutate matploti. Nagu näete allpool meie pilte ja nende silte.

Samm 2) Võrgumudeli konfigureerimine

Nüüd selles Py-sTorNäites loote Py jaoks lihtsa närvivõrguTorch pildi klassifikatsioon.

Siin tutvustame teile veel ühte viisi võrgumudeli loomiseks Py-sTorptk. Järjestusmudeli loomiseks kasutame nn.Sequential moodulit nn.Module alamklassi loomise asemel.

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)

Siin on meie võrgumudeli väljund

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

Võrgu selgitus

1. Jada on selline, et esimene kiht on Conv2D kiht sisendkujuga 1 ja väljundi kujuga 10 ning tuuma suurusega 5
2. Järgmisena on teil MaxPool2D kiht
3. ReLU aktiveerimisfunktsioon
4. väljalangemise kiht madala tõenäosusega väärtuste langetamiseks.
5. Seejärel teine ​​Conv2d viimase kihi sisendkujuga 10 ja väljundi kujuga 20 tuuma suurusega 5
6. Järgmisena MaxPool2d kiht
7. ReLU aktiveerimisfunktsioon.
8. Pärast seda tasandate tensori, enne kui sisestate selle lineaarsesse kihti
9. Lineaarne kiht kaardistab meie väljundi softmaxi aktiveerimisfunktsiooniga teisel Lineaarsel kihil

3. samm) Treenige mudelit

Enne koolitusprotsessi alustamist tuleb seadistada kriteerium ja optimeerija funktsioon.

Kriteeriumi jaoks kasutate CrossEntropyLoss'i. Optimeerija jaoks kasutate SGD-d õppimiskiirusega 0.001 ja impulsiga 0.9, nagu on näidatud allolevas Py-diagrammis.Torch näide.

import torch.optim as optim

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

Edasiliikumine võtab sisendkuju ja edastab selle esimesele conv2d-kihile. Seejärel suunatakse see sealt maxpool2d-sse ja lõpuks lisatakse ReLU aktiveerimisfunktsiooni. Sama protsess toimub ka teises conv2d kihis. Pärast seda kujundatakse sisend ümber (-1,320) ja sisestatakse väljundi ennustamiseks fc-kihti.

Nüüd alustate koolitusprotsessi. Kordate meie andmestikku 2 korda või 2-kordse perioodiga ja prindite välja praeguse kadu iga 2000 partii kohta.

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

Igal epohhil saab loendaja järgmise sisendi ja vastavad sildid. Enne kui sisestame oma võrgumudelisse sisendi, peame eelmise gradiendi tühjendama. See on vajalik, kuna pärast tagurpidi protsessi (tagasi levitamise protsess) gradient asendamise asemel koguneb. Seejärel arvutame prognoositava väljundi ja eeldatava toodangu kaod. Pärast seda teeme gradiendi arvutamiseks tagasi paljundamise ja lõpuks värskendame parameetreid.

Siin on koolitusprotsessi väljund

[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

4. samm) testige mudelit

Pärast meie mudeli väljaõpetamist peate testima või hindama teiste pildikomplektidega.

Kasutame test_loaderi jaoks iteraatorit ja see genereerib hulga pilte ja silte, mis edastatakse koolitatud mudelile. Kuvatakse prognoositav väljund ja seda võrreldakse eeldatava väljundiga.

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

KKK