PyTorch Tutoriál

Co je PyTorch?

PyTorch je open-source TorKnihovna strojového učení založená na ch pro zpracování přirozeného jazyka pomocí PythonJe podobný NumPy, ale s výkonnou podporou GPU. Nabízí dynamické výpočetní grafy, které můžete upravovat na cestách pomocí autogradace. PyTorFramework ch je také rychlejší než některé jiné frameworky. Byl vyvinut výzkumnou skupinou AI společnosti Facebook v roce 2016.

Vědět, co PyTorch nabízí vyvážený pohled na jeho silné a nevýhody.

PyTorVýhody a nevýhody ch

Následují výhody a nevýhody PyTorch:

Výhody PyTorch

1. Jednoduchá knihovna
   PyTorKód ch je jednoduchý. Je snadno pochopitelný a knihovnu můžete okamžitě použít. Podívejte se například na úryvek kódu níže:

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

Jak bylo zmíněno výše, model sítě můžete definovat snadno a kódu rychle porozumíte bez velkého školení.

2. Dynamický výpočetní graf

Zdroj obrázku: Prozkoumání hlubokého učení s PyTorch

PyTorch nabízí dynamický výpočetní graf (DAG). Výpočetní grafy jsou způsob, jak vyjádřit matematické výrazy v grafových modelech nebo teoriích, jako jsou uzly a hrany. Uzel provádí matematickou operaci a hrana je tenzor, který je přiveden do uzlů a nese výstup uzlu v tenzoru.

DAG je graf, který má libovolný tvar a je schopen provádět operace mezi různými vstupními grafy. Při každé iteraci se vytvoří nový graf. Je tedy možné mít stejnou strukturu grafu nebo vytvořit nový graf s jinou operací, nebo to můžeme nazvat dynamickým grafem.

3. Lepší výkon

Komunity a výzkumní pracovníci, porovnávat a porovnávat rámce, abyste zjistili, který z nich je rychlejší. Úložiště GitHub Srovnání rámců hlubokého učení a GPU uvedl, že PyTorFramework ch je rychlejší než ostatní frameworky, co se týče počtu zpracovaných obrázků za sekundu.

Jak můžete vidět níže, srovnávací grafy s vgg16 a resnet152

4. Domácí Python

PyTorch je více založen na Pythonu. Například pokud chcete trénovat model, můžete použít nativní řídicí tok, jako je loo.ping a rekurze bez nutnosti přidávat další speciální proměnné nebo relace, aby bylo možné je spustit. To je velmi užitečné pro proces trénování.

PyTorch také implementuje imperativní programování a je rozhodně flexibilnější. Je tedy možné vypsat hodnotu tenzoru uprostřed výpočtového procesu.

Nevýhoda PyTorch

PyTorch vyžaduje pro vizualizaci aplikace třetích stran. Pro produkční prostředí také potřebuje API server.

Další v tomto PyTorV tutoriálu ch se dozvíme o rozdílu mezi PyTorch a TensorFlow.

PyTorch vs. TensorFlow

S ohledem na srovnání je dalším krokem získání PyTorch běžící lokálně nebo v cloudu.

Instalace PyTorch

Linux

Instalace v Linuxu je jednoduchá. Můžete se rozhodnout použít virtuální prostředí nebo jej nainstalovat přímo s přístupem root. Zadejte tento příkaz do terminálu

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker je jednou z platforem Amazon Webová služba který nabízí výkonný stroj pro strojové učení s předinstalovanými konfiguracemi hlubokého učení pro datové vědce nebo vývojáře, aby mohli vytvářet, trénovat a nasazovat modely v jakémkoli měřítku.

Nejprve otevřete Amazon Sagemaker konzole a klikněte na Vytvořit instanci notebooku a vyplňte všechny podrobnosti o svém notebooku.

V dalším kroku klikněte na Otevřít pro spuštění instance notebooku.

Nakonec In JupyterKlikněte na Nový a vyberte conda_pytorch_p36 a můžete začít používat instanci notebooku s Py.Torch nainstalován.

Další v tomto PyTorch tutoriál, naučíme se o PyTorZáklady frameworku CH.

Instalace na místě, dalším krokem je samotné API.

PyTorZáklady frameworku ch

