Teie esimene närvivõrk graafikaprotsessoril (GPU). Algajatele mõeldud juhend

Selles artiklis räägin, kuidas 30 minutiga seadistada keskkond masinõppe jaoks, luua pildituvastamiseks närvivõrk ja seejärel käivitada sama võrk graafikaprotsessoril (GPU).

Alustame sellega, mis on närvivõrk.

Meie puhul on see matemaatiline mudel, samuti selle programmiline või riistvaraline kehastus, mis on üles ehitatud bioloogiliste närvivõrkude — elusorganismide närvirakkude — organisatsiooni ja toimimise printsiipide järgi. See mõisted tekkisid aju toimimise uurimise käigus ja selle protsesside modelleerimise katses.

Närvivõrke ei programmeerita tavas mõttes, vaid need õpitakse. Õppimise võimalus on närvivõrkude üks peamisi eeliseid traditsiooniliste algoritmide ees. Tehniliselt seisneb õppimine neuronite vaheliste ühenduste koefitsientide leidmises. Õppeprotsessi käigus suudab närvivõrk tuvastada keerulisi seoseid sissesiandmete ja väljundite vahel ning teostada üldistamist.

Masinõppe vaatenurgast on närvivõrk erijuht tunnustamistuvastuse, diskrimineerimisanalüüsi, klasterdamismeetodite ja muude meetodite osas.

Varustus

Esmalt vaatame varustust. Me vajame serverit, millel on paigaldatud Linuxi operatsioonisüsteem. Masinõppe süsteemide tööks vajalik riistvara peab olema piisavalt võimas ja seega ka kallis. Neile, kes ei saa head masinat käeulatuses, soovitan pöörata tähelepanu pilveteenuse pakkujate pakkumistele. Vajalikku serverit saab kiiresti rentida ja maksta ainult kasutamise aja eest.

Projektides, kus on vajalik närvivõrkude loomine, kasutan ühe vene pilveteenuse pakkuja servereid. Ettevõte pakub masinõppe jaoks spetsiaalselt tugevaid Tesla V100 graafikaprotsessoreid (GPU) rentimiseks. Ütlen lühidalt: GPU kasutamine võib olla kümneid kordi tõhusam (kiirem) võrreldes samas hinnaklassis CPU-d (keskprotsessor, millest kõik on hästi teadlikud) kasutava serveriga. See saavutatakse GPU arhitektuuri eripärade tõttu, mis suudab arvutusi kiiremini teostada.

Käesolevas näites, mis on edaspidi kirjeldatud, ostsime mõneks päevaks järgmise serveri:

• SSD ketas 150 GB
• RAM 32 GB
• Protsessor Tesla V100 16 Gb 4 tuumaga

Meie masinale on installitud Ubuntu 18.04.

Installime keskkonna

Nüüd installime serverile kõik vajalikud tööriistad. Kuna meie artikkel on peamiselt suunatud algajatele, räägin selles mõningatest punktidest, mis neile kasulikud on.

Palju tööd keskkonna seadistamisel tehakse käsurea kaudu. Enamik kasutajatest kasutab tööoperatsioonisüsteemina Windowsi. Selle opsüsteemi standardne konsool jätab soovida. Seetõttu kasutame mugavat tööriista Cmder/. Laadige alla mini versioon ja käivitage Cmder.exe. Edasi tuleb serveriga ühendada SSH protokolli kaudu:

ssh root@server-ip-or-hostname

Serveri IP-koodi või DNS-nime sisestamiseks asendage server-ip-or-hostname. Edasi sisestage parool ja edukal ühendamisel peaksime saama umbes sellise sõnumi.

Tere tulemast Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)

ML mudelite arendamiseks on peamine keel Python. Ja kõige populaarsem platvorm selle kasutamiseks Linuxi all on Anaconda.

Installime selle meie serverile.

Alustame kohaliku pakihalduri värskendamisega:

sudo apt-get update

Installime curl (käsklusprogramm):

sudo apt-get install curl

Laadime alla Anaconda Distributsiooni viimase versiooni:

cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.sh

Käivitame installatsiooni:

bash Anaconda3-2019.10-Linux-x86_64.sh

Installimise käigus tuleb nõustuda litsentsilepinguga. Eduka installimise korral peaksite nägema seda:

Aitäh, et installisite Anaconda3!

ML mudelite arendamiseks on loodud palju raamistikku, me töötame kõige populaarsematega: PyTorch ja Tensorflow.

Raamistiku kasutamine võimaldab arenduse kiirus kasvada ja kasutada juba olemasolevaid tööriistu standardsete ülesannete täitmiseks.

Selles näites töötame PyTorchiga. Installime selle:

conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

Nüüd peame käivitama Jupyter Notebooki — ML spetsialistide seas populaarse arendustööriista. See võimaldab kirjutada koodi ja kohe näha selle täitmise tulemusi. Jupyter Notebook on Anaconda osaks ja juba installitud meie serverisse. Peame sellele oma töölauasüsteemist ühenduma.

Selleks käivitame kõigepealt Jupyter serveris, määrates pordi 8080:

jupyter notebook --no-browser --port=8080 --allow-root

