Ninu nkan yii, Emi yoo sọ fun ọ bi o ṣe le ṣeto agbegbe ikẹkọ ẹrọ ni iṣẹju 30, ṣẹda nẹtiwọọki nkankikan fun idanimọ aworan, ati lẹhinna ṣiṣẹ nẹtiwọọki kanna lori ero isise eya aworan (GPU).
Ni akọkọ, jẹ ki a ṣalaye kini nẹtiwọọki nkankikan jẹ.
Ninu ọran wa, eyi jẹ awoṣe mathematiki, ati sọfitiwia rẹ tabi irisi ohun elo, ti a ṣe lori ipilẹ ti iṣeto ati iṣẹ ṣiṣe ti awọn nẹtiwọọki ti ara - awọn nẹtiwọọki ti awọn sẹẹli nafu ti ohun-ara alãye. Agbekale yii dide lakoko kikọ awọn ilana ti o waye ninu ọpọlọ ati igbiyanju lati ṣe apẹẹrẹ awọn ilana wọnyi.
Awọn nẹtiwọọki nkankikan ko ṣe eto ni ori deede ti ọrọ naa, wọn ti kọ wọn. Agbara lati kọ ẹkọ jẹ ọkan ninu awọn anfani akọkọ ti awọn nẹtiwọọki nkankikan lori awọn algoridimu ibile. Ni imọ-ẹrọ, ẹkọ ni wiwa awọn alafidipupo ti awọn asopọ laarin awọn neuronu. Lakoko ilana ikẹkọ, nẹtiwọọki nkankikan ni anfani lati ṣe idanimọ awọn igbẹkẹle idiju laarin data igbewọle ati data iṣelọpọ, bakanna bi ṣiṣe gbogbogbo.
Lati oju wiwo ti ẹkọ ẹrọ, nẹtiwọọki nkankikan jẹ ọran pataki ti awọn ọna idanimọ ilana, itupalẹ iyasoto, awọn ọna ikojọpọ ati awọn ọna miiran.
Awọn ohun elo
Ni akọkọ, jẹ ki a wo ohun elo naa. A nilo olupin pẹlu ẹrọ ṣiṣe Linux ti a fi sori ẹrọ rẹ. Ohun elo ti o nilo lati ṣiṣẹ awọn eto ikẹkọ ẹrọ jẹ agbara pupọ ati, bi abajade, gbowolori. Fun awọn ti ko ni ẹrọ ti o dara ni ọwọ, Mo ṣe iṣeduro san ifojusi si awọn ipese ti awọn olupese awọsanma. O le ya olupin ti o nilo ni kiakia ati sanwo nikan fun akoko lilo.
Ni awọn iṣẹ akanṣe nibiti o jẹ dandan lati ṣẹda awọn nẹtiwọọki neural, Mo lo awọn olupin ti ọkan ninu awọn olupese awọsanma Russia. Ile-iṣẹ nfunni ni awọn olupin awọsanma fun iyalo pataki fun ikẹkọ ẹrọ pẹlu awọn olupilẹṣẹ awọn eya aworan Tesla V100 ti o lagbara (GPU) lati NVIDIA. Ni kukuru: lilo olupin pẹlu GPU le jẹ awọn mewa ti awọn akoko diẹ sii daradara (yara) ni akawe si olupin ti iye owo ti o jọra ti o nlo Sipiyu kan (ẹka iṣelọpọ aarin ti a mọ daradara) fun awọn iṣiro. Eyi jẹ aṣeyọri nitori awọn ẹya ti faaji GPU, eyiti o koju awọn iṣiro ni iyara.
Lati ṣe awọn apẹẹrẹ ti a ṣalaye ni isalẹ, a ra olupin atẹle fun ọpọlọpọ awọn ọjọ:
- SSD disk 150 GB
- Ramu 32 GB
- Tesla V100 16 Gb ero isise pẹlu 4 ohun kohun
A fi Ubuntu 18.04 sori ẹrọ wa.
Ṣiṣeto ayika
Bayi jẹ ki a fi ohun gbogbo pataki fun iṣẹ lori olupin. Niwọn igba ti nkan wa jẹ akọkọ fun awọn olubere, Emi yoo sọrọ nipa awọn aaye diẹ ti yoo wulo fun wọn.
Pupọ ti iṣẹ nigba ti ṣeto agbegbe kan ni a ṣe nipasẹ laini aṣẹ. Pupọ julọ awọn olumulo lo Windows bi OS iṣẹ wọn. Awọn boṣewa console ni yi OS fi oju Elo lati wa ni fẹ. Nitorina, a yoo lo ohun elo ti o rọrun . Ṣe igbasilẹ ẹya kekere ati ṣiṣe Cmder.exe. Nigbamii o nilo lati sopọ si olupin nipasẹ SSH:
ssh root@server-ip-or-hostnameDipo olupin-ip-tabi-hostname, pato adiresi IP tabi orukọ DNS ti olupin rẹ. Nigbamii, tẹ ọrọ igbaniwọle sii ati ti asopọ ba ṣaṣeyọri, o yẹ ki a gba ifiranṣẹ ti o jọra si eyi.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)Ede akọkọ fun idagbasoke awọn awoṣe ML jẹ Python. Ati pe pẹpẹ ti o gbajumọ julọ fun lilo rẹ lori Linux jẹ .
Jẹ ki a fi sori ẹrọ lori olupin wa.
A bẹrẹ nipa mimu dojuiwọn oluṣakoso package agbegbe:
sudo apt-get updateFi sori ẹrọ curl (IwUlO laini aṣẹ):
sudo apt-get install curlṢe igbasilẹ ẹya tuntun ti Pinpin Anaconda:
cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shJẹ ki a bẹrẹ fifi sori ẹrọ:
bash Anaconda3-2019.10-Linux-x86_64.shLakoko ilana fifi sori ẹrọ, ao beere lọwọ rẹ lati jẹrisi adehun iwe-aṣẹ. Lẹhin fifi sori aṣeyọri o yẹ ki o wo eyi:
Thank you for installing Anaconda3!Ọpọlọpọ awọn ilana ni a ti ṣẹda fun idagbasoke awọn awoṣe ML; a ṣiṣẹ pẹlu olokiki julọ: и .
Lilo ilana ngbanilaaye lati mu iyara idagbasoke pọ si ati lo awọn irinṣẹ ti a ti ṣetan fun awọn iṣẹ ṣiṣe boṣewa.
Ni apẹẹrẹ yii a yoo ṣiṣẹ pẹlu PyTorch. Jẹ ki a fi sii:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchBayi a nilo lati ṣe ifilọlẹ Jupyter Notebook, ohun elo idagbasoke olokiki fun awọn alamọja ML. O gba ọ laaye lati kọ koodu ati lẹsẹkẹsẹ wo awọn abajade ti ipaniyan rẹ. Iwe akiyesi Jupyter wa pẹlu Anaconda ati pe o ti fi sii tẹlẹ lori olupin wa. O nilo lati sopọ si rẹ lati eto tabili tabili wa.
Lati ṣe eyi, a yoo kọkọ ṣe ifilọlẹ Jupyter lori olupin ti n ṣalaye ibudo 8080:
jupyter notebook --no-browser --port=8080 --allow-rootNigbamii, ṣiṣi taabu miiran ninu console Cmder wa (akojọ oke - Ibanisọrọ console Tuntun) a yoo sopọ nipasẹ ibudo 8080 si olupin nipasẹ SSH:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameNigbati a ba tẹ aṣẹ akọkọ, a yoo fun wa ni awọn ọna asopọ lati ṣii Jupyter ninu ẹrọ aṣawakiri wa:
To access the notebook, open this file in a browser:
file:///root/.local/share/jupyter/runtime/nbserver-18788-open.html
Or copy and paste one of these URLs:
http://localhost:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
or http://127.0.0.1:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
Jẹ ki a lo ọna asopọ fun localhost: 8080. Daakọ ọna kikun ki o si lẹẹmọ sinu ọpa adirẹsi ti ẹrọ aṣawakiri agbegbe ti PC rẹ. Jupyter Notebook yoo ṣii.
Jẹ ki a ṣẹda iwe ajako tuntun: Titun - Iwe akiyesi - Python 3.
Jẹ ki a ṣayẹwo iṣẹ ṣiṣe deede ti gbogbo awọn paati ti a fi sii. Jẹ ki a tẹ koodu PyTorch apẹẹrẹ sinu Jupyter ati ṣiṣe ipaniyan (Bọtini Ṣiṣe):
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
Abajade yẹ ki o jẹ nkan bi eyi:
Ti o ba ni abajade ti o jọra, lẹhinna a ti tunto ohun gbogbo ni deede ati pe a le bẹrẹ idagbasoke nẹtiwọọki nkankikan!
Ṣiṣẹda nẹtiwọọki nkankikan
A yoo ṣẹda nẹtiwọki nkankikan fun idanimọ aworan. Jẹ ki a gba eyi gẹgẹbi ipilẹ .
A yoo lo data CIFAR10 ti o wa ni gbangba lati ṣe ikẹkọ nẹtiwọọki naa. O ni awọn kilasi: "ọkọ ofurufu", "ọkọ ayọkẹlẹ", "eye", "ologbo", "deer", "aja", "ọpọlọ", "ẹṣin", "ọkọ oju omi", "oko". Awọn aworan ni CIFAR10 jẹ 3x32x32, iyẹn ni, awọn aworan awọ ikanni 3 ti awọn piksẹli 32 × 32.
Fun iṣẹ, a yoo lo package ti a ṣẹda nipasẹ PyTorch fun ṣiṣẹ pẹlu awọn aworan - ògùṣọ.
A yoo ṣe awọn igbesẹ wọnyi ni ibere:
- Ikojọpọ ati deede ikẹkọ ati awọn eto data idanwo
- Nẹtiwọki Nẹtiwọọki Itumọ
- Ikẹkọ nẹtiwọki lori data ikẹkọ
- Idanwo nẹtiwọki lori data idanwo
- Jẹ ki a tun ikẹkọ ati idanwo ni lilo GPU
A yoo ṣe gbogbo koodu ti o wa ni isalẹ ni Jupyter Notebook.
Ikojọpọ ati deede CIFAR10
Daakọ ati ṣiṣẹ koodu atẹle ni Jupyter:
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')Idahun si yẹ ki o jẹ:
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Extracting ./data/cifar-10-python.tar.gz to ./data
Files already downloaded and verifiedJẹ ki a ṣe afihan ọpọlọpọ awọn aworan ikẹkọ fun idanwo:
import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()
# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
Nẹtiwọki Nẹtiwọọki Itumọ
Jẹ ki a kọkọ wo bii nẹtiwọọki nkankikan fun idanimọ aworan ṣe n ṣiṣẹ. Eyi jẹ nẹtiwọọki aaye-si-ojuami ti o rọrun. O gba data titẹ sii, o kọja nipasẹ awọn ipele pupọ ni ẹyọkan, ati lẹhinna gbejade data iṣelọpọ nikẹhin.
Jẹ ki a ṣẹda nẹtiwọki ti o jọra ni agbegbe wa:
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
A tun ṣalaye iṣẹ ipadanu ati olupilẹṣẹ
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)Ikẹkọ nẹtiwọki lori data ikẹkọ
Jẹ ki a bẹrẹ ikẹkọ nẹtiwọọki nkankikan wa. Jọwọ ṣe akiyesi pe lẹhin ṣiṣe koodu yii, iwọ yoo nilo lati duro fun igba diẹ titi iṣẹ yoo fi pari. O gba mi iṣẹju marun. Yoo gba akoko lati kọ nẹtiwọọki naa.
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
A gba abajade wọnyi:
A fipamọ awoṣe ikẹkọ wa:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)Idanwo nẹtiwọki lori data idanwo
A ṣe ikẹkọ nẹtiwọọki nipa lilo ṣeto data ikẹkọ kan. Ṣugbọn a nilo lati ṣayẹwo boya nẹtiwọki naa ti kọ ohunkohun rara.
A yoo ṣe idanwo eyi nipa sisọ asọtẹlẹ aami kilasi ti nẹtiwọọki nkankikan ṣe jade ati idanwo rẹ lati rii boya o jẹ otitọ. Ti asọtẹlẹ ba tọ, a ṣafikun apẹẹrẹ si atokọ ti awọn asọtẹlẹ to tọ.
Jẹ ki a ṣe afihan aworan kan lati inu eto idanwo naa:
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
Bayi jẹ ki a beere lọwọ nẹtiwọọki nkankikan lati sọ fun wa kini ohun ti o wa ninu awọn aworan wọnyi:
net = Net()
net.load_state_dict(torch.load(PATH))
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
Awọn abajade dabi ẹni pe o dara: nẹtiwọọki naa ṣe idanimọ ni deede mẹta ninu awọn aworan mẹrin.
Jẹ ki a wo bii nẹtiwọọki ṣe n ṣiṣẹ kọja gbogbo dataset.
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
O dabi pe nẹtiwọọki mọ nkan kan ati pe o n ṣiṣẹ. Ti o ba pinnu awọn kilasi ni laileto, deede yoo jẹ 10%.
Bayi jẹ ki a wo iru awọn kilasi ti nẹtiwọọki n ṣe idanimọ dara julọ:
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
O dabi pe nẹtiwọọki naa dara julọ ni idamo awọn ọkọ ayọkẹlẹ ati awọn ọkọ oju omi: 71% deede.
Nitorina nẹtiwọki n ṣiṣẹ. Bayi jẹ ki a gbiyanju lati gbe awọn oniwe-ise si awọn eya isise (GPU) ati ki o wo ohun ti ayipada.
Ikẹkọ nẹtiwọọki nkankikan lori GPU
Ni akọkọ, Emi yoo ṣalaye ni ṣoki kini CUDA jẹ. CUDA (Iṣiro Iṣọkan Ẹrọ Iṣiro) jẹ iru ẹrọ iširo ti o jọra ti o dagbasoke nipasẹ NVIDIA fun ṣiṣe iṣiro gbogbogbo lori awọn ẹya sisẹ awọn eya aworan (GPUs). Pẹlu CUDA, awọn olupilẹṣẹ le mu awọn ohun elo iširo pọ si nipa gbigbe agbara GPUs ṣiṣẹ. Syeed yii ti wa tẹlẹ sori olupin wa ti a ra.
Jẹ ki a kọkọ ṣalaye GPU wa bi ẹrọ cuda akọkọ ti o han.
device = torch . device ( "cuda:0" if torch . cuda . is_available () else "cpu" )
# Assuming that we are on a CUDA machine, this should print a CUDA device:
print ( device )
Fifiranṣẹ nẹtiwọki si GPU:
net.to(device)A yoo tun ni lati firanṣẹ awọn igbewọle ati awọn ibi-afẹde ni igbesẹ kọọkan si GPU:
inputs, labels = data[0].to(device), data[1].to(device)Jẹ ki a tun kọ nẹtiwọọki lori GPU:
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data[0].to(device), data[1].to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')Ni akoko yii, ikẹkọ nẹtiwọọki duro nipa awọn iṣẹju 3. Jẹ ki a ranti pe ipele kanna lori ero isise aṣa jẹ iṣẹju marun 5. Iyatọ naa ko ṣe pataki, eyi ṣẹlẹ nitori nẹtiwọọki wa ko tobi pupọ. Nigbati o ba nlo awọn akojọpọ nla fun ikẹkọ, iyatọ laarin iyara GPU ati ero isise ibile yoo pọ si.
Iyẹn dabi pe o jẹ gbogbo rẹ. Ohun ti a ṣakoso lati ṣe:
- A wo kini GPU jẹ ati yan olupin lori eyiti o ti fi sii;
- A ti ṣeto agbegbe sọfitiwia lati ṣẹda nẹtiwọọki nkankikan;
- A ṣẹda nẹtiwọọki nkankikan fun idanimọ aworan ati ikẹkọ;
- A tun ṣe ikẹkọ nẹtiwọọki nipa lilo GPU ati gba ilosoke ninu iyara.
Emi yoo dun lati dahun awọn ibeere ninu awọn asọye.
orisun: www.habr.com