Pojďme se seznámit se základními pojmy jazyka PyTorch než se ponoříme hlouběji. PyTorch používá Tensor pro každou proměnnou podobně jako ndarray v NumPy, ale s podporou výpočtů na GPU. Zde si vysvětlíme síťový model, ztrátovou funkci, Backprop a Optimalizátor.

Model sítě

Síť lze vytvořit podtřídou torch.nn. Má 2 hlavní části,

1. První částí je definovat parametry a vrstvy, které budete používat
2. Druhá část je hlavní úkol zvaný dopředný proces, který bude mít vstup a předvídat výstup.

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

Jak můžete vidět výše, vytvoříte třídu nn.Module s názvem Model. Obsahuje 2 vrstvy Conv2d a lineární vrstvu. První vrstva conv2d má vstup 3 a výstupní tvar 20. Druhá vrstva bude mít vstup 20 a vytvoří výstupní tvar 40. Poslední vrstva je plně propojená vrstva ve tvaru 320 a vytvoří výstup 10.

Dopředný proces vezme vstup X a přivede jej do vrstvy conv1 a provede funkci ReLU,

Podobně bude také napájet vrstvu conv2. Poté se x přetvoří na (-1, 320) a přivede se do finální FC vrstvy. Před odesláním výstupu využijete funkci aktivace softmax.

Zpětný proces je automaticky definován pomocí autogradu, takže stačí definovat pouze dopředný proces.

Ztrátová funkce

Ztrátová funkce se používá k měření toho, jak dobře je predikční model schopen předpovědět očekávané výsledky. PyTorModul ch již obsahuje mnoho standardních funkcí pro výpočty ztrát v modulu torch.nn. Například můžete použít funkci Cross-Entropy Loss k řešení vícetřídního Py.TorKlasifikační problém ch. Definovat ztrátovou funkci a vypočítat ztráty je snadné:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Výpočet ztrátové funkce pomocí Py je snadný.Torch.

Backprop

Chcete-li provést zpětné šíření, jednoduše zavoláte los.backward(). Chyba bude vypočítána, ale nezapomeňte vymazat existující přechod pomocí zero_grad()

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

Optimalizátor

Torch.optim poskytuje běžné optimalizační algoritmy. Optimalizátor můžete definovat jednoduchým krokem:

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

Musíte předat parametry modelu sítě a rychlost učení, aby se při každé iteraci parametry po procesu backprop aktualizovaly.

Nejčistší způsob, jak se naučit API, je malý, komplexní příklad.

Jednoduchá regrese s PyTorch

Pojďme se naučit jednoduchou regresi s PyTorpříklady kapitoly 1:

Krok 1) Vytvoření našeho síťového modelu

Náš síťový model je jednoduchá lineární vrstva se vstupním a výstupním tvarem 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)

A síťový výstup by měl být takový

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

Krok 2) Testovací data

Než začnete s tréninkovým procesem, musíte znát naše údaje. Vytvoříte náhodnou funkci pro testování našeho modelu. 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()

Zde je bodový graf naší funkce:

Než začnete s trénovacím procesem, je třeba převést pole NumPy na proměnné, které jsou podporovány Torch a autograd, jak je znázorněno níže v PyTorPříklad regrese ch.

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

Krok 3) Optimalizátor a ztráta

Dále byste měli definovat Optimizer a Loss Function pro náš tréninkový proces.

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

Krok 4) Školení

Nyní začněme náš tréninkový proces. S epochou 250 budete opakovat naše data, abyste našli nejlepší hodnotu pro naše hyperparametry.

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

Krok 5) Výsledek

Jak vidíte níže, úspěšně jste provedli PyTorch regrese s neuronovou sítí. Ve skutečnosti se při každé iteraci červená čára v grafu aktualizuje a mění svou polohu, aby odpovídala datům. Na tomto obrázku však ukazuje pouze konečný výsledek, jak je znázorněno níže v PyTorpříklad kapitoly:

Regrese je rozcvička; klasifikace obrázků procvičuje svaly hlubokého učení PyTorch.

Příklad klasifikace obrázků s PyTorch

