PyTorchi õpetus: regressioon, piltide klassifitseerimise näide

Pytorchi õpetuse kokkuvõte

Selles Pytorchi õpetuses õpite kõiki mõisteid nullist. See õpetus hõlmab põhilisi ja täpsemaid teemasid, nagu pytorchi määratlus, pytorchi eelised ja puudused, võrdlus, installimine, pytorchi raamistik, regressioon ja kujutiste klassifikatsioon. See pytorchi õpetus on täiesti tasuta.

Mis on PyTorch?

PyTorch on avatud lähtekoodiga taskulampidel põhinev masinõppe raamatukogu loomuliku keele töötlemiseks Python. See sarnaneb NumPyga, kuid võimsa GPU toega. See pakub dünaamilisi arvutusgraafikuid, mida saate autogradi abil liikvel olles muuta. PyTorch on ka kiirem kui mõned teised raamistikud. Selle töötas välja Facebooki AI uurimisrühm 2016. aastal.

PyTorchi eelised ja puudused

PyTorchi eelised ja puudused on järgmised:

PyTorchi eelised

1. Lihtne raamatukogu
   PyTorchi kood on lihtne. Seda on lihtne mõista ja te kasutate raamatukogu koheselt. Näiteks vaadake allolevat koodilõiku:

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 PyTorchiga

Pytorch pakub dünaamilist arvutusgraafikut (DAG). Arvutusgraafikud on viis matemaatiliste avaldiste väljendamiseks graafimudelites või teooriates, nagu sõlmed ja servad. Sõlm teeb matemaatilise toimingu 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 osas teisest raamistikust kiirem.

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

4. Pärit Python

PyTorch põhineb rohkem pythonil. Näiteks kui soovite mudelit koolitada, saate kasutada natiivset juhtimisvoogu, nagu silmus ja rekursioonid, ilma et oleks vaja lisada nende käitamiseks rohkem erimuutujaid või seansse. See on koolitusprotsessi jaoks väga kasulik.

Pytorch rakendab ka imperatiivset programmeerimist ja see on kindlasti paindlikum. Seega on võimalik välja printida tensori väärtus keset arvutusprotsessi.

PyTorchi puudus

PyTorch nõuab visualiseerimiseks kolmandate osapoolte rakendusi. Samuti vajab see tootmiseks API-serverit.

Järgmisena selles PyTorchi õpetuses õpime PyTorchi ja TensorFlow erinevuste kohta.

PyTorch vs. Tensorflow

Parameeter	PyTorch	Tensorivoog
Mudeli definitsioon	Mudel on määratletud alamklassis ja pakub hõlpsasti kasutatavat paketti	Mudel on määratletud paljudega ja peate mõistma süntaksit
GPU tugi	Jah	Jah
Graafiku tüüp	Dünaamiline	Staatiline
TÖÖRIISTAD	Visualiseerimistööriist puudub	Võite kasutada Tensorboardi visualiseerimistööriista
kogukond	Kogukond kasvab endiselt	Suured aktiivsed kogukonnad

PyTorchi installimine

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 olete valmis kasutama oma sülearvuti eksemplari, kui Pytorch on installitud.

Järgmisena selles PyTorchi õpetuses õpime PyTorchi raamistiku põhitõdesid.

PyTorchi raamistiku põhitõed

Enne sügavale sukeldumist tutvume PyTorchi põhikontseptsioonidega. PyTorch kasutab Tensorit iga muutuja jaoks, mis sarnaneb numpy ndarrayga, kuid millel on GPU arvutustoetus. 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

Kaofunktsiooni kasutatakse selleks, et mõõta, kui hästi suudab ennustusmudel oodatavaid tulemusi ennustada. PyTorchil on moodulis torch.nn juba palju standardseid kadufunktsioone. Näiteks saate kasutada Cross-Entropy Loss'i mitme klassi PyTorchi klassifikatsiooniprobleemi lahendamiseks. Kaofunktsiooni on lihtne määratleda ja kadusid arvutada:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

PyTorchiga on lihtne oma kahjufunktsiooni arvutamist kasutada.

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.

Lihtne regressioon PyTorchiga

Õpime PyTorchi näidete abil lihtsat regressiooni:

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 teisendama numpy massiivi muutujateks, mida toetavad Torch ja autograd, nagu on näidatud allolevas PyTorchi regressiooninäites.

# 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 PyTorchi regressiooni närvivõrguga edukalt. Tegelikult värskendatakse igal iteratsioonil graafiku punast joont ja muudab selle asukohta andmetega sobitamiseks. Kuid sellel pildil näitab see teile ainult lõpptulemust, nagu on näidatud allolevas PyTorchi näites:

Piltide klassifitseerimise näide PyTorchiga

Ü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 PyTorchi klassifitseerimise näite esimeses etapis laadite andmestiku torchvisioni mooduli abil.

Enne koolitusprotsessi alustamist peate andmetest aru saama. Torchvision laadib andmestiku ja teisendab pildid võrgu jaoks sobivate nõuetega, nagu kuju ja kujutiste 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 PyTorchi näites teete PyTorchi kujutiste klassifitseerimiseks lihtsa närvivõrgu.

Siin tutvustame teile teist võimalust PyTorchis võrgumudeli loomiseks. Jadamudeli koostamiseks kasutame nn.Sequential selle asemel, et koostada nn.Module alamklassi.

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 CrossEntropyLossi. Optimeerija jaoks kasutate SGD-d õppimiskiirusega 0.001 ja impulsiga 0.9, nagu on näidatud allolevas PyTorchi näites.

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

kokkuvõte

• PyTorch on avatud lähtekoodiga taskulamp Masinõpe raamatukogu jaoks loomuliku keele töötlemine kasutamine Python.
• PyTorchi eelised: 1) Lihtne teek, 2) Dünaamiline arvutusgraafik, 3) Parem jõudlus, 4) Native Python
• PyTorch kasutab Tensorit iga muutuja jaoks, mis sarnaneb numpy ndarrayga, kuid millel on GPU arvutustoetus.
• Üks populaarsemaid meetodeid süvaõppe põhitõdede õppimiseks on MNIST-i andmestik.