თქვენი პირველი ნერვული ქსელი გრაფიკული დამუშავების ერთეულზე (GPU). დამწყებთათვის გზამკვლევი

ამ სტატიაში მე გეტყვით, თუ როგორ უნდა დააყენოთ მანქანათმცოდნეობის გარემო 30 წუთში, შექმნათ ნერვული ქსელი გამოსახულების ამოცნობისთვის და შემდეგ იგივე ქსელის გაშვება გრაფიკულ პროცესორზე (GPU).

პირველ რიგში, მოდით განვსაზღვროთ რა არის ნერვული ქსელი.

ჩვენს შემთხვევაში, ეს არის მათემატიკური მოდელი, ისევე როგორც მისი პროგრამული თუ აპარატურის განსახიერება, რომელიც აგებულია ბიოლოგიური ნერვული ქსელების ორგანიზებისა და ფუნქციონირების პრინციპზე - ცოცხალი ორგანიზმის ნერვული უჯრედების ქსელები. ეს კონცეფცია წარმოიშვა ტვინში მიმდინარე პროცესების შესწავლისას და ამ პროცესების მოდელირების მცდელობისას.

ნერვული ქსელები არ არის დაპროგრამებული ამ სიტყვის ჩვეულებრივი გაგებით, ისინი ვარჯიშობენ. სწავლის უნარი ნერვული ქსელების ერთ-ერთი მთავარი უპირატესობაა ტრადიციულ ალგორითმებთან შედარებით. ტექნიკურად, სწავლა შედგება ნეირონებს შორის კავშირების კოეფიციენტების პოვნაში. ტრენინგის პროცესში ნერვულ ქსელს შეუძლია ამოიცნოს რთული დამოკიდებულებები შეყვანის და გამომავალი მონაცემების შორის, ასევე განახორციელოს განზოგადება.

მანქანური სწავლის თვალსაზრისით, ნერვული ქსელი არის ნიმუშის ამოცნობის მეთოდების, დისკრიმინაციული ანალიზის, კლასტერული მეთოდებისა და სხვა მეთოდების განსაკუთრებული შემთხვევა.

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

პირველ რიგში, მოდით შევხედოთ აღჭურვილობას. ჩვენ გვჭირდება სერვერი მასზე დაყენებული Linux ოპერაციული სისტემით. მანქანათმცოდნეობის სისტემების მუშაობისთვის საჭირო აღჭურვილობა საკმაოდ მძლავრი და, შედეგად, ძვირია. მათთვის, ვისაც ხელთ არ აქვს კარგი მანქანა, გირჩევთ ყურადღება მიაქციოთ ღრუბლოვანი პროვაიდერების შეთავაზებებს. თქვენ შეგიძლიათ დაიქირავოთ საჭირო სერვერი სწრაფად და გადაიხადოთ მხოლოდ გამოყენების დრო.

პროექტებში, სადაც აუცილებელია ნერვული ქსელების შექმნა, მე ვიყენებ ერთ-ერთი რუსული ღრუბლოვანი პროვაიდერის სერვერებს. კომპანია გთავაზობთ ქირავდება ღრუბლოვან სერვერებს სპეციალურად მანქანათმცოდნეობისთვის ძლიერი Tesla V100 გრაფიკული პროცესორებით (GPU) NVIDIA-სგან. მოკლედ: სერვერის გამოყენება GPU-ით შეიძლება იყოს ათჯერ უფრო ეფექტური (სწრაფი) ანალოგიური ღირებულების სერვერთან შედარებით, რომელიც იყენებს CPU-ს (ცნობილ ცენტრალურ დამუშავების ერთეულს) გამოთვლებისთვის. ეს მიიღწევა GPU არქიტექტურის მახასიათებლების გამო, რომელიც უფრო სწრაფად უმკლავდება გამოთვლებს.

ქვემოთ აღწერილი მაგალითების განსახორციელებლად, ჩვენ შევიძინეთ შემდეგი სერვერი რამდენიმე დღის განმავლობაში:

• SSD დისკი 150 GB
• ოპერატიული მეხსიერება 32 GB
• Tesla V100 16 გბ პროცესორი 4 ბირთვით

ჩვენ დავაყენეთ Ubuntu 18.04 ჩვენს აპარატზე.

გარემოს დაყენება

ახლა მოდით დავაინსტალიროთ ყველაფერი, რაც საჭიროა სერვერზე მუშაობისთვის. ვინაიდან ჩვენი სტატია ძირითადად დამწყებთათვისაა, მე ვისაუბრებ რამდენიმე პუნქტზე, რომელიც მათთვის სასარგებლო იქნება.

გარემოს დაყენებისას ბევრი სამუშაო კეთდება ბრძანების ხაზის მეშვეობით. მომხმარებელთა უმეტესობა იყენებს Windows-ს, როგორც სამუშაო OS. სტანდარტული კონსოლი ამ OS-ში სასურველს ტოვებს. ამიტომ, ჩვენ გამოვიყენებთ მოსახერხებელ ხელსაწყოს 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-ზე მისი გამოყენების ყველაზე პოპულარული პლატფორმაა anaconda.

