Jaringan saraf munggaran anjeun dina unit pangolahan grafik (GPU). Guide pemula urang

Dina tulisan ieu, kuring bakal nyarioskeun ka anjeun kumaha nyetél lingkungan diajar mesin dina menit 30, nyiptakeun jaringan saraf pikeun pangakuan gambar, teras ngajalankeun jaringan anu sami dina prosesor grafik (GPU).

Kahiji, hayu urang ngartikeun naon jaringan saraf.

Dina hal urang, ieu téh modél matematik, kitu ogé software atawa hardware perwujudan na, diwangun dina prinsip organisasi jeung fungsi jaringan saraf biologis - jaringan sél saraf organisme hirup. Konsep ieu timbul nalika ngulik prosés anu lumangsung dina uteuk sareng nyobian modél prosés ieu.

Jaringan saraf teu diprogram dina rasa biasa kecap, aranjeunna dilatih. Kamampuh diajar mangrupikeun salah sahiji kaunggulan utama jaringan saraf tibatan algoritma tradisional. Téhnisna, diajar diwangun ku milarian koefisien sambungan antara neuron. Salila prosés latihan, jaringan saraf tiasa ngaidentipikasi katergantungan kompléks antara data input sareng data kaluaran, ogé ngalaksanakeun generalisasi.

Tina sudut pandang pembelajaran mesin, jaringan saraf mangrupikeun kasus khusus metode pangakuan pola, analisa diskriminan, metode clustering sareng metode anu sanés.

pakakas

Kahiji, hayu urang nempo alat. Urang peryogi server sareng sistem operasi Linux anu dipasang dina éta. Alat-alat anu dibutuhkeun pikeun ngoperasikeun sistem pembelajaran mesin cukup kuat sareng, akibatna, mahal. Pikeun anu henteu gaduh mesin anu saé, kuring nyarankeun merhatikeun tawaran panyadia awan. Anjeun tiasa nyéwa server anu diperyogikeun gancang sareng mayar ngan ukur kanggo waktos dianggo.

Dina proyék dimana perlu nyieun jaringan neural, abdi nganggo server salah sahiji panyadia awan Rusia. Pausahaan nawiskeun server awan pikeun nyéwa khusus pikeun diajar mesin kalayan prosesor grafik Tesla V100 (GPU) anu kuat ti NVIDIA. Pondokna: ngagunakeun server kalawan GPU a tiasa puluhan kali leuwih efisien (gancang) dibandingkeun jeung server ongkos sarupa anu ngagunakeun CPU a (Unit processing sentral well-dipikawanoh) pikeun itungan. Ieu kahontal alatan fitur arsitéktur GPU, nu copes jeung itungan leuwih gancang.

Pikeun nerapkeun conto anu dijelaskeun di handap, kami ngagaleuh server di handap ieu sababaraha dinten:

• SSD disk 150 GB
• RAM 32 GB
• Tesla V100 16 prosesor Gb kalawan 4 cores

Kami masang Ubuntu 18.04 dina mesin kami.

Nyetél lingkungan

Ayeuna hayu urang pasang sadayana anu dipikabutuh pikeun damel di server. Kusabab artikel kami utamana pikeun beginners, abdi bakal ngobrol ngeunaan sababaraha titik anu bakal mangpaat pikeun aranjeunna.

Seueur padamelan nalika nyetél lingkungan dilakukeun ngalangkungan garis paréntah. Kalolobaan pamaké ngagunakeun Windows salaku OS maranéhanana. Konsol standar dina OS ieu seueur anu dipikahoyong. Ku alatan éta, urang bakal ngagunakeun alat merenah Cmder/. Unduh versi mini sareng jalankeun Cmder.exe. Salajengna anjeun kedah nyambung ka server via SSH:

ssh root@server-ip-or-hostname

Gantina server-ip-atawa-hostname, tangtukeun alamat IP atawa ngaran DNS server Anjeun. Salajengna, lebetkeun kecap akses sareng upami sambunganna suksés, urang kedah nampi pesen anu sami sareng ieu.

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

