Artikulu honetan, 30 minututan makina ikasteko ingurune bat konfiguratu, irudiak ezagutzeko sare neuronal bat nola sortu eta gero sare bera exekutatu prozesadore grafiko batean (GPU) esango dizut.
Lehenik eta behin, defini dezagun zer den sare neuronal bat.
Gure kasuan, hau eredu matematiko bat da, baita bere softwarea edo hardwarea gauzatzea ere, neurona-sare biologikoen antolakuntza eta funtzionamendu printzipioan eraikia - organismo bizidun baten nerbio-zelulen sareak. Kontzeptu hau garunean gertatzen diren prozesuak aztertzen eta prozesu horiek modelatzen saiatzean sortu zen.
Sare neuronalak ez daude hitzaren ohiko zentzuan programatzen, trebatu egiten dira. Ikasteko gaitasuna da sare neuronalen abantaila nagusietako bat algoritmo tradizionalen aurrean. Teknikoki, ikaskuntza neuronen arteko konexio-koefizienteak aurkitzean datza. Prestakuntza-prozesuan zehar, sare neuronalak sarrerako datuen eta irteerako datuen arteko mendekotasun konplexuak identifikatzeko gai da, baita orokortzea ere.
Ikaskuntza automatikoaren ikuspuntutik, sare neuronal bat ereduak ezagutzeko metodoen, analisi diskriminatzaileen, clustering metodoen eta beste metodo batzuen kasu berezi bat da.
Оборудование
Lehenik eta behin, ikus ditzagun ekipamendua. Linux sistema eragilea instalatuta duen zerbitzari bat behar dugu. Ikaskuntza automatikoko sistemak funtzionatzeko behar den ekipamendua nahiko indartsua da eta, ondorioz, garestia. Eskuartean makina ona ez dutenentzat, hodeiko hornitzaileen eskaintzei arreta jartzea gomendatzen diet. Beharrezko zerbitzaria azkar alokatu dezakezu eta erabilera-denbora bakarrik ordaindu.
Neurona-sareak sortzea beharrezkoa den proiektuetan, Errusiako hodei-hornitzaileetako baten zerbitzariak erabiltzen ditut. Konpainiak hodeiko zerbitzariak alokatzeko eskaintzen ditu ikasketa automatikorako bereziki NVIDIAren Tesla V100 prozesadore grafiko (GPU) indartsuekin. Laburbilduz: GPUdun zerbitzari bat erabiltzea hamar aldiz eraginkorragoa (azkar) izan daiteke kalkuluetarako CPU bat (prozesatzeko unitate zentral ezaguna) erabiltzen duen antzeko kostua duen zerbitzari batekin alderatuta. Hau GPU arkitekturaren ezaugarriengatik lortzen da, kalkuluei azkarrago aurre egiten diena.
Jarraian azaltzen diren adibideak ezartzeko, zerbitzari hau erosi dugu hainbat egunetarako:
- SSD diskoa 150 GB
- RAM 32 GB
- Tesla V100 16 Gb prozesadorea 4 nukleorekin
Ubuntu 18.04 instalatu dugu gure makinan.
Ingurunearen ezarpena
Orain instala dezagun zerbitzarian lan egiteko beharrezkoa dena. Gure artikulua batez ere hasiberrientzat denez, haientzat erabilgarriak izango diren puntu batzuei buruz hitz egingo dut.
Ingurune bat konfiguratzean lan asko komando-lerroaren bidez egiten da. Erabiltzaile gehienek Windows erabiltzen dute laneko sistema eragile gisa. OS honetako kontsola estandarrak asko uzten du. Hori dela eta, tresna eroso bat erabiliko dugu . Deskargatu mini bertsioa eta exekutatu Cmder.exe. Ondoren SSH bidez zerbitzarira konektatu behar duzu:
ssh root@server-ip-or-hostnameServer-ip-or-hostname-ren ordez, zehaztu zure zerbitzariaren IP helbidea edo DNS izena. Ondoren, sartu pasahitza eta konexioa arrakastatsua bada, honen antzeko mezu bat jaso beharko genuke.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)ML ereduak garatzeko hizkuntza nagusia Python da. Eta Linux-en erabiltzeko plataforma ezagunena da .
Instala dezagun gure zerbitzarian.
Tokiko paketeen kudeatzailea eguneratzen hasiko gara:
sudo apt-get updateInstalatu curl (komando-lerroko utilitatea):
sudo apt-get install curlDeskargatu Anaconda Distribution-en azken bertsioa:
cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shHasi gaitezen instalazioa:
bash Anaconda3-2019.10-Linux-x86_64.shInstalazio prozesuan zehar, lizentzia-kontratua berresteko eskatuko zaizu. Instalazio arrakastatsuan, hau ikusi beharko zenuke:
Thank you for installing Anaconda3!Gaur egun esparru asko sortu dira ML ereduak garatzeko; ezagunenekin lan egiten dugu: и .
Esparrua erabiltzeak garapen-abiadura handitzeko eta zeregin estandarrak egiteko prest dauden tresnak erabiltzeko aukera ematen du.
Adibide honetan PyTorch-ekin lan egingo dugu. Instala dezagun:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchOrain Jupyter Notebook abiarazi behar dugu, ML espezialistentzako garapen tresna ezaguna. Kodea idazteko eta bere exekuzioaren emaitzak berehala ikusteko aukera ematen du. Jupyter Notebook Anacondarekin sartuta dago eta dagoeneko gure zerbitzarian instalatuta dago. Gure mahaigaineko sistematik konektatu behar duzu.
Horretarako, lehenik Jupyter abiaraziko dugu zerbitzarian 8080 ataka zehaztuz:
jupyter notebook --no-browser --port=8080 --allow-rootOndoren, gure Cmder kontsolan beste fitxa bat irekiz (goiko menua - Kontsola berria elkarrizketa-koadroa) 8080 atakaren bidez konektatuko gara zerbitzariarekin SSH bidez:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameLehenengo komandoa sartzen dugunean, gure arakatzailean Jupyter irekitzeko estekak eskainiko zaizkigu:
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
Erabili dezagun esteka localhost:8080. Kopiatu bide osoa eta itsatsi zure ordenagailuko tokiko arakatzailearen helbide-barran. Jupyter Notebook irekiko da.
Sor dezagun koaderno berri bat: Berria - Koadernoa - Python 3.
Egiaztatu dezagun instalatu ditugun osagai guztien funtzionamendu zuzena. Sar dezagun adibideko PyTorch kodea Jupyter-en eta exekuta dezagun (Exekutatu botoia):
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
Emaitza honelako zerbait izan beharko litzateke:
Antzeko emaitza izanez gero, dena behar bezala konfiguratu dugu eta neurona-sare bat garatzen has gaitezke!
Sare neuronal bat sortzea
Irudiak ezagutzeko sare neuronal bat sortuko dugu. Har dezagun hau oinarritzat .
Publikoki eskuragarri dagoen CIFAR10 datu multzoa erabiliko dugu sarea trebatzeko. Klaseak ditu: “hegazkina”, “kotxea”, “txoria”, “katua”, “oreina”, “txakurra”, “igela”, “zaldia”, “ontzia”, “kamioia”. CIFAR10eko irudiak 3x32x32 dira, hau da, 3x32 pixeleko 32 kanaleko koloretako irudiak.
Lanerako, PyTorch-ek sortutako paketea erabiliko dugu irudiekin lan egiteko - torchvision.
Urrats hauek egingo ditugu ordenan:
- Prestakuntza eta proba datu multzoak kargatzea eta normalizatzea
- Sare neuronalaren definizioa
- Prestakuntza datuei buruzko sareko prestakuntza
- Sare-probak proba-datuen gainean
- Errepikatu ditzagun entrenamenduak eta probak GPU erabiliz
Beheko kode guztia Jupyter Notebook-en exekutatuko dugu.
CIFAR10 kargatzea eta normalizatzea
Kopiatu eta exekutatu hurrengo kodea Jupyter-en:
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')Erantzuna izan beharko litzateke:
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 verifiedErakuts ditzagun hainbat prestakuntza-irudi probak egiteko:
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)))
Sare neuronalaren definizioa
Ikus dezagun lehenik irudiak ezagutzeko sare neuronalak nola funtzionatzen duen. Puntutik puntuko sare sinple bat da. Sarrerako datuak hartzen ditu, banan-banan hainbat geruza zeharkatzen ditu eta, azkenean, irteerako datuak sortzen ditu.
Sor dezagun antzeko sare bat gure ingurunean:
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()
Era berean, galera funtzio bat eta optimizatzaile bat definitzen ditugu
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)Prestakuntza datuei buruzko sareko prestakuntza
Has gaitezen gure sare neuronalak entrenatzen. Kontuan izan kode hau exekutatu ondoren, denbora pixka bat itxaron beharko duzula lana amaitu arte. 5 minutu behar izan nituen. Denbora behar da sarea entrenatzeko.
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')
Emaitza hau lortzen dugu:
Gure prestatutako eredua gordetzen dugu:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)Sare-probak proba-datuen gainean
Entrenamendu-datu multzo bat erabiliz sarea entrenatu dugu. Baina sareak ezer ikasi duen egiaztatu behar dugu.
Hau probatuko dugu sare neuronalak ateratzen duen klase etiketa iragarriz eta egia den ikusteko. Iragarpena zuzena bada, lagina iragarpen zuzenen zerrendara gehitzen dugu.
Erakuts dezagun proba multzoko irudi bat:
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)))
Orain galde diezaiogun sare neuronalei argazki hauetan zer dagoen esateko:
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)))
Emaitzak nahiko onak dirudite: sareak lau argazkitik hiru zuzen identifikatu zituen.
Ikus dezagun sareak datu multzo osoan nola funtzionatzen duen.
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))
Badirudi sareak badakiela zerbait eta lanean ari dela. Klaseak ausaz zehaztuko balitu, zehaztasuna %10ekoa izango litzateke.
Ikus dezagun sareak hobeto identifikatzen dituen klaseak:
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]))
Badirudi sarea dela onena autoak eta ontziak identifikatzeko: %71eko zehaztasuna.
Beraz, sarea lanean ari da. Orain saia gaitezen bere lana prozesadore grafikora (GPU) transferitzen eta ikusi zer aldatzen den.
Sare neuronal bat GPUn trebatzea
Lehenik eta behin, CUDA zer den laburki azalduko dut. CUDA (Compute Unified Device Architecture) NVIDIAk grafiko prozesatzeko unitateetan (GPU) konputazio orokorrerako garatutako konputazio plataforma paraleloa da. CUDArekin, garatzaileek informatika-aplikazioak izugarri bizkor ditzakete GPUen boterea aprobetxatuz. Plataforma hau dagoeneko instalatuta dago erosi dugun zerbitzarian.
Lehenik eta behin, defini dezagun gure GPU ikusgai dagoen lehen gailu gisa.
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 )
Sarea GPUra bidaltzea:
net.to(device)Urrats bakoitzean sarrerak eta helburuak ere bidali beharko ditugu GPUra:
inputs, labels = data[0].to(device), data[1].to(device)Berriro entrenatu dezagun sarea GPUan:
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')Oraingoan, sareko entrenamenduak 3 minutu inguruko iraupena izan du. Gogora dezagun ohiko prozesadore batean etapa berak 5 minutu iraun zituela. Aldea ez da nabarmena, hau gure sarea hain handia ez delako gertatzen da. Prestakuntzarako matrize handiak erabiltzen dituzunean, GPUaren eta prozesadore tradizional baten abiaduraren arteko aldea handitu egingo da.
Hori guztia omen da. Zer lortu genuen:
- GPU bat zer den aztertu dugu eta instalatuta dagoen zerbitzaria hautatu dugu;
- Sare neuronal bat sortzeko software ingurune bat ezarri dugu;
- Irudiak ezagutzeko sare neuronal bat sortu eta trebatu genuen;
- GPU erabiliz sareko entrenamendua errepikatu genuen eta abiadura igoera jaso genuen.
Pozik erantzungo ditut iruzkinetan galderei.
Iturria: www.habr.com