Seejärel avame meie konsoolis Cmder veel ühe vahekaart (ülemine menüü — New console dialog) ja ühendame SSH kaudu serveriga pordil 8080:

ssh -L 8080:localhost:8080 root@server-ip-or-hostname

Esimese käsu sisestamisel pakutakse meile linke Jupyter'i avamiseks meie brauseris:

Notebooksse pääsemiseks avage see fail brauseris:
        file:///root/.local/share/jupyter/runtime/nbserver-18788-open.html
    Või kopeerige ja kleepige mõni neist URL-idest:
        http://localhost:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
     või http://127.0.0.1:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311

Kasutame linki localhost:8080. Kopeerige täielik tee ja kleepige see teie PC kohalikku brauseri aadressiribale. Jupyter Notebook avaneb.

Loome uue notepad'i: New — Notebook — Python 3.

Kontrollime, et kõik installitud komponendid töötavad õigesti. Sisestame Jupyterisse PyTorch'i koodi näite ja käivitame selle (nupp Run):

from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)

Tulemus peaks olema umbes selline:

Kui teil on sarnane tulemus — siis on meil kõik õigesti seadistatud ja saame alustada närvivõrgu arendamist!

Loome närvivõrgu

Loome närvivõrgu piltide ära tundmiseks. Meie aluseks on järgmine juhend.

Võrgu treenimiseks kasutame avalikku CIFAR10 andmekogumit. Sellel on klassid: „lennuk“, „auto“, „lind“, „kass“, „hirv“, „koer“, „konn“, „hobune“, „laev“, „veok“. CIFAR10 pildid on mõõtmetega 3x32x32, st kolmekanalilised värvilised pildid, mille suurus on 32×32 pikslit.

Töötamiseks kasutame loodud PyTorch'i paketti piltide töötlemiseks — torchvision.

Teeme järgmised sammud järjekorras:

• Treening- ja testandmete komplektide laadimine ja normaliseerimine
• Närvivõrgu määratlemine
• Võrgu treenimine koolitusandmetel
• Võrgu testimine testandmetel
• Kordame treenimist ja testimist GPU kasutamisega

Kogu allpool toodud koodi täidame Jupyter Notebooks.

CIFAR10 laadimine ja normaliseerimine

Kopeerige ja käivitage Jupyter'is järgmine kood:

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 = ('lennuk', 'auto', 'lind', ' kass',
           'hirv', 'koer', 'konn', 'hobune', 'laev', 'veok')

Vastus peaks olema järgmine:

Laadimine https:\/\/www.cs.toronto.edu\/~kriz\/cifar-10-python.tar.gz .\/data\/cifar-10-python.tar.gz
Pakkimine .\/data\/cifar-10-python.tar.gz .\/data
Failid on juba alla laaditud ja kontrollitud

Kuvame mõned treeningpildid kontrollimiseks:

import matplotlib.pyplot as plt
import numpy as np

# funktsioon pildi kuvamiseks

def imshow(img):
    img = img \/ 2 + 0.5     # normaliseerimine tagasi
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

# võtame mõned juhuslikud treeningpildid
dataiter = iter(trainloader)
images, labels = dataiter.next()

# kuvame pilte
imshow(torchvision.utils.make_grid(images))
# prindime sildid
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

Närvivõrgu määratlemine

Vaadakem kõigepealt, kuidas töötab piltide tuvastamise närvivõrk. See on lihtne otseühenduste võrk. See võtab sisendi, edastab selle läbi mitme kihi järjestikku ja seejärel annab lõpuks väljundi.

Loome meie keskkonnas sarnase võrgu:

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

Määrame ka kaotuse funktsiooni ja optimeerija

import torch.optim as optim

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

Võrgu treenimine koolitusandmetel

Alustame meie närvivõrgu treeningut. Tõin välja, et pärast koodi käivitamist peate ootama mõnda aega, kuni see lõpule jõuab. Minu jaoks võttis see 5 minutit. Võrgu treenimiseks on vajalik aeg.

 kuni aeg, kui vahemik on 2: # kordame andmeid mitu korda

 jooksva_kadu = 0.0
 kõigi, andmete_hulgad in enumerate(trainloader, 0):
 # saame sisendid; andmed on loend [sisendid, sildid]
 sisendid, sildid = andmed

 # nullime parameetrite gradandid
 optimizer.zero_grad()

 # edasi + tagasi + optimeeri
 väljundid = net(sisendid)
 kadumine = criterion(väljundid, sildid)
 kadumine.backward()
 optimizer.step()

 # trüki statistika
 jooksva_kadu += kadumine.item()
 kui i % 2000 == 1999: # prindi välja iga 2000 mini-batch'ide kohta
 print('[%d, ] kadumine: %.3f' %
 (aeg + 1, i + 1, jooksva_kadu / 2000))
 jooksva_kadu = 0.0

print('Koolitus lõpetatud')

Saame sellise tulemuse:

Salvestame meie koolitatud mudeli:

PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)

Võrgu testimine testandmetel

Olemegi koolitanud võrku, kasutades koolitusandmete kogumit. Kuid peame kontrollima, kas võrku on üldse midagi õpetatud.

