ग्राफिक्स प्रशोधन इकाई (GPU) मा तपाईंको पहिलो तंत्रिका नेटवर्क। शुरुआती गाइड

यस लेखमा, म तपाईंलाई 30 मिनेटमा मेसिन लर्निङ वातावरण कसरी सेटअप गर्ने, छवि पहिचानको लागि न्यूरल नेटवर्क सिर्जना गर्ने, र त्यसपछि ग्राफिक्स प्रोसेसर (GPU) मा उही नेटवर्क चलाउने भनेर बताउनेछु।

पहिले, एक तंत्रिका नेटवर्क के हो परिभाषित गरौं।

हाम्रो मामला मा, यो एक गणितीय मोडेल, साथै यसको सफ्टवेयर वा हार्डवेयर अवतार, संगठन र जैविक तंत्रिका नेटवर्क को कार्य को सिद्धान्त मा निर्मित - एक जीवित जीव को तंत्रिका कोशिका को नेटवर्क। यो अवधारणा मस्तिष्कमा हुने प्रक्रियाहरूको अध्ययन गर्दा र यी प्रक्रियाहरूलाई मोडेल गर्ने प्रयास गर्दा उत्पन्न भयो।

तंत्रिका नेटवर्कहरू शब्दको सामान्य अर्थमा प्रोग्राम गरिएको छैन, तिनीहरू प्रशिक्षित छन्। सिक्ने क्षमता परम्परागत एल्गोरिदमहरू भन्दा न्यूरल नेटवर्कहरूको मुख्य फाइदाहरू मध्ये एक हो। प्राविधिक रूपमा, सिकाइले न्यूरोन्सहरू बीचको जडानहरूको गुणांकहरू फेला पार्नु समावेश गर्दछ। प्रशिक्षण प्रक्रियाको बखत, तंत्रिका नेटवर्कले इनपुट डाटा र आउटपुट डाटा बीच जटिल निर्भरताहरू पहिचान गर्न सक्षम छ, साथै सामान्यीकरण प्रदर्शन गर्दछ।

मेसिन लर्निङको दृष्टिकोणबाट, न्यूरल नेटवर्क ढाँचा पहिचान विधिहरू, भेदभाव विश्लेषण, क्लस्टरिङ विधिहरू र अन्य विधिहरूको एक विशेष मामला हो।

उपकरण

पहिले, उपकरण हेरौं। हामीलाई यसमा स्थापित लिनक्स अपरेटिङ सिस्टम भएको सर्भर चाहिन्छ। मेसिन लर्निङ सिस्टम सञ्चालन गर्न आवश्यक उपकरणहरू धेरै शक्तिशाली छन् र परिणाम स्वरूप, महँगो छ। जोसँग हातमा राम्रो मेसिन छैन, म क्लाउड प्रदायकहरूको प्रस्तावहरूमा ध्यान दिन सिफारिस गर्दछु। तपाईले आवश्यक सर्भर चाँडै भाडामा लिन सक्नुहुन्छ र प्रयोगको समयको लागि मात्र भुक्तान गर्न सक्नुहुन्छ।

परियोजनाहरूमा जहाँ यो तंत्रिका नेटवर्कहरू सिर्जना गर्न आवश्यक छ, म रूसी क्लाउड प्रदायकहरू मध्ये एकको सर्भरहरू प्रयोग गर्दछु। कम्पनीले NVIDIA बाट शक्तिशाली Tesla V100 ग्राफिक्स प्रोसेसर (GPU) को साथ मेसिन लर्निङको लागि विशेष गरी भाडामा क्लाउड सर्भरहरू प्रदान गर्दछ। छोटकरीमा: GPU को साथ सर्भर प्रयोग गर्दा गणनाको लागि CPU (प्रसिद्ध केन्द्रीय प्रशोधन इकाई) प्रयोग गर्ने समान लागतको सर्भरको तुलनामा दशौं गुणा बढी कुशल (छिटो) हुन सक्छ। यो GPU आर्किटेक्चर को विशेषताहरु को कारण हासिल भएको छ, जो छिटो गणना संग सामना गर्दछ।

तल वर्णन गरिएका उदाहरणहरू कार्यान्वयन गर्न, हामीले धेरै दिनको लागि निम्न सर्भर खरिद गर्यौं:

• SSD डिस्क 150 GB
• र्याम 32 जीबी
• टेस्ला V100 16 जीबी प्रोसेसर 4 कोर संग

हामीले हाम्रो मेसिनमा Ubuntu 18.04 स्थापना गर्यौं।

वातावरण स्थापना गर्दै

अब सर्भरमा कामको लागि आवश्यक सबै स्थापना गरौं। हाम्रो लेख मुख्यतया शुरुवातकर्ताहरूको लागि भएकोले, म केही बिन्दुहरूको बारेमा कुरा गर्नेछु जुन उनीहरूलाई उपयोगी हुनेछ।

वातावरण सेटअप गर्दा धेरै काम कमाण्ड लाइन मार्फत गरिन्छ। धेरै जसो प्रयोगकर्ताहरूले विन्डोजलाई उनीहरूको काम गर्ने ओएसको रूपमा प्रयोग गर्छन्। यस OS मा मानक कन्सोलले चाहिने धेरै छोड्छ। त्यसैले, हामी एक सुविधाजनक उपकरण प्रयोग गर्नेछौं Cmder/। मिनी संस्करण डाउनलोड गर्नुहोस् र Cmder.exe चलाउनुहोस्। अर्को तपाईंले SSH मार्फत सर्भरमा जडान गर्न आवश्यक छ:

ssh root@server-ip-or-hostname

