San artaigil seo, innsidh mi dhut mar a stèidhicheas tu àrainneachd ionnsachaidh inneal ann an 30 mionaidean, cruthaich lìonra neural airson aithneachadh ìomhaigh, agus an uairsin ruith an aon lìonra air pròiseasar grafaigs (GPU).
An toiseach, mìnichidh sinn dè a th’ ann an lìonra neural.
Anns a 'chùis againn, is e modail matamataigeach a tha seo, a bharrachd air a bhith a' toirt a-steach bathar-bog no bathar-cruaidh, air a thogail air a 'phrionnsapal de eagrachadh agus obrachadh lìonraidhean neural bith-eòlasach - lìonraidhean de cheallan neònach de dh'fhàs-bheairt beò. Dh'èirich am bun-bheachd seo fhad 'sa bha e a' sgrùdadh nam pròiseasan a tha a 'tachairt san eanchainn agus a' feuchainn ris na pròiseasan sin a mhodail.
Chan eil lìonraidhean neural air am prògramadh ann an dòigh àbhaisteach an fhacail, tha iad air an trèanadh. Is e an comas ionnsachadh aon de na prìomh bhuannachdan a tha aig lìonraidhean neural thairis air algorithms traidiseanta. Gu teicnigeach, tha ionnsachadh a’ toirt a-steach a bhith a’ lorg co-èifeachdan cheanglaichean eadar neurons. Tron phròiseas trèanaidh, bidh an lìonra neural comasach air eisimeileachd iom-fhillte a chomharrachadh eadar dàta cuir a-steach agus dàta toraidh, a bharrachd air coitcheannachadh a dhèanamh.
Bho thaobh ionnsachadh innealan, tha lìonra neural na chùis shònraichte de dhòighean aithneachadh pàtrain, mion-sgrùdadh leth-bhreith, dòighean cruinneachadh agus dòighean eile.
Uidheam
An toiseach, leigamaid sùil air an uidheamachd. Feumaidh sinn frithealaiche leis an t-siostam-obrachaidh Linux air a chuir air. Tha an uidheamachd a tha a dhìth airson siostaman ionnsachaidh innealan obrachadh gu math cumhachdach agus, mar thoradh air sin, daor. Dhaibhsan aig nach eil inneal math ri làimh, tha mi a 'moladh aire a thoirt do thairgsean solaraichean sgòthan. Faodaidh tu an frithealaiche riatanach fhaighinn air màl gu sgiobalta agus pàigheadh dìreach airson an ùine cleachdaidh.
Ann am pròiseactan far a bheil feum air lìonraidhean neural a chruthachadh, bidh mi a’ cleachdadh frithealaichean aon de na solaraichean sgòthan Ruiseanach. Bidh a’ chompanaidh a’ tabhann frithealaichean sgòthan air màl gu sònraichte airson ionnsachadh innealan le pròiseasairean grafaigeach cumhachdach Tesla V100 (GPU) bho NVIDIA. Ann an ùine ghoirid: faodaidh cleachdadh frithealaiche le GPU a bhith deichean de thursan nas èifeachdaiche (luath) an coimeas ri frithealaiche de chosgais coltach ris a bhios a’ cleachdadh CPU (an aonad giullachd meadhanach ainmeil) airson àireamhachadh. Tha seo air a choileanadh air sgàth feartan an GPU ailtireachd, a bhios a 'dèiligeadh ri àireamhachadh nas luaithe.
Gus na h-eisimpleirean a tha air am mìneachadh gu h-ìosal a chuir an gnìomh, cheannaich sinn an frithealaiche a leanas airson grunn làithean:
- SSD diosc 150 GB
- RAM 32 GB
- Pròiseasar Tesla V100 16 Gb le 4 cores
Chuir sinn Ubuntu 18.04 air an inneal againn.
A 'suidheachadh na h-àrainneachd
A-nis leig leinn a h-uile dad a tha riatanach airson obair air an fhrithealaiche a stàladh. Leis gu bheil an artaigil againn gu sònraichte airson luchd-tòiseachaidh, bruidhnidh mi mu chuid de phuingean a bhios feumail dhaibh.
Bithear a’ dèanamh tòrr den obair nuair a thathar a’ stèidheachadh àrainneachd tron loidhne-àithne. Bidh a’ mhòr-chuid de luchd-cleachdaidh a’ cleachdadh Windows mar an OS obrach aca. Tha an consol àbhaisteach san OS seo a’ fàgail mòran ri bhith air a mhiannachadh. Mar sin, cleachdaidh sinn inneal goireasach . Luchdaich sìos an dreach beag agus ruith Cmder.exe. An uairsin feumaidh tu ceangal ris an fhrithealaiche tro SSH:
ssh root@server-ip-or-hostnameAn àite server-ip-or-hostname, sònraich an seòladh IP no ainm DNS an fhrithealaiche agad. An uairsin cuir a-steach am facal-faire agus ma tha an ceangal soirbheachail, bu chòir dhuinn teachdaireachd coltach ri seo fhaighinn.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)Is e Python am prìomh chànan airson modalan ML a leasachadh. Agus is e an àrd-ùrlar as mòr-chòrdte airson a chleachdadh air Linux .
Nach stàlaich sinn e air an fhrithealaiche againn.
Tòisichidh sinn le bhith ag ùrachadh a’ mhanaidsear pacaid ionadail:
sudo apt-get updateStàlaich curl (goireas loidhne-àithne):
sudo apt-get install curlLuchdaich a-nuas an tionndadh as ùire de Anaconda. .
cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shFeuch an tòisich sinn air an stàladh:
bash Anaconda3-2019.10-Linux-x86_64.shTron phròiseas stàlaidh, thèid iarraidh ort an aonta ceadachais a dhearbhadh. Às deidh an stàladh soirbheachail bu chòir dhut seo fhaicinn:
Thank you for installing Anaconda3!Tha mòran fhrèaman air an cruthachadh a-nis airson modalan ML a leasachadh; bidh sinn ag obair leis an fheadhainn as mòr-chòrdte: и .
Le bhith a’ cleachdadh an fhrèam leigidh sin leat astar an leasachaidh àrdachadh agus innealan deiseil a chleachdadh airson gnìomhan àbhaisteach.
San eisimpleir seo obraichidh sinn le PyTorch. Nach stàlaich sinn e:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchA-nis feumaidh sinn Jupyter Notebook a chuir air bhog, inneal leasachaidh mòr-chòrdte airson eòlaichean ML. Leigidh e leat còd a sgrìobhadh agus toraidhean a chuir gu bàs fhaicinn sa bhad. Tha Jupyter Notebook air a ghabhail a-steach le Anaconda agus tha e mu thràth air a chuir a-steach air an t-seirbheisiche againn. Feumaidh tu ceangal ris bhon t-siostam deasg againn.
Gus seo a dhèanamh, cuiridh sinn Jupyter air bhog an toiseach air an fhrithealaiche a 'sònrachadh port 8080:
jupyter notebook --no-browser --port=8080 --allow-rootAn ath rud, a’ fosgladh taba eile anns a’ chonsail Cmder againn (clàr àrd - còmhradh tòcan ùr) ceangailidh sinn tro phort 8080 ris an fhrithealaiche tro SSH:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameNuair a thèid sinn a-steach don chiad àithne, thèid ceanglaichean a thabhann dhuinn gus Jupyter fhosgladh sa bhrobhsair againn:
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
Cleachdaidh sinn an ceangal airson localhost: 8080. Dèan lethbhreac den t-slighe slàn agus cuir a-steach e ann am bàr seòlaidh brabhsair ionadail a’ PC agad. Fosglaidh Leabhar-nota Jupyter.
Cruthaichidh sinn leabhar notaichean ùr: Ùr - Leabhar-nota - Python 3.
Feuch an dèan sinn sgrùdadh air obrachadh ceart a h-uile pàirt a chuir sinn a-steach. Nach cuir sinn a-steach an còd PyTorch eisimpleir a-steach do Jupyter agus ruith an cur gu bàs (Putan Ruith):
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
Bu chòir gum biodh an toradh rudeigin mar seo:
Ma tha an aon toradh agad, tha sinn air a h-uile càil a rèiteachadh gu ceart agus is urrainn dhuinn tòiseachadh air lìonra neural a leasachadh!
A’ cruthachadh lìonra neural
Cruthaichidh sinn lìonra neural airson aithneachadh ìomhaighean. Gabhamaid seo mar bhunait .
Cleachdaidh sinn an stòr-dàta CIFAR10 a tha ri fhaotainn gu poblach gus an lìonra a thrèanadh. Tha clasaichean ann: "itealan", "càr", "eun", "cat", "fèidh", "cù", "losgann", "each", "soitheach", "truc". Tha ìomhaighean ann an CIFAR10 3x32x32, is e sin, ìomhaighean dath 3-seanail de 32x32 piogsail.
Airson obair, cleachdaidh sinn am pasgan a chruthaich PyTorch airson obrachadh le ìomhaighean - torchvision.
Nì sinn na ceumannan a leanas ann an òrdugh:
- A’ luchdachadh agus a’ gnàthachadh seataichean dàta trèanaidh is deuchainn
- Mìneachadh Lìonra Neural
- Trèanadh lìonra air dàta trèanaidh
- Lìonra deuchainn air dàta deuchainn
- Nach dèan sinn trèanadh agus deuchainn a-rithist a’ cleachdadh GPU
Bidh sinn a’ cur an gnìomh a’ chòd gu h-ìosal ann an Leabhar-nota Jupyter.
A 'luchdachadh agus a' gnàthachadh CIFAR10
Dèan lethbhreac agus ruith an còd a leanas ann an 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')Bu chòir am freagairt a bhith:
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 verifiedNach seall sinn grunn ìomhaighean trèanaidh airson deuchainn:
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)))
Mìneachadh Lìonra Neural
Beachdaichidh sinn an-toiseach air mar a tha lìonra neural airson aithneachadh ìomhaighean ag obair. Is e lìonra sìmplidh puing-gu-puing a tha seo. Bidh e a’ toirt dàta a-steach, ga thoirt tro ghrunn shreathan aon ri aon, agus an uairsin a’ toirt a-mach dàta toraidh.
Cruthaichidh sinn lìonra coltach ris san àrainneachd againn:
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()
Bidh sinn cuideachd a’ mìneachadh gnìomh call agus optimizer
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)Trèanadh lìonra air dàta trèanaidh
Feuch an tòisich sinn a’ trèanadh ar lìonra neural. Thoir an aire, às deidh dhut an còd seo a ruith, gum feum thu feitheamh beagan ùine gus an tèid an obair a chrìochnachadh. Thug e 5 mionaidean dhomh. Bheir e ùine an lìonra a thrèanadh.
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')
Gheibh sinn an toradh a leanas:
Bidh sinn a’ sàbhaladh ar modal trèanaidh:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)Lìonra deuchainn air dàta deuchainn
Rinn sinn trèanadh air an lìonra a’ cleachdadh seata de dhàta trèanaidh. Ach feumaidh sinn dèanamh cinnteach a bheil an lìonra air dad ionnsachadh idir.
Nì sinn deuchainn air seo le bhith a’ ro-innse bileag a’ chlas a bhios an lìonra neural a’ toirt a-mach agus ga dheuchainn feuch a bheil e fìor. Ma tha an ro-innse ceart, cuiridh sinn an sampall ris an liosta de ro-innse ceart.
Nach seall sinn dealbh bhon t-seata deuchainn:
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)))
A-nis iarramaid air an lìonra neural innse dhuinn dè a tha anns na dealbhan seo:
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)))
Tha coltas gu math math air na toraidhean: chomharraich an lìonra trì a-mach à ceithir dealbhan gu ceart.
Chì sinn mar a tha an lìonra ag obair thairis air an dàta gu lèir.
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))
Tha e coltach gu bheil fios aig an lìonra air rudeigin agus gu bheil e ag obair. Nan co-dhùin e na clasaichean air thuaiream, bhiodh an cruinneas 10%.
A-nis chì sinn dè na clasaichean a tha an lìonra ag aithneachadh nas fheàrr:
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]))
Tha e coltach gu bheil an lìonra nas fheàrr air càraichean is shoithichean a chomharrachadh: cruinneas 71%.
Mar sin tha an lìonra ag obair. A-nis feuchaidh sinn ris an obair aige a ghluasad chun phròiseasar grafaigs (GPU) agus faic dè na h-atharrachaidhean.
Trèanadh lìonra neural air GPU
An toiseach, mìnichidh mi gu h-aithghearr dè a th’ ann an CUDA. Tha CUDA (Ailtireachd Innealan Aonaichte Coimpiutaireachd) na àrd-ùrlar coimpiutaireachd co-shìnte air a leasachadh le NVIDIA airson coimpiutaireachd coitcheann air aonadan giullachd grafaigs (GPUn). Le CUDA, faodaidh luchd-leasachaidh luathachadh mòr a dhèanamh air tagraidhean coimpiutaireachd le bhith a’ faighinn buannachd bho chumhachd GPUs. Tha an àrd-ùrlar seo mu thràth air a chuir a-steach air an t-seirbheisiche againn a cheannaich sinn.
Nach mìnich sinn an GPU againn an-toiseach mar a’ chiad inneal cuda faicsinneach.
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 )
A 'cur an lìonra chun an GPU:
net.to(device)Bidh againn cuideachd ri cuir a-steach agus targaidean a chuir aig gach ceum chun GPU:
inputs, labels = data[0].to(device), data[1].to(device)Leig leinn an lìonra ath-thrèanadh air an 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')An turas seo, mhair an trèanadh lìonra timcheall air 3 mionaidean. Cuimhnich gun do mhair an aon ìre air pròiseasar àbhaisteach 5 mionaidean. Chan eil an diofar cudromach, tha seo a’ tachairt leis nach eil an lìonra againn cho mòr. Nuair a bhios tu a’ cleachdadh arrays mòra airson trèanadh, meudaichidh an eadar-dhealachadh eadar astar an GPU agus pròiseasar traidiseanta.
Tha e coltach gur e sin uile. Na chaidh againn air a dhèanamh:
- Thug sinn sùil air dè a th’ ann an GPU agus thagh sinn am frithealaiche air a bheil e air a chuir a-steach;
- Tha sinn air àrainneachd bathar-bog a stèidheachadh gus lìonra neural a chruthachadh;
- Chruthaich sinn lìonra neural airson aithneachadh ìomhaighean agus rinn sinn trèanadh;
- Rinn sinn a-rithist an trèanadh lìonra a 'cleachdadh an GPU agus fhuair sinn àrdachadh ann an astar.
Bidh mi toilichte ceistean a fhreagairt anns na beachdan.
Source: www.habr.com