PyTorch Урок

Какво е PyTorч?

PyTorch е с отворен код Torch-базирана библиотека за машинно обучение за обработка на естествен език, използваща PythonПодобен е на NumPy, но с мощна поддръжка на графични процесори. Предлага динамични изчислителни графики, които можете да променяте в движение с помощта на autograd. PyTorch е и по-бърз от някои други рамки. Разработен е от изследователската група за изкуствен интелект на Facebook през 2016 г.

Знаейки какво PyTorch предлага балансиран поглед върху неговите силни и недостатъци.

PyTorПредимства и недостатъци

Следват предимствата и недостатъците на PyTorch:

Предимства на PyTorch

1. Проста библиотека
   PyTorch кодът е прост. Лесен е за разбиране и използвате библиотеката мигновено. Например, разгледайте фрагмента от код по-долу:

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

Както бе споменато по-горе, можете лесно да дефинирате мрежовия модел и можете да разберете кода бързо без много обучение.

2. Динамична изчислителна графика

Източник на изображението: Изследване на дълбокото обучение с PyTorch

PyTorch предлага динамична изчислителна графика (DAG). Изчислителната графика е начин за изразяване на математически изрази в графови модели или теории, като например възли и ръбове. Възелът ще извършва математическата операция, а ръбът е тензор, който ще бъде подаден към възлите и ще носи изхода на възела в тензора.

DAG е графика, която поддържа произволна форма и може да извършва операции между различни входни графики. При всяка итерация се създава нова графика. Така че е възможно да имаме същата структура на графиката или да създадем нова графика с различна операция, или можем да я наречем динамична графика.

3. По-добро представяне

Общности и изследователи, сравните и сравнете рамки, за да видите коя е по-бърза. Репо GitHub Бенчмарк за Deep Learning Frameworks и GPU съобщи, че PyTorch е по-бърз от другите рамки по отношение на обработваните изображения в секунда.

Както можете да видите по-долу, сравнителните графики с vgg16 и resnet152

4. Роден Python

PyTorch е по-базиран на Python. Например, ако искате да обучите модел, можете да използвате native control flow, като например loo.ping и рекурсии, без да е необходимо да се добавят още специални променливи или сесии, за да могат да се изпълняват. Това е много полезно за процеса на обучение.

PyTorch също така реализира императивно програмиране и определено е по-гъвкав. Така че е възможно да се отпечата стойността на тензора по средата на изчислителен процес.

Недостатък на PyTorch

PyTorch изисква приложения на трети страни за визуализация. Също така е необходим API сървър за производство.

Следващо в този PyTorВ урока по ch ще научим за разликата между PyTorch и TensorFlow.

PyTorch срещу TensorFlow

Имайки предвид сравнението, следващата стъпка е да се получи PyTorch, работещ локално или в облака.

Инсталиране на PyTorch

Linux

Лесно е да го инсталирате в Linux. Можете да изберете да използвате виртуална среда или да я инсталирате директно с root достъп. Въведете тази команда в терминала

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker е една от платформите в Amazon Уеб сервиз който предлага мощен двигател за машинно обучение с предварително инсталирани конфигурации за дълбоко обучение за специалисти по данни или разработчици за изграждане, обучение и внедряване на модели във всякакъв мащаб.

Първо отворете Amazon Sagemaker конзола и щракнете върху Създаване на екзе��пляр на бележник и попълнете всички подробности за вашия бележник.

Следващата стъпка, щракнете върху Отвори, за да стартирате екземпляра на вашия бележник.

Накрая, In JupyterКликнете върху „Ново“ и изберете conda_pytorch_p36 и сте готови да използвате вашия екземпляр на бележника с Py.Torch инсталиран.

Следващо в този PyTorch урок, ще научим за PyTorОснови на ch framework.

Инсталацията е на място, самият API е следващата спирка.

PyTorch Основи на рамката

