Вашата прва невронска мрежа на единица за графичка обработка (GPU). Водич за почетници

Во оваа статија, ќе ви кажам како да поставите средина за машинско учење за 30 минути, да креирате невронска мрежа за препознавање слики и потоа да ја стартувате истата мрежа на графички процесор (GPU).

Прво, да дефинираме што е невронска мрежа.

Во нашиот случај, ова е математички модел, како и негово софтверско или хардверско отелотворување, изградено врз принципот на организација и функционирање на биолошките невронски мрежи - мрежи на нервни клетки на жив организам. Овој концепт се појави додека ги проучуваше процесите што се случуваат во мозокот и се обидуваше да ги моделира овие процеси.

Невронските мрежи не се програмирани во вообичаената смисла на зборот, тие се обучени. Способноста за учење е една од главните предности на невронските мрежи во однос на традиционалните алгоритми. Технички, учењето се состои од пронаоѓање на коефициентите на врски помеѓу невроните. За време на процесот на обука, невронската мрежа може да идентификува сложени зависности помеѓу влезните и излезните податоци, како и да изврши генерализација.

Од гледна точка на машинското учење, невронската мрежа е посебен случај на методи за препознавање шаблони, дискриминантна анализа, методи на кластерирање и други методи.

Оборудование

Прво, да ја разгледаме опремата. Потребен ни е сервер со инсталиран оперативен систем Linux на него. Опремата потребна за управување со системите за машинско учење е прилично моќна и, како резултат на тоа, скапа. За оние кои немаат добра машина при рака, препорачувам да обрнат внимание на понудите на давателите на облак. Можете брзо да го изнајмите бараниот сервер и да плаќате само за времето на користење.

Во проекти каде што е неопходно да се создадат невронски мрежи, ги користам серверите на еден од руските провајдери на облак. Компанијата нуди облак сервери за изнајмување специјално за машинско учење со моќни Tesla V100 графички процесори (GPU) од NVIDIA. Накратко: користењето сервер со графички процесор може да биде десетици пати поефикасно (брзо) во споредба со сервер со слична цена што користи процесор (добро позната централна процесорска единица) за пресметки. Ова се постигнува поради карактеристиките на архитектурата на графичкиот процесор, која побрзо се справува со пресметките.

За да ги имплементираме примерите опишани подолу, го купивме следниов сервер неколку дена:

• SSD диск 150 GB
• RAM меморија 32 GB
• Tesla V100 16 Gb процесор со 4 јадра

Го инсталиравме Ubuntu 18.04 на нашата машина.

Поставување на околината

Сега ајде да инсталираме сè што е потребно за работа на серверот. Бидејќи нашата статија е првенствено за почетници, ќе зборувам за некои точки што ќе им бидат корисни.

Голем дел од работата при поставувањето на околината се врши преку командната линија. Повеќето од корисниците користат Windows како работен оперативен систем. Стандардната конзола во овој ОС остава многу да се посакува. Затоа, ќе користиме пригодна алатка Cmder/. Преземете ја мини верзијата и стартувајте Cmder.exe. Следно, треба да се поврзете со серверот преку SSH:

ssh root@server-ip-or-hostname

Наместо име на сервер-ip-или-домаќин, наведете ја IP адресата или името на DNS на вашиот сервер. Следно, внесете ја лозинката и ако врската е успешна, треба да добиеме слична порака на оваа.

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

Главниот јазик за развој на ML модели е Python. И најпопуларната платформа за нејзина употреба на Linux е анаконда.

Ајде да го инсталираме на нашиот сервер.

Започнуваме со ажурирање на локалниот менаџер на пакети:

sudo apt-get update

Инсталирајте curl (услужна алатка за командна линија):

sudo apt-get install curl

Преземете ја најновата верзија на Anaconda Distribution:

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

Да ја започнеме инсталацијата:

bash Anaconda3-2019.10-Linux-x86_64.sh

За време на процесот на инсталација, ќе биде побарано да го потврдите договорот за лиценца. По успешна инсталација, треба да го видите ова:

Thank you for installing Anaconda3!

Сега се создадени многу рамки за развој на ML модели со кои работиме најпопуларните: PyTorch и Проток на тензор.

Користењето на рамката ви овозможува да ја зголемите брзината на развој и да користите готови алатки за стандардни задачи.

Во овој пример ќе работиме со PyTorch. Ајде да го инсталираме:

conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

Сега треба да го лансираме Jupyter Notebook, популарна алатка за развој за специјалисти за ML. Ви овозможува да напишете код и веднаш да ги видите резултатите од неговото извршување. Jupyter Notebook е вклучен во Anaconda и е веќе инсталиран на нашиот сервер. Треба да се поврзете со него од нашиот десктоп систем.

За да го направите ова, прво ќе го стартуваме Jupyter на серверот што ја одредува портата 8080:

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

Следно, отворајќи друго јазиче во нашата Cmder конзола (горното мени - Дијалог за нова конзола) ќе се поврземе преку портата 8080 со серверот преку SSH:

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

Кога ќе ја внесеме првата команда, ќе ни бидат понудени врски за отворање на Jupyter во нашиот прелистувач:

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

Ајде да ја искористиме врската за localhost:8080. Копирајте ја целосната патека и залепете ја во лентата за адреси на локалниот прелистувач на вашиот компјутер. Ќе се отвори Jupyter Notebook.