Jedna z populárních metod, jak se naučit základy hluboké učení je s datovou sadou MNIST. Je to „Hello World“ v hlubokém učení. Dataset obsahuje ručně psaná čísla od 0 do 9 s celkem 60,000 10,000 trénovacími vzorky a 28 28 testovacími vzorky, které jsou již označeny velikostí XNUMX×XNUMX pixelů.

Krok 1) Předzpracování dat

V prvním kroku tohoto PyTorV příkladu klasifikace ch načtete datovou sadu pomocí modulu TorchVision.

Než začnete s tréninkovým procesem, musíte porozumět datům. TorChvision načte datovou sadu a transformuje obrázky s odpovídajícími požadavky pro síť, jako je tvar a normalizace obrázků.

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

Funkce transformace převádí obrázky na tenzor a normalizuje hodnotu. Funkce torchvision.transforms.MNIST stáhne datovou sadu (pokud není dostupná) v adresáři, v případě potřeby nastaví datovou sadu pro trénování a provede proces transformace.

K vizualizaci datové sady použijte data_iterator k získání další dávky obrázků a štítků. K vykreslení těchto obrázků a jejich příslušného označení použijete matplot. Jak můžete vidět níže naše obrázky a jejich popisky.

Krok 2) Konfigurace síťového modelu

Nyní v tomto PyTorNapříklad vytvoříte jednoduchou neuronovou síť pro PyTorklasifikace obrázků ch.

Zde vám představujeme další způsob, jak vytvořit síťový model v Py.Torkapitola. Místo vytváření podtřídy třídy nn.Module použijeme k vytvoření sekvenčního modelu třídu nn.Sequential.

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)

Zde je výstup našeho síťového modelu

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

Vysvětlení sítě

1. Sekvence je taková, že první vrstva je vrstva Conv2D se vstupním tvarem 1 a výstupním tvarem 10 s velikostí jádra 5
2. Dále máte vrstvu MaxPool2D
3. Aktivační funkce ReLU
4. vrstva Dropout pro snížení hodnot s nízkou pravděpodobností.
5. Poté druhý Conv2d se vstupním tvarem 10 z poslední vrstvy a výstupním tvarem 20 s velikostí jádra 5
6. Dále vrstva MaxPool2d
7. Funkce aktivace ReLU.
8. Poté tenzor zploštíte, než jej vložíte do lineární vrstvy
9. Lineární vrstva bude mapovat náš výstup na druhé lineární vrstvě s funkcí aktivace softmax

Krok 3) Trénujte model

Před zahájením tréninkového procesu je nutné nastavit kritérium a funkci optimalizátoru.

Pro kritérium použijete CrossEntropyLoss. Pro Optimalizátor použijete SGD s mírou učení 0.001 a hybností 0.9, jak je znázorněno na níže uvedeném Py grafu.Torpříklad ch.

import torch.optim as optim

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

Dopředný proces převezme vstupní tvar a předá jej první vrstvě conv2d. Poté bude přiváděn do maxpool2d a nakonec uveden do funkce aktivace ReLU. Ke stejnému procesu dojde ve druhé vrstvě conv2d. Poté bude vstup přetvořen na (-1,320 XNUMX) a přiveden do fc vrstvy, aby se předpověděl výstup.

Nyní zahájíte tréninkový proces. Projdete naši datovou sadu 2krát nebo s epochou 2 a vytisknete aktuální ztrátu při každé dávce 2000.

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

V každé epoše získá čítač další n-tici vstupů a odpovídajících štítků. Než přivedeme vstup do našeho síťového modelu, musíme vymazat předchozí gradient. To je vyžadováno, protože po zpětném procesu (proces zpětného šíření) bude gradient namísto nahrazení akumulován. Poté spočítáme ztráty z predikovaného výkonu z očekávaného výkonu. Poté provedeme backpropagation pro výpočet gradientu a nakonec aktualizujeme parametry.

Zde je výstup z tréninkového procesu

[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

Krok 4) Otestujte model

Poté, co natrénujete náš model, musíte jej otestovat nebo vyhodnotit s jinými sadami obrázků.

Pro test_loader použijeme iterátor a ten vygeneruje dávku obrázků a štítků, které budou předány trénovanému modelu. Předpokládaný výstup se zobrazí a porovná s očekávaným výstupem.

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

Nejčastější dotazy