🥇Ang imong una nga neural network sa usa ka graphics processor (GPU). Giya sa Magsugod

Niini nga artikulo, isulti ko kanimo kung giunsa ang pag-set up sa usa ka palibot sa pagkat-on sa makina sa 30 minuto, paghimo usa ka neural network alang sa pag-ila sa imahe, ug dayon pagdagan ang parehas nga network sa usa ka graphics processor (GPU).

Una, atong ipasabut kung unsa ang neural network.

Sa among kaso, kini usa ka modelo sa matematika, ingon man ang software o hardware nga embodiment niini, nga gitukod sa prinsipyo sa organisasyon ug paglihok sa mga biological neural network - mga network sa mga selula sa nerbiyos sa usa ka buhi nga organismo. Kini nga konsepto mitungha samtang nagtuon sa mga proseso nga nahitabo sa utok ug naningkamot sa pagmodelo niini nga mga proseso.

Ang mga neural network wala giprograma sa naandan nga kahulugan sa pulong, kini gibansay. Ang abilidad sa pagkat-on mao ang usa sa mga nag-unang bentaha sa mga neural network sa tradisyonal nga mga algorithm. Sa teknikal, ang pagkat-on naglangkob sa pagpangita sa mga coefficient sa mga koneksyon tali sa mga neuron. Atol sa proseso sa pagbansay, ang neural network makahimo sa pag-ila sa mga komplikadong dependency tali sa input data ug output data, ingon man sa paghimo sa generalization.

Gikan sa punto sa pagtan-aw sa pagkat-on sa makina, ang usa ka neural network usa ka espesyal nga kaso sa mga pamaagi sa pag-ila sa pattern, pagtuki sa diskriminasyon, mga pamaagi sa clustering ug uban pang mga pamaagi.

Kagamitan

Una, atong tan-awon ang mga ekipo. Nagkinahanglan kami og server nga adunay Linux operating system nga na-install niini. Ang mga ekipo nga gikinahanglan sa pag-operate sa mga sistema sa pagkat-on sa makina kusog kaayo ug, isip resulta, mahal. Alang sa mga wala’y maayong makina nga magamit, girekomenda nako nga hatagan pagtagad ang mga tanyag sa mga taghatag sa panganod. Mahimo ka mag-abang sa gikinahanglan nga server sa madali ug magbayad lamang sa panahon sa paggamit.

Sa mga proyekto diin gikinahanglan ang paghimo og mga neural network, akong gigamit ang mga server sa usa sa mga Russian cloud providers. Nagtanyag ang kompanya og mga cloud server alang sa pag-abang ilabi na alang sa pagkat-on sa makina nga adunay gamhanan nga Tesla V100 graphics processors (GPU) gikan sa NVIDIA. Sa laktud nga pagkasulti: ang paggamit sa usa ka server nga adunay usa ka GPU mahimong napulo ka beses nga labi ka episyente (paspas) kung itandi sa usa ka server nga parehas nga gasto nga naggamit usa ka CPU (ang ilado nga sentral nga yunit sa pagproseso) alang sa mga kalkulasyon. Nakab-ot kini tungod sa mga bahin sa arkitektura sa GPU, nga mas paspas nga makasagubang sa mga kalkulasyon.

Aron ipatuman ang mga pananglitan nga gihulagway sa ubos, gipalit namo ang mosunod nga server sulod sa pipila ka adlaw:

SSD disk 150 GB
RAM 32 GB
Tesla V100 16 Gb nga processor nga adunay 4 ka core

Gi-install namon ang Ubuntu 18.04 sa among makina.

Pagpahimutang sa palibot

Karon atong i-install ang tanan nga gikinahanglan alang sa pagtrabaho sa server. Tungod kay ang among artikulo sa panguna alang sa mga nagsugod, maghisgot ako bahin sa pipila ka mga punto nga mapuslanon alang kanila.

Daghang trabaho kung ang pag-set up sa usa ka palibot gihimo pinaagi sa command line. Kadaghanan sa mga tiggamit naggamit sa Windows ingon ilang nagtrabaho nga OS. Ang standard console niini nga OS nagbilin ug daghan nga gitinguha. Busa, mogamit kami usa ka kombenyente nga himan Cmder/. I-download ang mini nga bersyon ug padagana ang Cmder.exe. Sunod kinahanglan nimo nga makonektar sa server pinaagi sa SSH:

ssh root@server-ip-or-hostname