Ајде да создадеме нова тетратка: Ново - Бележник - Пајтон 3.

Ајде да ја провериме правилната работа на сите компоненти што ги инсталиравме. Ајде да го внесеме примерот PyTorch код во Jupyter и да го извршиме извршувањето (копче Run):

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

Резултатот треба да биде нешто вака:

Ако имате сличен резултат, тогаш конфигуриравме сè правилно и можеме да започнеме да развиваме невронска мрежа!

Создавање невронска мрежа

Ќе создадеме невронска мрежа за препознавање слики. Да го земеме ова како основа лидерство.

За да ја обучиме мрежата, ќе ја користиме јавно достапната база на податоци CIFAR10. Има класи: „авион“, „автомобил“, „птица“, „мачка“, „елен“, „куче“, „жаба“, „коњ“, „брод“, „камион“. Сликите во CIFAR10 се 3x32x32, односно 3-канални слики во боја од 32x32 пиксели.

За работа, ќе го користиме пакетот создаден од PyTorch за работа со слики - torchvision.

Ќе ги направиме следните чекори по редослед:

• Вчитување и нормализирање на збирките на податоци за обука и тестирање
• Дефиниција на невронска мрежа
• Мрежна обука за податоци за обука
• Мрежно тестирање на податоците од тестот
• Ајде да повториме обука и тестирање користејќи графички процесор

Ќе го извршиме целиот код подолу во Jupyter Notebook.

Вчитување и нормализирање на CIFAR10

Копирајте го и стартувајте го следниов код во 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')

Одговорот треба да биде:

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

Ајде да прикажеме неколку слики за обука за тестирање:

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

Дефиниција на невронска мрежа

Ајде прво да размислиме како функционира невронската мрежа за препознавање слики. Ова е едноставна мрежа од точка до точка. Ги зема влезните податоци, ги поминува низ неколку слоеви еден по еден, а потоа конечно произведува излезни податоци.

Ајде да создадеме слична мрежа во нашата околина:

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

Ние, исто така, дефинираме функција за загуба и оптимизатор

import torch.optim as optim

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

Мрежна обука за податоци за обука

Да почнеме да ја тренираме нашата невронска мрежа. Ве молиме имајте предвид дека откако ќе ја извршите оваа шифра, ќе треба да почекате некое време додека не се заврши работата. Ми требаа 5 минути. Потребно е време да се обучи мрежата.

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

Го добиваме следниот резултат:

Го зачувуваме нашиот обучен модел:

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

Мрежно тестирање на податоците од тестот

Ја обучивме мрежата користејќи збир на податоци за обука. Но, треба да провериме дали мрежата воопшто научила нешто.

Ќе го тестираме ова со предвидување на ознаката на класата што ја дава невронската мрежа и ќе ја тестираме за да видиме дали е вистина. Ако предвидувањето е точно, го додаваме примерокот на списокот со точни предвидувања.
Ајде да прикажеме слика од тест сет:

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

Сега да побараме од невронската мрежа да ни каже што е на овие слики:

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

Резултатите изгледаат прилично добри: мрежата правилно идентификуваше три од четири слики.

Ајде да видиме како функционира мрежата низ целата база на податоци.

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

Изгледа дека мрежата знае нешто и работи. Доколку ги одреди класите по случаен избор, точноста би била 10%.

Сега да видиме кои класи мрежата ги идентификува подобро:

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

Се чини дека мрежата е најдобра во идентификување на автомобили и бродови: 71% точност.

Значи, мрежата работи. Сега да се обидеме да ја пренесеме неговата работа на графичкиот процесор (GPU) и да видиме што се менува.

Обука на невронска мрежа на графичкиот процесор

Прво накратко ќе објаснам што е CUDA. CUDA (Compute Unified Device Architecture) е паралелна компјутерска платформа развиена од NVIDIA за општо пресметување на графички процесорски единици (GPU). Со CUDA, програмерите можат драматично да ги забрзаат компјутерските апликации со искористување на моќта на графичките процесори. Оваа платформа е веќе инсталирана на нашиот сервер што го купивме.

Ајде прво да го дефинираме нашиот графички процесор како првиот видлив 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 )

Испраќање на мрежата до графичкиот процесор:

net.to(device)

Исто така, ќе мора да испраќаме влезови и цели на секој чекор до графичкиот процесор:

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

Ајде повторно да ја обучиме мрежата на графичкиот процесор:

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

Овој пат мрежниот тренинг траеше околу 3 минути. Да потсетиме дека истата фаза на конвенционален процесор траеше 5 минути. Разликата не е значајна, ова се случува затоа што нашата мрежа не е толку голема. Кога користите големи низи за обука, разликата помеѓу брзината на графичкиот процесор и традиционалниот процесор ќе се зголеми.

Се чини дека тоа е сè. Што успеавме да направиме:

• Разгледавме што е графичкиот процесор и го избравме серверот на кој е инсталиран;
• Поставивме софтверско опкружување за создавање невронска мрежа;
• Создадовме невронска мрежа за препознавање слики и ја обучивме;
• Ја повторивме мрежната обука користејќи графички процесор и добивме зголемување на брзината.

Со задоволство ќе одговорам на прашања во коментарите.

Извор: www.habr.com