Нека научим основните понятия на PyTorch преди да се потопим дълбоко. PyTorch използва Tensor за всяка променлива, подобно на ndarray в numpy, но с поддръжка на GPU изчисления. Тук ще обясним мрежовия модел, функцията за загуба, Backprop и Optimizer.

Мрежов модел

Мрежата може да бъде изградена чрез подкласиране на torch.nn. Има 2 основни части,

1. Първата част е да дефинирате параметрите и слоевете, които ще използвате
2. Втората част е основната задача, наречена напредващ процес, който ще приеме вход и ще предвиди изхода.

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

Както можете да видите по-горе, създавате клас от nn.Module, наречен Model. Съдържа 2 Conv2d слоя и линеен слой. Първият слой conv2d приема вход 3 и изходна форма 20. Вторият слой ще приема вход 20 и ще произведе изходна форма 40. Последният слой е напълно свързан слой във формата 320 и ще произведе изход от 10.

Процесът напред ще вземе вход от X и ще го подаде към слоя conv1 и ще изпълни ReLU функция,

По същия начин ще захранва и слоя conv2. След това x ще бъде преоформен в (-1, 320) и ще бъде подаден във финалния FC слой. Преди да изпратите изхода, ще използвате функцията за активиране на softmax.

Процесът назад се дефинира автоматично от autograd, така че трябва да дефинирате само процеса напред.

Функция загуба

Функцията за загуба се използва за измерване на това колко добре моделът за прогнозиране е способен да предскаже очакваните резултати. PyTorch вече има много стандартни функции за загуба в модула torch.nn. Например, можете да използвате функцията „Cross-Entropy Loss“, за да решите многокласов Py.TorПроблем с класификацията на ch. Лесно е да се дефинира функцията на загубите и да се изчислят загубите:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Лесно е да използвате собствено изчисление на функцията на загуба с PyTorгл.

Подпора

За да извършите обратното разпространение, просто извиквате los.backward(). Грешката ще бъде изчислена, но не забравяйте да изчистите съществуващия градиент с zero_grad()

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

Optimizer

Torch.optim предоставя общи алгоритми за оптимизация. Можете да дефинирате оптимизатор с една проста стъпка:

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

Трябва да предадете параметрите на мрежовия модел и скоростта на обучение, така че при всяка итерация параметрите да се актуализират след процеса на backprop.

Най-чистият на��ин да научите API е малък, цялостен пример.

Проста регресия с PyTorch

Нека научим проста регресия с PyTorпримери за гл.:

Стъпка 1) Създаване на нашия мрежов модел

Нашият мрежов модел е прост линеен слой с входна и изходна форма 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)

И мрежовият изход трябва да бъде такъв

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

Стъпка 2) Тестови данни

Преди да започнете процеса на обучение, трябва да знаете нашите данни. Вие правите произволна функция, за да тествате нашия модел. 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()

Ето диаграмата на разсейване на нашата функция:

Преди да започнете процеса на обучение, трябва да конвертирате масива numpy в променливи, които се поддържат от Torch и автоград, както е показано на Py по-долуTorПример за 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)

Стъпка 3) Оптимизатор и загуба

След това трябва да дефинирате оптимизатора и функцията за загуба за нашия процес на обучение.

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

Стъпка 4) Обучение

Сега нека започнем нашия процес на обучение. С епоха от 250 ще повторите нашите данни, за да намерите най-добрата стойност за нашите хиперпараметри.

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) Резултат

Както можете да видите по-долу, успешно изпълнихте PyTorch регресия с невронна мрежа. Всъщност, при всяка итерация, червената линия на графиката ще се актуализира и ще променя позицията си, за да съответства на данните. Но на тази снимка тя показва само крайния резултат, както е показано на Py по-долу.Torпример за гл.:

Регресията е загрявка; класификацията на изображенията упражнява мускулите на дълбокото обучение на PyTorгл.

Пример за класификация на изображения с PyTorch