Basa utama pikeun ngembangkeun modél ML nyaéta Python. Sareng platform anu paling populér pikeun dianggo dina Linux nyaéta anaconda.

Hayu urang pasang dina server kami.

Urang mimitian ku ngamutahirkeun manajer pakét lokal:

sudo apt-get update

Pasang curl (utilitas baris paréntah):

sudo apt-get install curl

Unduh versi panganyarna tina Anaconda Distribution:

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

Hayu urang ngamimitian pamasangan:

bash Anaconda3-2019.10-Linux-x86_64.sh

Salila prosés pamasangan, anjeun bakal dipenta pikeun ngonfirmasi perjanjian lisénsi. Saatos instalasi suksés anjeun kedah ningali ieu:

Thank you for installing Anaconda3!

Loba kerangka ayeuna geus dijieun pikeun ngembangkeun model ML kami gawé bareng nu pang populerna: PyTorch и Aliran tensor.

Ngagunakeun kerangka ngidinan Anjeun pikeun ngaronjatkeun laju ngembangkeun sarta ngagunakeun parabot siap-dijieun pikeun tugas baku.

Dina conto ieu kami bakal dianggo sareng PyTorch. Hayu urang pasang:

conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

Ayeuna urang kedah ngaluncurkeun Jupyter Notebook, alat pangembangan populér pikeun spesialis ML. Éta ngamungkinkeun anjeun nyerat kode sareng langsung ningali hasil palaksanaanna. Jupyter Notebook kalebet sareng Anaconda sareng parantos dipasang dina server kami. Anjeun kedah nyambungkeun éta tina sistem desktop urang.

Jang ngalampahkeun ieu, urang mimiti ngajalankeun Jupyter dina server nangtukeun port 8080:

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

Teras, muka tab sanés dina konsol Cmder kami (menu luhur - dialog konsol énggal) kami bakal nyambung via port 8080 ka server via SSH:

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

Nalika kami asupkeun paréntah anu munggaran, kami bakal ditawarkeun tautan pikeun muka Jupyter dina panyungsi kami:

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

Hayu urang nganggo tautan pikeun localhost:8080. Salin jalur lengkep sareng tempelkeun kana bar alamat browser lokal PC anjeun. Jupyter Notebook bakal dibuka.

Hayu urang nyieun notebook anyar: Anyar - Notebook - Python 3.

Hayu urang parios operasi anu leres tina sadaya komponén anu kami pasang. Hayu urang lebetkeun conto kode PyTorch kana Jupyter sareng ngajalankeun palaksanaan (tombol Run):

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

Hasilna kedah sapertos kieu:

Upami anjeun gaduh hasil anu sami, maka kami parantos ngonpigurasi sadayana leres sareng urang tiasa ngamimitian ngembangkeun jaringan saraf!

Nyiptakeun jaringan saraf

Urang bakal nyieun jaringan neural pikeun pangakuan gambar. Hayu urang nyandak ieu salaku dadasar kapamimpinan.

Urang bakal ngagunakeun dataset CIFAR10 sadia masarakat awam pikeun ngalatih jaringan. Aya kelas: "pesawat", "mobil", "manuk", "ucing", "kijang", "anjing", "bangkong", "kuda", "kapal", "treuk". Gambar dina CIFAR10 nyaéta 3x32x32, nyaéta, gambar warna 3-kanal 32x32 piksel.

Pikeun digawé, urang bakal ngagunakeun pakét dijieun ku PyTorch pikeun gawé bareng gambar - torchvision.

Urang bakal ngalakukeun léngkah-léngkah ieu dina urutan:

• Ngamuat sareng normalisasi set data latihan sareng uji
• Definisi Neural Network
• Pelatihan jaringan dina data pelatihan
• Tés jaringan dina data tés
• Hayu urang ngulang latihan jeung nguji maké GPU

Urang bakal ngaéksekusi sadaya kode di handap ieu dina Jupyter Notebook.

Ngamuat sareng normalisasi CIFAR10

Salin sareng jalankeun kodeu ieu dina 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')

Jawabanana kedah kieu:

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

Hayu urang mintonkeun sababaraha gambar latihan pikeun nguji:

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

