In hoc articulo, tibi dicam quomodo machinam discendi ambitum in 30 minutis constituere, reticulum neurale ad recognitionem imaginis creandum, et eadem retia curre in processu graphicae unitatis (GPU).
Primum quid sit network neural definiamus.
In nobis, hoc exemplar est mathematicum, ac eius programmatio vel ferramentum in corpore, in principio organizationis et operandi reticulorum biologicorum neuralis, reticulorum nervi cellularum organismi viventis. Haec conceptio orta est dum processus in cerebro occurrentes studet et has processus effingere conatur.
Retia neuralis in usu vocabuli sensu programmata non exercentur. Facultas discendi una est e praecipuis retis neuralis commodis in algorithms traditis. Doctrina technice est invenire coefficientes nexus inter neuronos. Per processum exercitationis retis neuralis potest cognoscere implicatas clientelas inter input datas et output datas, ac generalitatem praestare.
Ex parte machinae discendi, network neural est casus specialis rationum agnitionis exemplaris, analysi discriminantis, methodi condensae et aliorum methodorum.
apparatibus
Primum inspiciamus apparatum. Servitore opus est cum systemate operante Linux in eo inaugurato. Apparatus ad machinam discendi operandam requiritur satis potens et, per consequens, sumptuosus. Pro his qui non habent bonam machinam in promptu habent, commendamus operam praebentibus nubis provisoribus. Cito servo debitum scindere potes et tantum temporis usus reddere.
In inceptis ubi necesse est retiacula neuralis creare, servitoribus uti provisoribus nubis Russiae cuiusdam. Societas nubeculas ministrantibus praebet pro redditu specialiter ad apparatus discendi cum potentissimis processoribus graphicis Tesla V100 (GPU) ex NVIDIA. In summa: utens servo cum GPU potest decies plus temporis efficiens (celeriter) comparari servo simili sumptus qui utitur CPU (nota centralis processus unitas) pro calculis. Hoc fit propter architecturae GPU lineamenta, quae cum calculis citius tolerat.
Ad exempla infra descripta peragenda, sequenti servo per aliquot dies emimus;
- SSD orbis 150 GB
- RAM 32 GB
- Tesla V100 16 Gb processus cum 4 coros
18.04 Ubuntu in machina nostra constituimus.
Erexerit amet
Nunc instituamus omnia quae ad operandum in calculo necessaria sunt. Cum articulus noster sit principaliter pro incipientibus, de aliquibus punctis, quae eis usui erunt, loquar.
Multum opus est, ubi ambitus instituens fit per lineam rectam. Plerique usores Fenestra utentes operando OS. Vexillum consolatorium in hoc OS relinquit multum desiderandum. Ideo utemur instrumento opportuno . Download mini versionem et currunt Cmder.exe. Deinde debes servo coniungere cum via SSH:
ssh root@server-ip-or-hostnameInstead of server-ip-or-hostname, specificare IP address or DNS name of your server. Deinde tesseram intrant et si nexus succedit, nuntium huic simile accipiamus.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)Praecipua lingua ad exempla ML explicanda est Python. Et maxime popularis suggestum ad usum suum in Linux est .
Let's install it in our server.
Incipimus adaequationis loci sarcina procurator:
sudo apt-get updateCrispum inaugurare (mandatum lineae utilitatis);
sudo apt-get install curlDownload recentissimam versionem Anaconda Distribution:
cd /tmp
curl βO https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shIncipit institutionem:
bash Anaconda3-2019.10-Linux-x86_64.shPer processum institutionem rogaberis ad consensum licentiae confirmandae. In secunda institutione hoc debes videre:
Thank you for installing Anaconda3!Multae compages nunc ad ML exemplorum evolutionem creatae sunt, cum maxime popularibus laboramus; ΠΈ .
In compage permittit ut celeritas evolutionis augeatur et instrumenta praeparata instrumenta ad operas vexillum utantur.
In hoc exemplo elaborabimus apud PyTorch. Let's install it:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchNunc opus est Iupyter Comentarium mittere, instrumentum evolutionis popularis pro ML specialibus. Liceat tibi codicem scribere et statim eventus executionis videre. Iuppiter codicillus cum Anaconda includitur et in servo nostro iam inauguratus est. Opus ex escritorio nostro ad illud coniungere debes.
Ad hoc faciendum, primum Iupytrem in calculonis servi speciei portus 8080 mittemus;
jupyter notebook --no-browser --port=8080 --allow-rootDeinde aliam tab aperientes in nostro Cmder console (mensus top - Novus dialogus consolatorium) per portum 8080 coniungemus cum servo per SSH:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameCum primum mandatum intramus, nexus offeremur ut Iuppiter in navigatro nostro aperiatur:
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
Utamur nexum pro localhost: 8080. Effingo plenam viam et conglutinatam in vecte electronicae navigatoris localis tui PC. Iuppiter codicillus aperiet.
Novo libello faciamus: Novus - codicillus - Python III.
Reprehendamus rectam operationem omnium partium quae instituimus. Exemplum PyTorch signum in Iuppiter ingrediamur et exsecutio currite (Bulla currite);
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
Eveniet ut aliquid ut est.
Si simile exitum habes, tunc omnia recte conformavimus et retis neuralis enucleare possumus!
Creando neural network
Reticulum neurale imaginis recognitionis dabimus. Sit hoc est basis .
In promptu publice CIFAR10 dataset utemur ad ornatum retis. Classes habet: "avis", "currus", "avis", "cattus", "cervus", "canes", "rana", "equus", "navis", "carsella". Imagines in CIFAR10 sunt 3x32x32, id est, 3-alvei coloris imagines 32x32 imaginum.
Ad opus, sarcina a PyTorch creata ad operandum cum imaginibus - taedis adhibebimus.
Sequentes gradus faciemus per ordinem:
- Loading et normalizing disciplina et experimentum notitia occidere
- Neural Network Definition
- Network disciplina in disciplina notitia
- Network probatio test notitia
- Sit scriptor repetere disciplinam et probare usura GPU
Codicem totum infra in codicillo Jupyteri exequemur.
Loading et normalizing CIFAR10
Effingo quod sequenti codice currunt in Iuppiter:
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')Respondeatur:
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 verifiedPlures imagines ad probationem instituendam proponamus:
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)))
Neural Network Definition
Prius videamus quomodo retis neurals ad recognitionem imaginis operatur. Hoc punctum simplex est-ad punctum ornatum. Data input accipit, per plures ordines singulatim transit, et demum data output producit.
Similem retem creemus in ambitu nostro:
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()
Definimus etiam munus damnum et optimizer
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)Network disciplina in disciplina notitia
Initium nostrum neural retis exerceat. Nota quaeso quod postquam hunc codicem curris, exspectare aliquod tempus debes donec opus perficiatur. Me cepit V minuta. Tempus suscipit ipsum elit.
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')
Sequenti eventum obtinemus:
Serva nos institutum nostrum exemplar:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)Network probatio test notitia
Instituti sumus retiacula in notitia certa disciplinae usus. Sed inspiciendum est num retis aliquid omnino didicerit.
Hoc probabimus, indicando label classium retiacula exitu neural, experiendo videre an verum sit. Si vera est praedictio, specimen adimus in indice rectarum praedictionum.
Ostendamus imaginem e testi statuto:
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)))
Nunc retia neuralis quaeramus ut nobis dicas quid in his imaginibus est:
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)))
Eventus satis bonus videntur: retiacula recte tria ex quattuor imaginibus identificata.
Videamus quomodo reticulum per totam dataset exerceat.
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))
Is vultus sicut retis aliquid cognoscit et laborat. Si classes temere definiret, accuratio esset 10%.
Nunc videamus quae genera retis melius agnoscat;
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]))
Reticulum videtur optimum esse ad identidem carros et naves: 71% accurate.
Sic reticulum laborat. Nunc studeamus suum opus ad processorem graphicae (GPU) transferre et quae mutationes vide.
Disciplina neural network in GPU
Primum quid CUDA sit breviter exponam. CUDA (Architectura Fabrica Compute Unificata) parallela computandi suggestum ab NVIDIA evoluta est pro computatione universali in unitatibus graphicis processui (GPUs). Cum CUDA, tincidunt computationem applicationes dramatice accelerare possunt potentiam GPUs levando. Hoc suggestum iam inauguratus est nostro servo quem emimus.
Primum definiamus nostrum GPU ut primum cuda visibilis fabrica.
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 )
Mittens ad network in GPU:
net.to(device)Volumus etiam ut inputationes et scuta mittere singulis gradibus ad GPU:
inputs, labels = data[0].to(device), data[1].to(device)Lets re-retiacula in GPU instituendi:
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')Hoc tempore, disciplina retiacula circiter 3 minuta duravit. Meminimus eundem gradum in processu conventionali 5 minuta duravisse. Differentia non est significativa, quia network nostrum non est ita magna. Cum magnis vestimentis ad exercitationem adhibitis, differentia celeritatis GPU et processus traditionalis augebitur.
Quod omnibus videtur. Quod nos facere potuimus;
- Inspeximus quid sit GPU et delegit server in quo instituitur;
- programmatum programmatum instituimus ut reticulum neurale creet;
- Reticulum neurale ad imaginem imaginis nos creavimus et eam exercuimus;
- Repetimus retis exercitationem GPU utentem et celeritatis incrementum accepimus.
Laetus ero in commentaria ad interrogata respondere.
Source: www.habr.com