Підручник з PyTorch

Підсумок підручника з Pytorch

У цьому підручнику pytorch ви вивчите всі концепції з нуля. Цей підручник охоплює базові та складні теми, такі як визначення pytorch, переваги та недоліки pytorch, порівняння, встановлення, структура pytorch, регресія та класифікація зображень. Цей підручник pytorch є абсолютно безкоштовним.

Що таке PyTorch?

PyTorch це бібліотека машинного навчання з відкритим вихідним кодом на основі Torch для обробки природної мови Python. Він схожий на NumPy, але має потужну підтримку GPU. Він пропонує динамічні обчислювальні графіки, які ви можете змінювати на ходу за допомогою autograd. PyTorch також швидший за деякі інші фреймворки. Він був розроблений групою дослідження штучного інтелекту Facebook у 2016 році.

Переваги та недоліки PyTorch

Нижче наведено переваги та недоліки 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 пропонує Dynamic Computational Graph (DAG). Обчислювальні графіки — це спосіб вираження математичних виразів у графових моделях або теоріях, таких як вузли та ребра. Вузол виконуватиме математичну операцію, а ребро є тензором, який надсилатиметься до вузлів і передаватиме вихідні дані вузла в тензорі.

DAG — це граф, який має довільну форму та може виконувати операції між різними вхідними графами. З кожною ітерацією створюється новий графік. Отже, можна мати таку саму структуру графа або створити новий графік з іншою операцією, або ми можемо назвати це динамічним графіком.

3. Краща продуктивність

Спільноти та дослідники, тестуйте та порівнюйте фреймворки, щоб побачити, який із них швидший. Репо GitHub Порівняльний тест на основі глибокого навчання та GPU повідомляє, що PyTorch є швидшим за інші фреймворки з точки зору кількості зображень, що обробляються за секунду.

Як ви можете бачити нижче, порівняльні графіки з vgg16 і resnet152

4. рідний Python

PyTorch більше базується на Python. Наприклад, якщо ви хочете навчити модель, ви можете використовувати власний потік керування, такий як цикли та рекурсії, без необхідності додавати додаткові змінні чи сеанси, щоб мати можливість їх запускати. Це дуже корисно для тренувального процесу.

Pytorch також реалізує імперативне програмування, і це, безперечно, більш гнучко. Отже, можна роздрукувати значення тензора в середині процесу обчислення.

Недолік PyTorch

Для візуалізації PyTorch потрібні програми сторонніх розробників. Він також потребує сервера API для виробництва.

Далі в цьому посібнику з PyTorch ми дізнаємося про різницю між PyTorch і TensorFlow.

PyTorch Vs. Tensorflow

Параметр	PyTorch	Тензорний потік
Визначення моделі	Модель визначена в підкласі та пропонує простий у використанні пакет	Модель визначається багатьма, і вам потрібно зрозуміти синтаксис
Підтримка GPU	Так	Так
Тип графіка	Dynamic	Статичний
Інструменти	Немає інструментів візуалізації	Ви можете використовувати інструмент візуалізації Tensorboard
Спільнота	Спільнота все ще зростає	Великі активні спільноти

Встановлення PyTorch

Linux

Його легко встановити в Linux. Ви можете вибрати використання віртуального середовища або встановити його безпосередньо з кореневим доступом. Введіть цю команду в терміналі

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker є однією з платформ у Amazon Веб-сервіс який пропонує потужний механізм машинного навчання з попередньо встановленими конфігураціями глибокого навчання для вчених даних або розробників для створення, навчання та розгортання моделей будь-якого масштабу.

Спочатку відкрийте Amazon Шалфейник консолі та клацніть «Створити екземпляр блокнота» та введіть усі дані для свого блокнота.

На наступному кроці натисніть «Відкрити», щоб запустити екземпляр блокнота.

Нарешті, В Jupyter, Натисніть «Новий» і виберіть conda_pytorch_p36, і ви готові використовувати свій екземпляр блокнота з установленим Pytorch.

Далі в цьому посібнику з PyTorch ми дізнаємося про основи PyTorch.

Основи PyTorch Framework

Давайте вивчимо основні концепції 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. Наприклад, ви можете використовувати перехресну втрату ентропії для вирішення проблеми класифікації PyTorch із кількома класами. Легко визначити функцію втрат і обчислити втрати:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

За допомогою PyTorch легко використовувати власний розрахунок функції втрат.

Задня опора

Щоб виконати зворотне поширення, ви просто викликаєте los.backward(). Помилка буде обчислена, але не забудьте очистити наявний градієнт за допомогою zero_grad()

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

Оптимізатор

Torch.optim надає загальні алгоритми оптимізації. Ви можете визначити оптимізатор за допомогою простого кроку:

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

Вам потрібно передати параметри моделі мережі та швидкість навчання, щоб на кожній ітерації параметри оновлювалися після процесу резервної підтримки.

Проста регресія з PyTorch

Давайте вивчимо просту регресію на прикладах PyTorch:

Крок 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 ранд(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 і autograd, як показано в наведеному нижче прикладі регресії PyTorch.

# 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 за допомогою нейронної мережі. Фактично, на кожній ітерації червона лінія на графіку оновлюватиметься та змінюватиме своє положення відповідно до даних. Але на цьому зображенні він показує лише кінцевий результат, як показано в наведеному нижче прикладі PyTorch:

Приклад класифікації зображень за допомогою PyTorch

Один із популярних методів вивчення основ глибоке навчання з набором даних MNIST. Це «Hello World» у глибокому навчанні. Набір даних містить рукописні числа від 0 до 9 із загальною кількістю 60,000 10,000 навчальних зразків і 28 28 тестових зразків, які вже позначені розміром XNUMX×XNUMX пікселів.

Крок 1) Попередня обробка даних

На першому кроці цього прикладу класифікації PyTorch ви завантажите набір даних за допомогою модуля 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()

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

Щоб візуалізувати набір даних, ви використовуєте data_iterator, щоб отримати наступну партію зображень і міток. Ви використовуєте matplot, щоб побудувати ці зображення та їх відповідну мітку. Як ви можете бачити нижче, наші зображення та їхні мітки.

Крок 2) Конфігурація моделі мережі

Тепер у цьому прикладі PyTorch ви створите просту нейронну мережу для класифікації зображень PyTorch.

Тут ми представляємо вам інший спосіб створення моделі мережі в PyTorch. Ми будемо використовувати 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. шар вилучення, щоб викинути значення низької ймовірності.
5. Потім другий Conv2d із вхідною формою 10 з останнього шару та вихідною формою 20 із розміром ядра 5
6. Далі шар MaxPool2d
7. Функція активації ReLU.
8. Після цього ви зведете тензор перед подачею його на лінійний шар
9. Лінійний шар відобразить наш вихід на другому лінійному шарі з функцією активації softmax

Крок 3) Навчіть модель

Перед початком процесу навчання необхідно налаштувати функцію критерію та оптимізатора.

Як критерій ви будете використовувати CrossEntropyLoss. Для оптимізатора ви будете використовувати SGD зі швидкістю навчання 0.001 і імпульсом 0.9, як показано в прикладі PyTorch нижче.

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

Підсумки

• PyTorch — це відкрита версія Torch машинне навчання бібліотека для обробка природного мови використання Python.
• Переваги PyTorch: 1) Проста бібліотека, 2) Динамічний обчислювальний графік, 3) Краща продуктивність, 4) Нативний Python
• PyTorch використовує Tensor для кожної змінної, подібно до ndarray numpy, але з підтримкою обчислень GPU.
• Одним із популярних методів вивчення основ глибокого навчання є набір даних MNIST.