Imbis sa server-ip-or-hostname, ipiho ang IP address o DNS nga ngalan sa imong server. Sunod, isulod ang password ug kung malampuson ang koneksyon, kinahanglan nga makadawat kami usa ka mensahe nga parehas niini.

Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)

Ang nag-unang pinulongan alang sa pagpalambo sa mga modelo sa ML mao ang Python. Ug ang labing popular nga plataporma alang sa paggamit niini sa Linux mao ang Anaconda.

Ato kining i-install sa atong server.

Nagsugod kami pinaagi sa pag-update sa lokal nga manager sa package:

sudo apt-get update

I-install ang curl (command line utility):

sudo apt-get install curl

I-download ang pinakabag-o nga bersyon sa Anaconda Distribution:

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

Atong sugdan ang pag-instalar:

bash Anaconda3-2019.10-Linux-x86_64.sh

Atol sa proseso sa pag-instalar, hangyoon ka nga kumpirmahon ang kasabutan sa lisensya. Sa malampuson nga pag-instalar kinahanglan nimo nga makita kini:

Thank you for installing Anaconda3!

Daghang mga balangkas ang nahimo na karon alang sa pagpauswag sa mga modelo sa ML; nagtrabaho kami sa labing inila: PyTorch и dagan sa tensor.

Ang paggamit sa balangkas nagtugot kanimo nga madugangan ang katulin sa pag-uswag ug gamiton ang andam nga mga himan alang sa mga sumbanan nga buluhaton.

Niini nga pananglitan magtrabaho kami sa PyTorch. Atong i-install kini:

conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

Karon kinahanglan namong ilunsad ang Jupyter Notebook, usa ka sikat nga himan sa pagpalambo alang sa mga espesyalista sa ML. Gitugotan ka niini nga isulat ang code ug makita dayon ang mga sangputanan sa pagpatuman niini. Ang Jupyter Notebook gilakip sa Anaconda ug na-install na sa among server. Kinahanglan ka nga magkonektar niini gikan sa among desktop system.

Aron mahimo kini, una namong ilunsad ang Jupyter sa server nga nagtino sa port 8080:

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

Sunod, pag-abli sa laing tab sa among Cmder console (top menu - Bag-ong console dialog) kami magkonektar pinaagi sa port 8080 ngadto sa server pinaagi sa SSH:

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

Kung mosulod kami sa una nga mando, hatagan kami mga link aron maablihan ang Jupyter sa among browser:

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

Atong gamiton ang link para sa localhost:8080. Kopyaha ang tibuok nga agianan ug idikit kini sa address bar sa lokal nga browser sa imong PC. Ang Jupyter Notebook maablihan.

Magbuhat ta ug bag-ong notebook: Bag-o - Notebook - Python 3.

Atong susihon ang husto nga operasyon sa tanan nga mga sangkap nga among gi-install. Atong isulod ang pananglitan nga PyTorch code sa Jupyter ug ipadagan ang execution (Run button):

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

Ang resulta kinahanglan nga ingon niini:

Kung adunay ka parehas nga resulta, nan among gi-configure ang tanan sa husto ug mahimo namong magsugod sa paghimo og neural network!

Paghimo usa ka neural network

Maghimo kami usa ka neural network alang sa pag-ila sa imahe. Ato kining himoon nga basehan giya.

Among gamiton ang publikong magamit nga CIFAR10 dataset aron mabansay ang network. Kini adunay mga klase: "eroplano", "sakyanan", "langgam", "iring", "usa", "iro", "baki", "kabayo", "barko", "trak". Ang mga hulagway sa CIFAR10 kay 3x32x32, sa ato pa, 3-channel nga kolor nga mga hulagway sa 32x32 pixels.

Alang sa trabaho, gamiton namon ang pakete nga gihimo sa PyTorch alang sa pagtrabaho sa mga imahe - torchvision.

Atong buhaton ang mosunod nga mga lakang sa pagkahan-ay:

Pag-load ug pag-normalize sa mga set sa datos sa pagbansay ug pagsulay
Kahulugan sa Neural Network
Pagbansay sa network sa datos sa pagbansay
Pagsulay sa network sa datos sa pagsulay
Atong sublion ang pagbansay ug pagsulay gamit ang GPU

Ipatuman namo ang tanang code sa ubos sa Jupyter Notebook.

Pag-load ug pag-normalize sa CIFAR10

Kopyaha ug padagana ang mosunod nga code sa 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')

Ang tubag kinahanglan nga:

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 verified