Един от популярните методи за изучаване на основите дълбоко учене е с набора от данни на MNIST. Това е „Здравей свят“ в дълбокото обучение. Наборът от данни съдържа ръкописни числа от 0 до 9 с общо 60,000 10,000 тренировъчни проби и 28 28 тестови проби, които вече са етикетирани с размер XNUMX × XNUMX пиксела.

Стъпка 1) Предварителна обработка на данните

В първата стъпка на този PyTorВ пример за класификация на ch ще заредите набора от данни, използвайки модула torchvision.

Преди да започнете процеса на обучение, трябва да разберете данните. Torchvision ще зареди набора от данни и ще трансформира изображенията с подходящите изисквания за мрежата, като например формата и нормализирането на изображенията.

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

Функцията за преобразуване преобразува изображенията в тензор и нормализира стойността. Функцията torchvision.transforms.MNIST ще изтегли набора от данни (ако не е наличен) в директорията, ще зададе набора от данни за обучение, ако е необходимо, и ще извърши процеса на трансформация.

За да визуализирате набора от данни, използвате data_iterator, за да получите следващата партида изображения и етикети. Използвате matplot, за да начертаете тези изображения и подходящия им етикет. Както можете да видите по-долу нашите изображения и техните етикети.

Стъпка 2) Конфигурация на мрежовия модел

Сега в този PyTorНапример, ще направите проста невронна мрежа за PyTorкласификация на изображенията ch.

Тук ви представяме друг начин за създаване на мрежов модел в Py.Torгл. Ще използваме nn.Sequential, за да създадем модел на последователност, вместо да правим подклас на 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)

Ето резултата от нашия мрежов модел

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

Мрежово обяснение

1. Последователността е, че първият слой е Conv2D слой с входна форма 1 и изходна форма 10 с размер на ядрото 5
2. След това имате слой MaxPool2D
3. Функция за активиране на ReLU
4. слой Dropout за премахване на стойности с ниска вероятност.
5. След това втори Conv2d с входна форма 10 от последния слой и изходна форма 20 с размер на ядрото 5
6. Следва слой MaxPool2d
7. Функция за активиране на ReLU.
8. След това ще изравните тензора, преди да го подадете в линейния слой
9. Линеен слой ще картографира нашия изход във втория линеен слой с функция за активиране на softmax

Стъпка 3) Обучете модела

Преди да започнете процеса на обучение, е необходимо да настроите функцията за критерий и оптимизатор.

За критерия ще използвате CrossEntropyLoss. За оптимизатора ще използвате SGD с коефициент на обучение 0.001 и импулс 0.9, както е показано на графиката Py по-долу.Torпример с глава.

import torch.optim as optim

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

Процесът напред ще вземе входната форма и ще я предаде на първия слой conv2d. След това оттам ще бъде подаден в maxpool2d и накрая ще бъде поставен във функцията за активиране на ReLU. Същият процес ще се случи във втория слой conv2d. След това входът ще бъде преоформен в (-1,320) и ще бъде подаден в fc слоя, за да се предвиди изхода.

Сега ще започнете процеса на обучение. Ще преминете през нашия набор от данни 2 пъти или с епоха от 2 и ще отпечатате текущата загуба на всяка партида от 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

Във всяка епоха изброителят ще получи следващия кортеж от входни данни и съответните етикети. Преди да подадем входа към нашия мрежов модел, трябва да изчистим предишния градиент. Това е необходимо, защото след обратния процес (процес на обратно разпространение), градиентът ще бъде натрупан, вместо да бъде заменен. След това ще изчислим загубите от прогнозираната продукция от очакваната продукция. След това ще направим обратно разпространение, за да изчислим градиента, и накрая ще актуализираме параметрите.

Ето резултата от процеса на обучение

[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) Тествайте модела

След като обучите нашия модел, трябва да тествате или оцените с други набори от изображения.

Ще използваме итератор за test_loader и той ще генерира пакет от изображения и етикети, които ще бъдат предадени на обучения модел. Прогнозираният резултат ще бъде показан и сравнен с очаквания резултат.

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

Въпроси и Отговори