Di vê gotarê de, ez ê ji we re vebêjim ka meriv çawa di 30 hûrdeman de hawîrdorek fêrbûna makîneyê saz dike, ji bo naskirina wêneyê torgilokek neuralî biafirîne, û dûv re heman torê li ser pêvajoyek grafîkî (GPU) bimeşîne.
Pêşîn, bila em pênase bikin ka tora neuralî çi ye.
Di rewşa me de, ev modelek matematîkî ye, û her weha nermalava wê an jî cîhana wê ya hişk e, ku li ser prensîba rêxistin û xebata torên neuralî yên biyolojîkî - torgilokên hucreyên nervê yên organîzmayek zindî hatî çêkirin. Ev têgîn dema ku pêvajoyên di mejî de diqewimin lêkolîn dike û hewl dide van pêvajoyan model bike derket holê.
Tora neuralî di wateya adetî ya peyvê de ne bernamekirî ne, ew têne perwerde kirin. Hêza fêrbûnê yek ji avantajên sereke yên torên neuralî li ser algorîtmayên kevneşopî ye. Ji hêla teknîkî ve, fêrbûn ji dîtina hevrêzên girêdanên di navbera neuronan de pêk tê. Di dema pêvajoya perwerdehiyê de, tora neuralî dikare girêdanên tevlihev di navbera daneya têketin û daneya derketinê de nas bike, û hem jî gelemperîkirinê pêk bîne.
Ji hêla fêrbûna makîneyê ve, torgilokek neuralî dozek taybetî ya rêbazên naskirina nimûneyê, analîzên cihêreng, rêbazên komkirinê û rêbazên din e.
Amûr
Pêşîn, bila em li amûran binêrin. Pêdiviya me bi serverek heye ku pergala xebitandina Linux li ser hatî saz kirin. Amûrên ku ji bo xebitandina pergalên fêrbûna makîneyê hewce ne pir bi hêz û, wekî encam, biha ne. Ji bo kesên ku di destê wan de makîneyek baş tune, ez pêşniyar dikim ku bala xwe bidin pêşniyarên pêşkêşkerên ewr. Hûn dikarin servera hewce zû kirê bikin û tenê ji bo dema karanîna bidin.
Di projeyên ku pêdivî ye ku torên neuralî biafirînin, ez serverên yek ji pêşkêşkerên ewr ên rûsî bikar tînim. Pargîdanî serverên cloudê ji bo kirêkirinê bi taybetî ji bo fêrbûna makîneyê bi pêvajoyên grafîkî yên hêzdar Tesla V100 (GPU) ji NVIDIA pêşkêşî dike. Bi kurtasî: karanîna serverek bi GPU dikare bi dehan carî bikêrtir (zûtir) be li gorî serverek bi lêçûnek wekhev ku CPU (yekîneya pêvajoyek navendî ya navdar) ji bo hesaban bikar tîne. Ev ji ber taybetmendiyên mîmariya GPU-yê, ku zûtir bi hesaban re mijûl dibe, tê bidestxistin.
Ji bo bicihanîna mînakên ku li jêr hatine diyarkirin, me servera jêrîn çend rojan kirî:
- Dîska SSD 150 GB
- RAM 32 GB
- Pêvajoya Tesla V100 16 Gb bi 4 core
Me Ubuntu 18.04 li ser makîneya xwe saz kir.
Sazkirina jîngehê
Naha werin em her tiştê ku ji bo xebatê li ser serverê hewce dike saz bikin. Ji ber ku gotara me di serî de ji bo destpêkeran e, ez ê li ser hin xalên ku dê ji wan re kêrhatî bin biaxivim.
Gelek kar dema sazkirina hawîrdorek bi rêza fermanê ve tê kirin. Piraniya bikarhêneran Windows-ê wekî OS-ya xwe ya xebatê bikar tînin. Di vê OS-ê de konsolê standard pir ku were xwestin dihêle. Ji ber vê yekê, em ê amûrek hêsan bikar bînin . Guhertoya piçûk dakêşin û Cmder.exe bimeşînin. Dûv re hûn hewce ne ku bi serverê bi SSH-ê ve girêdayî bibin:
ssh root@server-ip-or-hostnameLi şûna server-ip-an-hostname, navnîşana IP-ê an navê DNS-ya servera xwe diyar bikin. Dûv re, şîfreyê binivîsin û heke girêdan serketî be, divê em peyamek bi vî rengî bistînin.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)Zimanê sereke ji bo pêşxistina modelên ML Python e. Û platforma herî populer a ji bo karanîna wê li Linux-ê ye .
Ka em wê li ser servera xwe saz bikin.
Em bi nûvekirina rêveberê pakêtê ya herêmî dest pê dikin:
sudo apt-get updateCurl saz bikin (bikaranîna rêzika fermanê):
sudo apt-get install curlGuhertoya herî dawî ya Anaconda Distribution dakêşin:
cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shKa em sazkirinê dest pê bikin:
bash Anaconda3-2019.10-Linux-x86_64.shDi pêvajoya sazkirinê de, dê ji we were xwestin ku peymana lîsansê piştrast bikin. Piştî sazkirina serkeftî divê hûn vê yekê bibînin:
Thank you for installing Anaconda3!Naha gelek çarçove ji bo pêşkeftina modelên ML hatine afirandin; em bi yên herî populer re dixebitin: и .
Bikaranîna çarçoveyê dihêle hûn leza pêşkeftinê zêde bikin û ji bo karên standard amûrên amade bikar bînin.
Di vê nimûneyê de em ê bi PyTorch re bixebitin. Ka em wê saz bikin:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchNaha pêdivî ye ku em Jupyter Notebook, amûrek pêşkeftinê ya populer ji bo pisporên ML-ê bidin destpêkirin. Ew dihêle hûn kodê binivîsin û tavilê encamên darvekirina wê bibînin. Jupyter Notebook bi Anaconda re tê de heye û jixwe li ser servera me hatî saz kirin. Pêdivî ye ku hûn wê ji pergala sermaseya me ve girêbidin.
Ji bo vê yekê, em ê pêşî Jupyter-ê li ser servera ku porta 8080 diyar dike dest pê bikin:
jupyter notebook --no-browser --port=8080 --allow-rootDûv re, di konsolê meya Cmder de tabloyek din vekin (menuya jorîn - Diyaloga konsolê ya nû) em ê bi porta 8080 ve bi serverê ve bi SSH ve girêbidin:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameDema ku em emrê yekem têkevin, dê ji me re girêdan werin pêşkêş kirin ku Jupyter di geroka xwe de vekin:
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
Ka em zencîreyê ji bo localhost bikar bînin: 8080. Rêya tevahî kopî bikin û wê li barika navnîşana geroka herêmî ya PC-ya xwe bixin. Jupyter Notebook dê vebe.
Ka em notebookek nû biafirînin: Nû - Notebook - Python 3.
Ka em xebata rast a hemî beşên ku me saz kirine kontrol bikin. Ka em mînaka koda PyTorch têkevin Jupyter û darvekirinê bimeşînin (bişkojka Run):
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
Divê encam tiştek weha be:
Ger we encamek wusa hebe, wê hingê me her tişt rast mîheng kiriye û em dikarin dest bi pêşxistina tora neuralî bikin!
Afirandina tora neuralî
Em ê ji bo naskirina wêneyê tora neuralî çêbikin. Em vê yekê ji xwe re esas bigirin .
Em ê daneheva CIFAR10 ya gelemperî ya berdest bikar bînin da ku torê perwerde bikin. Çînên wê hene: "balafir", "otomobîl", "çûk", "pisîk", "ker", "kûçik", "beq", "hesp", "gemî", "kamyon". Wêneyên di CIFAR10 de 3x32x32 ne, ango wêneyên rengîn ên 3-kanal ên 32x32 pixel in.
Ji bo xebatê, em ê pakêta ku ji hêla PyTorch ve hatî afirandin ji bo xebata bi wêneyan - torchvision bikar bînin.
Em ê gavên jêrîn bi rêzê bikin:
- Barkirin û normalîzekirina komên daneya perwerde û ceribandinê
- Pênase Tora Neuralî
- Perwerdehiya torê li ser daneyên perwerdehiyê
- Testkirina torê li ser daneyên testê
- Werin em bi karanîna GPU perwerdehî û ceribandinê dubare bikin
Em ê hemî koda jêrîn di Jupyter Notebook de bicîh bikin.
Barkirin û normalîzekirina CIFAR10
Koda jêrîn li Jupyter kopî bikin û bişopînin:
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')Divê bersiv ev be:
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 verifiedKa em çend wêneyên perwerdehiyê ji bo ceribandinê nîşan bidin:
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)))
Pênase Tora Neuralî
Ka em pêşî bifikirin ka torgilokek neuralî ji bo naskirina wêneyê çawa dixebite. Ev torgilokek xal-bi-xala hêsan e. Daneyên têketinê digire, yek bi yek di çend qatan re derbas dike û dûv re jî daneya derketinê çêdike.
Werin em di hawîrdora xwe de torgilokek wekhev biafirînin:
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()
Em di heman demê de fonksiyonek windabûnê û optimîzatorek jî diyar dikin
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)Perwerdehiya torê li ser daneyên perwerdehiyê
Werin em dest bi perwerdekirina tora xweya neuralî bikin. Ji kerema xwe not bikin ku piştî ku hûn vê kodê bimeşînin, hûn ê hewce bikin ku hindek dem bisekinin heya ku kar biqede. Ji min re 5 deqe girt. Ji bo perwerdekirina torê wext digire.
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')
Em encama jêrîn bistînin:
Em modela xweya perwerdekirî xilas dikin:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)Testkirina torê li ser daneyên testê
Me bi karanîna komek daneyên perwerdehiyê torê perwerde kir. Lê divê em kontrol bikin ka torê bi tevahî tiştek fêr bûye.
Em ê vê bi pêşbînîkirina etîketa pola ku tora neuralî derdixe biceribînin û ceribandina wê bikin da ku bibînin ka ew rast e. Ger pêşbînî rast be, em nimûneyê li navnîşa pêşbîniyên rast zêde dikin.
Ka em wêneyek ji koma testê nîşan bidin:
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)))
Naha em ji tora neuralî bipirsin ku ji me re bêje ka di van wêneyan de çi ye:
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)))
Encam pir baş xuya dikin: torê sê ji çar wêneyan rast nas kir.
Ka em bibînin ka torgilok çawa li seranserê databasê tevdigere.
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))
Wusa dixuye ku torê tiştek dizane û dixebite. Ger wî dersên rasthatî destnîşan bike, dê rastbûn %10 be.
Naha em bibînin ka kîjan çînên torê çêtir nas dike:
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]))
Wusa dixuye ku tor di naskirina otomobîl û keştiyan de çêtirîn e: 71% rastbûn.
Ji ber vê yekê torê dixebite. Naha em hewl bidin ku xebata wê veguhezînin pêvajoya grafîkê (GPU) û bibînin ka çi diguhezîne.
Perwerdekirina tora neuralî li ser GPU
Pêşîn, ez ê bi kurtasî rave bikim ka CUDA çi ye. CUDA (Compute Unified Device Architecture) platformek hesabkirina paralel e ku ji hêla NVIDIA ve hatî pêşve xistin ji bo hesabkirina gelemperî li ser yekîneyên pêvajoyek grafîkê (GPU). Bi CUDA re, pêşdebiran dikarin bi karanîna hêza GPU-an ve serîlêdanên hesabkirinê bi rengek dramatîk bilez bikin. Ev platform jixwe li ser servera me ya ku me kirî hatiye saz kirin.
Werin em pêşî GPU-ya xwe wekî yekem cîhaza cûda ya xuyayî pênase bikin.
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 )
Şandina torê ji GPU re:
net.to(device)Em ê her weha neçar in ku di her gavê de têketin û armanc ji GPU re bişînin:
inputs, labels = data[0].to(device), data[1].to(device)Ka em torê li ser GPU ji nû ve perwerde bikin:
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')Vê carê perwerdeya torê bi qasî 3 deqîqeyan dewam kir. Ka em bînin bîra xwe ku heman qonax li ser pêvajoyek kevneşopî 5 hûrdem dom kir. Cûdahî ne girîng e, ji ber ku tora me ne ewqas mezin e ev dibe. Dema ku rêzikên mezin ji bo perwerdehiyê bikar bînin, dê cûdahiya di navbera leza GPU û pêvajoyek kevneşopî de zêde bibe.
Ew xuya dike ku hemî. Tiştê ku me karî kir:
- Me mêze kir ku GPU çi ye û servera ku li ser hatî saz kirin hilbijart;
- Me hawîrdorek nermalavê saz kiriye da ku tora neuralî biafirîne;
- Me ji bo naskirina wêneyê tora neuralî çêkir û ew perwerde kir;
- Me perwerdehiya torê bi karanîna GPU dubare kir û lezek zêde wergirt.
Ez ê kêfxweş bibim ku di şîroveyan de bersiva pirsan bidim.
Source: www.habr.com