Definisi Neural Network

Hayu urang tingali heula kumaha jaringan neural pikeun pangakuan gambar jalan. Ieu jaringan titik-ka-titik basajan. Butuh data input, ngaliwatan sababaraha lapisan hiji-hiji, lajeng tungtungna ngahasilkeun data kaluaran.

Hayu urang ngadamel jaringan anu sami di lingkungan urang:

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

Urang ogé nangtukeun hiji fungsi leungitna sarta optimizer

import torch.optim as optim

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

Pelatihan jaringan dina data pelatihan

Hayu urang mimitian ngalatih jaringan saraf urang. Punten perhatikeun yén saatos anjeun ngajalankeun kode ieu, anjeun kedah ngantosan sababaraha waktos dugi ka réngsé. Butuh waktu kuring 5 menit. Butuh waktu pikeun ngalatih jaringan.

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

Kami nampi hasil di handap ieu:

Urang nyimpen model dilatih urang:

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

Tés jaringan dina data tés

Kami ngalatih jaringan nganggo sakumpulan data latihan. Tapi urang kedah parios naha jaringan parantos diajar nanaon.

Kami bakal nguji ieu ku ngaramalkeun labél kelas anu kaluaran jaringan saraf sareng nguji éta pikeun ningali naha éta leres. Upami ramalanna leres, urang tambahkeun conto kana daptar prediksi anu leres.
Hayu urang nunjukkeun gambar tina set tés:

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

Ayeuna hayu urang naroskeun ka jaringan saraf pikeun nyarioskeun naon anu aya dina gambar ieu:

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

Hasilna sigana lumayan saé: jaringan leres ngaidentipikasi tilu tina opat gambar.

Hayu urang tingali kumaha kinerja jaringan dina sakabéh set data.

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

Sigana jaringan terang hiji hal sareng berpungsi. Upami anjeunna nangtukeun kelas sacara acak, akurasina bakal 10%.

Ayeuna hayu urang tingali kelas mana anu diidentifikasi ku jaringan anu langkung saé:

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

Sigana yén jaringan anu pangalusna pikeun ngaidentipikasi mobil jeung kapal: 71% akurasi.

Jadi jaringan jalan. Ayeuna hayu urang coba nransper karyana ka processor grafik (GPU) tur tingal parobahan naon.

Ngalatih jaringan saraf dina GPU

Kahiji, kuring bakal ngajelaskeun sakeudeung naon CUDA. CUDA (Compute Unified Device Architecture) nyaéta platform komputasi paralel anu dikembangkeun ku NVIDIA pikeun komputasi umum dina unit pangolahan grafik (GPU). Kalayan CUDA, pamekar tiasa nyirorot ngagancangkeun aplikasi komputasi ku ngamangpaatkeun kakuatan GPU. Platform ieu parantos dipasang dina server kami anu kami mésér.

Hayu urang ngartikeun GPU urang salaku alat cuda munggaran anu katingali.

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 )

Ngirim jaringan ka GPU:

net.to(device)

Urang ogé kedah ngirim input sareng target dina unggal léngkah ka GPU:

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

Hayu urang ngalatih deui jaringan dina 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')

Waktos ieu, palatihan jaringan lumangsung sakitar 3 menit. Hayu urang ngelingan yén tahap sarua dina processor konvensional lumangsung 5 menit. Bédana teu signifikan, ieu kajadian sabab jaringan urang teu jadi badag. Lamun ngagunakeun arrays badag pikeun latihan, bédana antara speed GPU sarta processor tradisional bakal ningkat.

Éta sigana sadayana. Naon anu urang tiasa laksanakeun:

• Kami ningali naon GPU sareng milih server dimana éta dipasang;
• Kami parantos nyetél lingkungan parangkat lunak pikeun nyiptakeun jaringan saraf;
• Kami nyiptakeun jaringan saraf pikeun pangakuan gambar sareng ngalatih éta;
• Kami ngulang latihan jaringan nganggo GPU sareng nampi kanaékan kagancangan.

Kuring bakal senang ngajawab patarosan dina komentar.

sumber: www.habr.com