Kontrollime seda, ennustades klassi sildi, mis väljundit annab närvivõrk, ja kontrollides seda tõe suhtes. Kui ennustus on õige, lisame näite õigete ennustuste loendisse.
Kujutame ette pilti testimiskogust:

dataiter = iter(testloader)
pildid, sildid = dataiter.next()

# trüki pildid
imshow(torchvision.utils.make_grid(pildid))
print('Tõeline tõde: ', ' '.join('%5s' % klassid[sildid[j]] for j in range(4)))

Nüüd palume närvivõrgul öelda meile, mis nende piltide peal on:

net = Net()
net.load_state_dict(torch.load(PATH))

väljundid = net(pildid)

_, ennustatud = torch.max(väljundid, 1)

print('Ennustatud: ', ' '.join('%5s' % klassid[ennustatud[j]]
                              for j in range(4)))

Tulemused näivad üsna head: võrk tuvastas õigesti kolm pilti neljast.

Vaatame, kuidas võrku töötab kogu andmekogumiga.

õige = 0
total = 0
with torch.no_grad():
    for andmed in testloader:
        pildid, sildid = andmed
        väljundid = net(pildid)
        _, ennustatud = torch.max(väljundid.data, 1)
        total += sildid.size(0)
        õige += (ennustatud == sildid).sum().item()

print('Võrgu täpsus 10000 testpildil: %d %%' % (
    100 * õige / total))

Tundub, et võrk teab midagi ja töötab. Kui ta määraks klassid juhuslikult, oleks täpsus 10%.

Nüüd vaatame, milliseid klasse võrk paremini määrab:

klass_oige = list(0. for i in range(10))
klass_kokku = list(0. for i in range(10))
with torch.no_grad():
 for andmed in testloader:
 pildid, sildid = andmed
 väljundid = net(pildid)
 _, ennustanud = torch.max(väljundid, 1)
 c = (ennustanud == sildid).squeeze()
 for i in range(4):
 silt = sildid[i]
 klass_oige[silt] += c[i].item()
 klass_kokku[silt] += 1


for i in range(10):
 print('Täpsus %5s : %%' % (
 klassid[i], 100 * klass_oige[i] / klass_kokku[i]))

Tundub, et võrk määrab kõige paremini autosid ja laevu: 71% täpsus.

Nii et võrk töötab. Nüüd proovime viia selle töö graafikakaardile (GPU) ja vaatame, mis muutub.

Närvivõrgu treenimine GPU-l

Esialgu selgitan lühidalt, mis on CUDA. CUDA (Compute Unified Device Architecture) on NVIDIA loodud paralleelsete arvutuste platvorm üldiseks arvutamiseks graafikaprotsessoritel (GPU-del). CUDA abil saavad arendajad märkimisväärselt kiirendada arvutusrakendusi, kasutades grafikaeidmise protsessorite võimet. Meie ostetud serveris on see platvorm juba paigaldatud.

Alustame meie GPU määratlemisega kui esimesest nähtavast cuda seadmetest.

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Eeldades, et oleme CUDA masinas, peaks see printima CUDA seadme:
print(device)

Saadetame võrgustiku GPU-le:

net.to(device)

Peame samuti saadetama sisendid ja sihid igal sammul GPU-le:

inputs, labels = data[0].to(device), data[1].to(device)

Käivitame võrgu uuestiõppimise juba GPU-l:

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for aeg in range(2): # kordame andmeid mitu korda

 jooksva_kadu = 0.0
 for i, andmed in enumerate(trainloader, 0):
 # saame sisendid; andmed on loend [sisendid, sildid]
 sisendid, sildid = andmed[0].to(device), andmed[1].to(device)

 # nullime parameetrite gradandid
 optimizer.zero_grad()

 # edasi + tagasi + optimeeri
 väljundid = net(sisendid)
 kadumine = criterion(väljundid, sildid)
 kadumine.backward()
 optimizer.step()

 # trüki statistika
 jooksva_kadu += kadumine.item()
 kui i % 2000 == 1999: # prindi välja iga 2000 mini-batch'ide kohta
 print('[%d, ] kadumine: %.3f' %
 (aeg + 1, i + 1, jooksva_kadu / 2000))
 jooksva_kadu = 0.0

print('Koolitus lõpetatud')

Seekord kestis võrgu õpetamine umbes 3 minutit. Kinnitatakse, et sama etapp tavalisel protsessoril kestis 5 minutit. Erinevus pole oluline, see toimub seetõttu, et meie võrk ei ole nii suur. Suurte andmekogumite kasutamisel suureneb erinevus GPU ja traditsioonilise protsessori töökiirusel.

Tundub, et see on kõik. Mida me saavutasime:

• Me uurisime, mis on GPU ja valisime serveri, millel see on paigaldatud;
• Me seadsime üles programmikeskkonna närvivõrgu loomiseks;
• Me tegime närvivõrgu piltide tuvastamiseks ja koolitasime seda;
• Me kordasime võrgu õpetamist GPU abil ja saime kiirusetõusu.

Olen valmis vastama küsimustele kommentaarides.

Allikas: habr.com