მოდით დააინსტალიროთ ის ჩვენს სერვერზე.

ჩვენ ვიწყებთ ადგილობრივი პაკეტის მენეჯერის განახლებით:

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-თან. მოდით დააინსტალიროთ:

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 გაიხსნება.

მოდით შევქმნათ ახალი რვეული: New - Notebook - Python 3.

მოდით შევამოწმოთ ყველა იმ კომპონენტის სწორი მოქმედება, რომელიც ჩვენ დავაინსტალირეთ. მოდით შევიტანოთ PyTorch კოდის მაგალითი Jupyter-ში და გავუშვათ შესრულება (გაშვების ღილაკი):

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

შედეგი უნდა იყოს დაახლოებით ასეთი:

თუ თქვენ გაქვთ მსგავსი შედეგი, მაშინ ჩვენ ყველაფერი სწორად დავაკონფიგურირეთ და შეგვიძლია დავიწყოთ ნერვული ქსელის განვითარება!

ნერვული ქსელის შექმნა

ჩვენ შევქმნით ნერვულ ქსელს გამოსახულების ამოცნობისთვის. ავიღოთ ეს საფუძვლად ხელმძღვანელობა.

ჩვენ გამოვიყენებთ საჯაროდ ხელმისაწვდომ CIFAR10 მონაცემთა ბაზას ქსელის მოსამზადებლად. მას აქვს კლასები: "თვითმფრინავი", "მანქანა", "ჩიტი", "კატა", "ირემი", "ძაღლი", "ბაყაყი", "ცხენი", "გემი", "სატვირთო მანქანა". CIFAR10-ში სურათები არის 3x32x32, ანუ 3-არხიანი ფერადი სურათები 32x32 პიქსელით.

სამუშაოდ გამოვიყენებთ PyTorch-ის მიერ შექმნილ პაკეტს სურათებთან მუშაობისთვის - ჩირაღდნის ხედვა.

ჩვენ გავაკეთებთ შემდეგ ნაბიჯებს თანმიმდევრობით:

• ტრენინგის და ტესტირების მონაცემთა ნაკრების ჩატვირთვა და ნორმალიზება
• ნერვული ქსელის განმარტება
• ქსელური ტრენინგი ტრენინგის მონაცემებზე
• ქსელის ტესტირება ტესტის მონაცემებზე
• გავიმეოროთ ტრენინგი და ტესტირება GPU-ს გამოყენებით

ჩვენ შევასრულებთ ქვემოთ მოცემულ ყველა კოდს 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) გადავიტანოთ და ვნახოთ რა შეიცვლება.

ნერვული ქსელის სწავლება GPU-ზე

პირველ რიგში, მოკლედ აგიხსნით რა არის CUDA. CUDA (Compute Unified Device Architecture) არის პარალელური გამოთვლითი პლატფორმა, რომელიც შემუშავებულია NVIDIA-ს მიერ გრაფიკული დამუშავების ერთეულებზე (GPU) ზოგადი გამოთვლებისთვის. CUDA-ს საშუალებით დეველოპერებს შეუძლიათ მკვეთრად დააჩქარონ გამოთვლითი აპლიკაციები GPU-ების სიმძლავრის გამოყენებით. ეს პლატფორმა უკვე დაინსტალირებულია ჩვენს მიერ შეძენილ სერვერზე.

მოდით ჯერ განვსაზღვროთ ჩვენი GPU, როგორც პირველი ხილული 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 )

ქსელის გაგზავნა GPU-ზე:

net.to(device)

ჩვენ ასევე მოგვიწევს შეყვანის და მიზნების გაგზავნა თითოეულ საფეხურზე GPU-ზე:

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

მოდით ხელახლა ვავარჯიშოთ ქსელი 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')

ამჯერად ქსელური ტრენინგი დაახლოებით 3 წუთი გაგრძელდა. შეგახსენებთ, რომ ჩვეულებრივი პროცესორზე იგივე ეტაპი 5 წუთს გაგრძელდა. განსხვავება არ არის მნიშვნელოვანი, ეს იმიტომ ხდება, რომ ჩვენი ქსელი არც თუ ისე დიდია. ვარჯიშისთვის დიდი მასივების გამოყენებისას გაიზრდება სხვაობა GPU-სა და ტრადიციულ პროცესორს შორის.

როგორც ჩანს, ეს ყველაფერია. რაც ჩვენ მოვახერხეთ:

• ჩვენ შევხედეთ რა არის GPU და შევარჩიეთ სერვერი, რომელზეც ის არის დაინსტალირებული;
• ჩვენ შევქმენით პროგრამული გარემო ნერვული ქსელის შესაქმნელად;
• ჩვენ შევქმენით სურათის ამოცნობის ნერვული ქსელი და ვავარჯიშეთ იგი;
• ჩვენ გავიმეორეთ ქსელის ტრენინგი GPU-ს გამოყენებით და მივიღეთ სიჩქარის ზრდა.

სიამოვნებით ვუპასუხებ კითხვებს კომენტარებში.

წყარო: www.habr.com