Katika makala hii, nitakuambia jinsi ya kuanzisha mazingira ya kujifunza mashine kwa dakika 30, kuunda mtandao wa neural kwa utambuzi wa picha, na kisha kukimbia mtandao huo kwenye processor ya graphics (GPU).
Kwanza, hebu tufafanue mtandao wa neva ni nini.
Kwa upande wetu, hii ni mfano wa hisabati, pamoja na programu yake au embodiment ya vifaa, iliyojengwa juu ya kanuni ya shirika na utendaji wa mitandao ya neural ya kibaolojia - mitandao ya seli za ujasiri za kiumbe hai. Wazo hili liliibuka wakati wa kusoma michakato inayotokea kwenye ubongo na kujaribu kuiga michakato hii.
Mitandao ya neva haijapangwa kwa maana ya kawaida ya neno, imefunzwa. Uwezo wa kujifunza ni mojawapo ya faida kuu za mitandao ya neural juu ya algoriti za kitamaduni. Kitaalamu, kujifunza kunajumuisha kutafuta coefficients ya miunganisho kati ya niuroni. Wakati wa mchakato wa mafunzo, mtandao wa neva unaweza kutambua utegemezi changamano kati ya data ya pembejeo na data ya pato, na pia kufanya jumla.
Kwa mtazamo wa kujifunza kwa mashine, mtandao wa neva ni kesi maalum ya mbinu za utambuzi wa muundo, uchambuzi wa kibaguzi, mbinu za kuunganisha na mbinu nyingine.
ΠΠ±ΠΎΡΡΠ΄ΠΎΠ²Π°Π½ΠΈΠ΅
Kwanza, hebu tuangalie vifaa. Tunahitaji seva iliyo na mfumo wa uendeshaji wa Linux uliowekwa juu yake. Vifaa vinavyohitajika kuendesha mifumo ya kujifunza mashine ni nguvu kabisa na, kwa sababu hiyo, ni ghali. Kwa wale ambao hawana mashine nzuri karibu, ninapendekeza kulipa kipaumbele kwa matoleo ya watoa huduma wa wingu. Unaweza kukodisha seva inayohitajika haraka na kulipa tu kwa wakati wa matumizi.
Katika miradi ambapo ni muhimu kuunda mitandao ya neural, ninatumia seva za mmoja wa watoa huduma wa wingu wa Kirusi. Kampuni inatoa seva za wingu kwa ajili ya kukodisha mahususi kwa ajili ya kujifunza mashine na vichakataji michoro vya Tesla V100 (GPU) kutoka NVIDIA. Kwa kifupi: kutumia seva iliyo na GPU inaweza kuwa makumi ya mara kwa ufanisi zaidi (haraka) ikilinganishwa na seva ya gharama sawa inayotumia CPU (kitengo kikuu cha usindikaji kinachojulikana) kwa hesabu. Hii inafanikiwa kutokana na vipengele vya usanifu wa GPU, ambayo inakabiliana na mahesabu kwa kasi zaidi.
Ili kutekeleza mifano iliyoelezwa hapa chini, tulinunua seva ifuatayo kwa siku kadhaa:
- diski ya SSD 150 GB
- RAM 32 GB
- Kichakataji cha Tesla V100 16 Gb chenye cores 4
Tuliweka Ubuntu 18.04 kwenye mashine yetu.
Kuweka mazingira
Sasa hebu tusakinishe kila kitu muhimu kwa kazi kwenye seva. Kwa kuwa nakala yetu ni ya wanaoanza, nitazungumza juu ya vidokezo ambavyo vitakuwa muhimu kwao.
Kazi nyingi wakati wa kuanzisha mazingira hufanywa kupitia mstari wa amri. Watumiaji wengi hutumia Windows kama OS yao inayofanya kazi. Console ya kawaida katika OS hii inaacha kuhitajika. Kwa hiyo, tutatumia chombo cha urahisi . Pakua toleo la mini na uendeshe Cmder.exe. Ifuatayo unahitaji kuunganishwa na seva kupitia SSH:
ssh root@server-ip-or-hostnameBadala ya seva-ip-au-hostname, taja anwani ya IP au jina la DNS la seva yako. Ifuatayo, ingiza nenosiri na ikiwa uunganisho umefanikiwa, tunapaswa kupokea ujumbe sawa na huu.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)Lugha kuu ya kukuza mifano ya ML ni Python. Na jukwaa maarufu zaidi la matumizi yake kwenye Linux ni .
Hebu tusakinishe kwenye seva yetu.
Tunaanza kwa kusasisha msimamizi wa kifurushi cha ndani:
sudo apt-get updateSakinisha curl (matumizi ya mstari wa amri):
sudo apt-get install curlPakua toleo jipya zaidi la Usambazaji wa Anaconda:
cd /tmp
curl βO https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shWacha tuanze usakinishaji:
bash Anaconda3-2019.10-Linux-x86_64.shWakati wa mchakato wa usakinishaji, utaulizwa kuthibitisha makubaliano ya leseni. Baada ya usakinishaji uliofanikiwa unapaswa kuona hii:
Thank you for installing Anaconda3!Mifumo mingi sasa imeundwa kwa ajili ya ukuzaji wa miundo ya ML; tunafanya kazi na maarufu zaidi: ΠΈ .
Kutumia mfumo hukuruhusu kuongeza kasi ya ukuzaji na kutumia zana zilizotengenezwa tayari kwa kazi za kawaida.
Katika mfano huu tutafanya kazi na PyTorch. Hebu tusakinishe:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchSasa tunahitaji kuzindua Jupyter Notebook, zana maarufu ya ukuzaji kwa wataalamu wa ML. Inakuwezesha kuandika msimbo na mara moja kuona matokeo ya utekelezaji wake. Daftari ya Jupyter imejumuishwa na Anaconda na tayari imesakinishwa kwenye seva yetu. Unahitaji kuunganishwa nayo kutoka kwa mfumo wetu wa eneo-kazi.
Ili kufanya hivyo, kwanza tutazindua Jupyter kwenye seva inayobainisha bandari 8080:
jupyter notebook --no-browser --port=8080 --allow-rootIfuatayo, tukifungua kichupo kingine kwenye kiweko chetu cha Cmder (menyu ya juu - mazungumzo ya kiweko kipya) tutaunganisha kupitia bandari 8080 kwa seva kupitia SSH:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameTunapoingiza amri ya kwanza, tutapewa viungo vya kufungua Jupyter kwenye kivinjari chetu:
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
Wacha tutumie kiunga cha localhost:8080. Nakili njia kamili na ubandike kwenye upau wa anwani wa kivinjari cha ndani cha Kompyuta yako. Daftari la Jupyter litafunguliwa.
Wacha tuunde daftari mpya: Mpya - Daftari - Python 3.
Hebu tuangalie uendeshaji sahihi wa vipengele vyote ambavyo tumeweka. Wacha tuingize mfano wa nambari ya PyTorch kwenye Jupyter na tuendesha utekelezaji (kitufe cha Run):
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
Matokeo yake inapaswa kuwa kitu kama hiki:
Ikiwa una matokeo sawa, basi tumesanidi kila kitu kwa usahihi na tunaweza kuanza kuendeleza mtandao wa neural!
Kuunda mtandao wa neva
Tutaunda mtandao wa neva kwa utambuzi wa picha. Wacha tuchukue hii kama msingi .
Tutatumia seti ya data ya CIFAR10 inayopatikana kwa umma ili kutoa mafunzo kwa mtandao. Ina madarasa: "ndege", "gari", "ndege", "paka", "kulungu", "mbwa", "chura", "farasi", "meli", "lori". Picha katika CIFAR10 ni 3x32x32, yaani, picha za rangi ya vituo 3 vya pikseli 32x32.
Kwa kazi, tutatumia kifurushi kilichoundwa na PyTorch kwa kufanya kazi na picha - torchvision.
Tutafanya hatua zifuatazo kwa utaratibu:
- Inapakia na kurekebisha seti za data za majaribio
- Ufafanuzi wa Mtandao wa Neural
- Mafunzo ya mtandao juu ya data ya mafunzo
- Jaribio la mtandao kwenye data ya jaribio
- Hebu turudie mafunzo na majaribio kwa kutumia GPU
Tutakuwa tukitekeleza nambari zote hapa chini kwenye Jupyter Notebook.
Inapakia na kuhalalisha CIFAR10
Nakili na uendeshe nambari ifuatayo katika 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')Jibu linapaswa kuwa:
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 verifiedWacha tuonyeshe picha kadhaa za mafunzo kwa majaribio:
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)))
Ufafanuzi wa Mtandao wa Neural
Hebu kwanza tuchunguze jinsi mtandao wa neva wa utambuzi wa picha unavyofanya kazi. Huu ni mtandao rahisi wa kumweka-kwa-uhakika. Inachukua data ya pembejeo, huipitisha kupitia tabaka kadhaa moja baada ya nyingine, na hatimaye hutoa data ya pato.
Wacha tuunde mtandao sawa katika mazingira yetu:
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()
Pia tunafafanua kitendakazi cha upotezaji na kiboreshaji
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)Mafunzo ya mtandao juu ya data ya mafunzo
Wacha tuanze kufundisha mtandao wetu wa neva. Tafadhali kumbuka kuwa baada ya kutekeleza msimbo huu, utahitaji kusubiri kwa muda hadi kazi ikamilike. Ilinichukua dakika 5. Inachukua muda kufundisha mtandao.
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')
Tunapata matokeo yafuatayo:
Tunahifadhi mfano wetu uliofunzwa:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)Jaribio la mtandao kwenye data ya jaribio
Tulifunza mtandao kwa kutumia seti ya data ya mafunzo. Lakini tunahitaji kuangalia ikiwa mtandao umejifunza chochote.
Tutajaribu hili kwa kutabiri lebo ya darasa ambayo mtandao wa neural hutoa na kuipima ili kuona ikiwa ni kweli. Ikiwa utabiri ni sahihi, tunaongeza sampuli kwenye orodha ya utabiri sahihi.
Wacha tuonyeshe picha kutoka kwa seti ya jaribio:
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)))
Sasa hebu tuulize mtandao wa neva utuambie ni nini kwenye picha hizi:
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)))
Matokeo yanaonekana kuwa mazuri: mtandao ulitambua kwa usahihi picha tatu kati ya nne.
Hebu tuone jinsi mtandao unavyofanya kazi kwenye mkusanyiko mzima wa data.
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))
Inaonekana mtandao unajua kitu na unafanya kazi. Ikiwa angeamua madarasa bila mpangilio, usahihi ungekuwa 10%.
Sasa hebu tuone ni madarasa gani mtandao unatambua bora:
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]))
Inaonekana kwamba mtandao ni bora katika kutambua magari na meli: usahihi wa 71%.
Kwa hivyo mtandao unafanya kazi. Sasa hebu jaribu kuhamisha kazi yake kwa processor ya graphics (GPU) na tuone mabadiliko gani.
Kufunza mtandao wa neva kwenye GPU
Kwanza, nitaeleza kwa ufupi CUDA ni nini. CUDA (Usanifu wa Kifaa cha Kukokotoa Kilichounganishwa) ni jukwaa la kompyuta sambamba lililoundwa na NVIDIA kwa ajili ya kompyuta ya jumla kwenye vitengo vya usindikaji wa michoro (GPUs). Kwa CUDA, wasanidi programu wanaweza kuharakisha programu za kompyuta kwa kutumia nguvu za GPU. Mfumo huu tayari umesakinishwa kwenye seva yetu tuliyonunua.
Hebu kwanza tufafanue GPU yetu kama kifaa cha kwanza kinachoonekana cha cuda.
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 )
Kutuma mtandao kwa GPU:
net.to(device)Pia itatubidi kutuma pembejeo na shabaha kwa kila hatua kwa GPU:
inputs, labels = data[0].to(device), data[1].to(device)Wacha tufunze tena mtandao kwenye 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')Wakati huu, mafunzo ya mtandao yalichukua kama dakika 3. Hebu tukumbuke kwamba hatua sawa kwenye processor ya kawaida ilidumu dakika 5. Tofauti sio kubwa, hii hutokea kwa sababu mtandao wetu sio mkubwa sana. Unapotumia safu kubwa za mafunzo, tofauti kati ya kasi ya GPU na kichakataji cha jadi itaongezeka.
Hiyo inaonekana kuwa yote. Tulichoweza kufanya:
- Tuliangalia GPU ni nini na tukachagua seva ambayo imewekwa;
- Tumeweka mazingira ya programu ili kuunda mtandao wa neva;
- Tulitengeneza mtandao wa neva kwa utambuzi wa picha na tukaufunza;
- Tulirudia mafunzo ya mtandao kwa kutumia GPU na tukapokea ongezeko la kasi.
Nitafurahi kujibu maswali katika maoni.
Chanzo: mapenzi.com