Atong ipakita ang daghang mga imahe sa pagbansay alang sa pagsulay:


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

Kahulugan sa Neural Network

Atong hisgotan una kung giunsa ang usa ka neural network alang sa pag-ila sa imahe nagtrabaho. Kini usa ka yano nga point-to-point nga network. Nagkinahanglan kini og input data, gipasa kini sa daghang mga layer sa usag usa, ug sa katapusan nagpatunghag output data.

Maghimo kita og susama nga network sa atong palibot:


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

Gihubit usab namo ang usa ka function sa pagkawala ug usa ka optimizer


import torch.optim as optim

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

Pagbansay sa network sa datos sa pagbansay

Magsugod ta sa pagbansay sa atong neural network. Palihug timan-i nga human nimo ipadagan kini nga kodigo, kinahanglang maghulat ka ug pipila ka panahon hangtod mahuman ang trabaho. Niabot kog 5 minutes. Nagkinahanglan kini og panahon sa pagbansay sa network.

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

Atong makuha ang mosunod nga resulta:

Gitipigan namo ang among gibansay nga modelo:

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

Pagsulay sa network sa datos sa pagsulay

Gibansay namo ang network gamit ang set sa training data. Apan kinahanglan natong susihon kung ang network ba nakakat-on sa bisan unsa.

Atong sulayan kini pinaagi sa pagtagna sa label sa klase nga ang neural network output ug pagsulay niini aron makita kung kini tinuod. Kung husto ang panagna, among idugang ang sample sa lista sa husto nga panagna.
Atong ipakita ang usa ka imahe gikan sa set sa pagsulay:

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

Karon atong pangutan-on ang neural network sa pagsulti kanato kon unsa ang anaa niini nga mga hulagway:


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

Ang mga resulta ingon og maayo kaayo: ang network husto nga nagpaila sa tulo sa upat ka mga litrato.

Atong tan-awon kung giunsa ang paglihok sa network sa tibuuk nga dataset.


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

Morag ang network adunay nahibal-an ug nagtrabaho. Kung gipili niya ang mga klase sa random, ang katukma mahimong 10%.

Karon atong tan-awon kung unsang mga klase ang mas maayo nga giila sa network:

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

Morag ang network mao ang labing maayo sa pag-ila sa mga sakyanan ug mga barko: 71% nga katukma.

Busa ang network nagtrabaho. Karon atong sulayan nga ibalhin ang trabaho niini sa graphics processor (GPU) ug tan-awon kung unsa ang mga pagbag-o.

Pagbansay sa usa ka neural network sa GPU

Una, akong ipasabot sa daklit unsa ang CUDA. Ang CUDA (Compute Unified Device Architecture) usa ka parallel computing platform nga gimugna sa NVIDIA para sa general computing sa graphics processing units (GPUs). Uban sa CUDA, ang mga developer mahimo nga makapadali sa mga aplikasyon sa kompyuter pinaagi sa paggamit sa gahum sa mga GPU. Kini nga plataporma na-install na sa among server nga among gipalit.

Atong una nga ipasabut ang atong GPU isip ang unang makita nga cuda device.

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 )

Pagpadala sa network ngadto sa GPU:

net.to(device)

Kinahanglan usab namon nga magpadala mga input ug target sa matag lakang sa GPU:

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

Atong bansayon pag-usab ang network sa 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')

Niining higayona, ang pagbansay sa network milungtad mga 3 minuto. Atong hinumdoman nga ang parehas nga yugto sa usa ka naandan nga processor milungtad og 5 minuto. Ang kalainan dili mahinungdanon, kini mahitabo tungod kay ang among network dili kaayo dako. Kung gigamit ang daghang mga arrays alang sa pagbansay, ang kalainan tali sa katulin sa GPU ug usa ka tradisyonal nga processor modako.

Morag mao na ang tanan. Unsa ang among nahimo:

Gitan-aw namon kung unsa ang usa ka GPU ug gipili ang server diin kini gi-install;
Nag-set up kami og software environment aron makahimo og neural network;
Naghimo kami usa ka neural network alang sa pag-ila sa imahe ug gibansay kini;
Gisubli namo ang pagbansay sa network gamit ang GPU ug nakadawat og pagtaas sa katulin.

Malipay ko sa pagtubag sa mga pangutana sa mga komento.

Source: www.habr.com

Ang imong unang neural network sa usa ka graphics processing unit (GPU). Giya sa Magsugod