सर्भर-आईपी-वा-होस्टनामको सट्टा, तपाईंको सर्भरको IP ठेगाना वा DNS नाम निर्दिष्ट गर्नुहोस्। अर्को, पासवर्ड प्रविष्ट गर्नुहोस् र यदि जडान सफल छ भने, हामीले यस्तै सन्देश प्राप्त गर्नुपर्छ।

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

एमएल मोडेलहरू विकास गर्ने मुख्य भाषा पाइथन हो। र लिनक्समा यसको प्रयोगको लागि सबैभन्दा लोकप्रिय प्लेटफर्म हो Anaconda.

यसलाई हाम्रो सर्भरमा स्थापना गरौं।

हामी स्थानीय प्याकेज प्रबन्धक अपडेट गरेर सुरु गर्छौं:

sudo apt-get update

कर्ल स्थापना गर्नुहोस् (कमांड लाइन उपयोगिता):

sudo apt-get install curl

Anaconda वितरण को नवीनतम संस्करण डाउनलोड गर्नुहोस्:

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!

धेरै ढाँचाहरू अब एमएल मोडेलहरूको विकासको लागि सिर्जना गरिएको छ; हामी सबैभन्दा लोकप्रियसँग काम गर्छौं: पाइटोरच и टेन्सरफ्लो.

ढाँचाको प्रयोगले तपाईंलाई विकासको गति बढाउन र मानक कार्यहरूको लागि तयार उपकरणहरू प्रयोग गर्न अनुमति दिन्छ।

यस उदाहरणमा हामी PyTorch सँग काम गर्नेछौं। यसलाई स्थापना गरौं:

conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

अब हामीले Jupyter Notebook, ML विशेषज्ञहरूको लागि लोकप्रिय विकास उपकरण सुरू गर्न आवश्यक छ। यसले तपाईंलाई कोड लेख्न र तुरुन्तै यसको कार्यान्वयनको नतिजाहरू हेर्न अनुमति दिन्छ। Jupyter Notebook Anaconda सँग समावेश गरिएको छ र पहिले नै हाम्रो सर्भरमा स्थापित छ। तपाईंले हाम्रो डेस्कटप प्रणालीबाट यसलाई जडान गर्न आवश्यक छ।

यो गर्नको लागि, हामी पहिले पोर्ट 8080 निर्दिष्ट गर्ने सर्भरमा Jupyter सुरु गर्नेछौं:

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

लोकलहोस्ट:8080 को लागि लिङ्क प्रयोग गरौं। पूर्ण मार्ग प्रतिलिपि गर्नुहोस् र यसलाई तपाईंको पीसीको स्थानीय ब्राउजरको ठेगाना पट्टीमा टाँस्नुहोस्। Jupyter Notebook खुल्नेछ।

नयाँ नोटबुक सिर्जना गरौं: नयाँ - नोटबुक - पाइथन 3।

हामीले स्थापना गरेका सबै कम्पोनेन्टहरूको सही सञ्चालन जाँच गरौं। Jupyter मा उदाहरण PyTorch कोड प्रविष्ट गरौं र कार्यान्वयन (रन बटन) चलाउनुहोस्:

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

परिणाम यस्तो हुनुपर्छ:

यदि तपाइँसँग समान परिणाम छ भने, हामीले सबै कुरा सही रूपमा कन्फिगर गरेका छौं र हामी एक न्यूरल नेटवर्क विकास गर्न सुरु गर्न सक्छौं!

न्यूरल नेटवर्क सिर्जना गर्दै

हामी छवि पहिचानको लागि एक तंत्रिका नेटवर्क सिर्जना गर्नेछौं। यसलाई आधारको रूपमा लिऔं गाईड.

हामी नेटवर्कलाई तालिम दिन सार्वजनिक रूपमा उपलब्ध CIFAR10 डाटासेट प्रयोग गर्नेछौं। यसमा वर्गहरू छन्: "हवाई जहाज", "कार", "चरा", "बिरालो", "मृग", "कुकुर", "भ्यागुता", "घोडा", "जहाज", "ट्रक"। CIFAR10 मा छविहरू 3x32x32 छन्, अर्थात्, 3x32 पिक्सेलको 32-च्यानल रङ छविहरू।

कामको लागि, हामी PyTorch द्वारा बनाईएको प्याकेज छविहरूसँग काम गर्न प्रयोग गर्नेछौं - torchvision।

हामी निम्न चरणहरू क्रमबद्ध गर्नेछौं:

• प्रशिक्षण र परीक्षण डेटा सेट लोड र सामान्यीकरण
• तंत्रिका नेटवर्क परिभाषा
• प्रशिक्षण डेटा मा नेटवर्क प्रशिक्षण
• परीक्षण डाटा मा नेटवर्क परीक्षण
• 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)

प्रशिक्षण डेटा मा नेटवर्क प्रशिक्षण

हाम्रो न्यूरल नेटवर्कलाई प्रशिक्षण सुरु गरौं। कृपया ध्यान दिनुहोस् कि तपाईंले यो कोड चलाएपछि, तपाईंले काम पूरा नभएसम्म केही समय पर्खनु पर्नेछ। मलाई ५ मिनेट लाग्यो। नेटवर्कलाई तालिम दिन समय लाग्छ।

 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 (कम्प्युट युनिफाइड डिभाइस आर्किटेक्चर) एक समानान्तर कम्प्युटिङ प्लेटफर्म हो जुन NVIDIA ले ग्राफिक्स प्रोसेसिङ इकाइहरू (GPUs) मा सामान्य कम्प्युटिङको लागि विकसित गरेको हो। 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