🥇ග්‍රැෆික් ප්‍රොසෙසරයක (GPU) ඔබේ පළමු ස්නායු ජාලය. ආරම්භක මාර්ගෝපදේශය

මෙම ලිපියෙන්, මම ඔබට විනාඩි 30 කින් යන්ත්‍ර ඉගෙනීමේ පරිසරයක් සකසා, රූප හඳුනාගැනීම සඳහා ස්නායුක ජාලයක් සාදා, පසුව එම ජාලයම ග්‍රැෆික් ප්‍රොසෙසරයක (GPU) ධාවනය කරන්නේ කෙසේදැයි ඔබට කියමි.

පළමුව, ස්නායු ජාලයක් යනු කුමක්දැයි නිර්වචනය කරමු.

අපගේ නඩුවේදී, මෙය ගණිතමය ආකෘතියක් මෙන්ම එහි මෘදුකාංග හෝ දෘඩාංග ප්‍රතිමූර්තියක් වන අතර එය ජීව විද්‍යාත්මක ස්නායුක ජාල සංවිධානය කිරීම සහ ක්‍රියාත්මක කිරීමේ මූලධර්මය මත ගොඩනගා ඇත - ජීවී ජීවියෙකුගේ ස්නායු සෛල ජාල. මෙම සංකල්පය ඇති වූයේ මොළයේ සිදුවන ක්‍රියාවලීන් අධ්‍යයනය කරමින් මෙම ක්‍රියාවලීන් ආදර්ශයට ගැනීමට උත්සාහ කිරීමේදී ය.

ස්නායුක ජාල වචනයේ සුපුරුදු අර්ථයෙන් වැඩසටහන්ගත කර නැත, ඒවා පුහුණු කර ඇත. ඉගෙනීමේ හැකියාව සාම්ප්‍රදායික ඇල්ගොරිතම වලට වඩා ස්නායුක ජාල වල ප්‍රධාන වාසි වලින් එකකි. තාක්ෂණික වශයෙන්, ඉගෙනීම සමන්විත වන්නේ නියුරෝන අතර සම්බන්ධතා වල සංගුණක සොයා ගැනීමයි. පුහුණු ක්‍රියාවලියේදී, ආදාන දත්ත සහ ප්‍රතිදාන දත්ත අතර සංකීර්ණ පරායත්තතා හඳුනා ගැනීමට මෙන්ම සාමාන්‍යකරණය සිදු කිරීමට ස්නායු ජාලයට හැකි වේ.

යන්ත්‍ර ඉගෙනීමේ දෘෂ්ටි කෝණයෙන්, ස්නායුක ජාලයක් යනු රටා හඳුනාගැනීමේ ක්‍රම, වෙනස් කොට සැලකීමේ විශ්ලේෂණය, පොකුරු ක්‍රම සහ වෙනත් ක්‍රම පිළිබඳ විශේෂ අවස්ථාවකි.

උපකරණ

පළමුව, අපි උපකරණ දෙස බලමු. අපට ලිනක්ස් මෙහෙයුම් පද්ධතිය ස්ථාපනය කර ඇති සේවාදායකයක් අවශ්‍ය වේ. යන්ත්‍ර ඉගෙනුම් පද්ධති ක්‍රියාත්මක කිරීමට අවශ්‍ය උපකරණ තරමක් බලවත් වන අතර එහි ප්‍රතිඵලයක් වශයෙන් මිල අධික වේ. අතේ හොඳ යන්ත්‍රයක් නොමැති අය සඳහා, වලාකුළු සපයන්නන්ගේ දීමනා කෙරෙහි අවධානය යොමු කරන ලෙස මම නිර්දේශ කරමි. ඔබට අවශ්‍ය සේවාදායකය ඉක්මනින් කුලියට ගත හැකි අතර භාවිතා කරන කාලය සඳහා පමණක් ගෙවිය හැකිය.

ස්නායුක ජාල නිර්මාණය කිරීමට අවශ්ය වන ව්යාපෘති වලදී, මම රුසියානු වලාකුළු සපයන්නෙකුගේ සේවාදායකයන් භාවිතා කරමි. සමාගම NVIDIA වෙතින් බලවත් Tesla V100 ග්‍රැෆික් ප්‍රොසෙසර (GPU) සමඟ යන්ත්‍ර ඉගෙනීම සඳහා විශේෂයෙන් වලාකුළු සේවාදායකයන් කුලියට ලබා දෙයි. කෙටියෙන් කිවහොත්: ගණනය කිරීම් සඳහා CPU (සුප්‍රසිද්ධ මධ්‍යම සැකසුම් ඒකකය) භාවිතා කරන සමාන පිරිවැයක් සහිත සේවාදායකයකට සාපේක්ෂව GPU සහිත සේවාදායකයක් භාවිතා කිරීම දස ගුණයකින් කාර්යක්ෂම (වේගවත්) විය හැක. ගණනය කිරීම් සමඟ වේගයෙන් කටයුතු කරන GPU ගෘහ නිර්මාණ ශිල්පයේ විශේෂාංග නිසා මෙය සාක්ෂාත් කරගනු ලැබේ.

පහත විස්තර කර ඇති උදාහරණ ක්‍රියාත්මක කිරීම සඳහා, අපි දින කිහිපයක් සඳහා පහත සේවාදායකය මිලදී ගත්තෙමු:

SSD තැටිය 150 GB
RAM 32 GB
Tesla V100 16 Gb ප්‍රොසෙසරය cores 4ක් සහිතයි

අපි Ubuntu 18.04 අපේ යන්ත්‍රයේ ස්ථාපනය කළා.

පරිසරය සකස් කිරීම

දැන් අපි සේවාදායකයේ වැඩ සඳහා අවශ්ය සියල්ල ස්ථාපනය කරමු. අපගේ ලිපිය මූලික වශයෙන් ආරම්භකයින් සඳහා වන බැවින්, මම ඔවුන්ට ප්රයෝජනවත් වන කරුණු කිහිපයක් ගැන කතා කරමි.

පරිසරයක් සැකසීමේදී බොහෝ වැඩ විධාන රේඛාව හරහා සිදු කෙරේ. බොහෝ පරිශීලකයින් ඔවුන්ගේ වැඩ කරන මෙහෙයුම් පද්ධතිය ලෙස වින්ඩෝස් භාවිතා කරයි. මෙම OS හි සම්මත කොන්සෝලය අපේක්ෂා කිරීමට බොහෝ දේ ඉතිරි කරයි. එබැවින්, අපි පහසු මෙවලමක් භාවිතා කරමු Cmder/. කුඩා අනුවාදය බාගත කර Cmder.exe ධාවනය කරන්න. ඊළඟට ඔබ SSH හරහා සේවාදායකයට සම්බන්ධ විය යුතුය:

ssh root@server-ip-or-hostname

server-ip-or-hostname වෙනුවට, ඔබේ සේවාදායකයේ IP ලිපිනය හෝ DNS නම සඳහන් කරන්න. ඊළඟට, මුරපදය ඇතුළත් කරන්න, සම්බන්ධතාවය සාර්ථක නම්, අපට මෙවැනි පණිවිඩයක් ලැබිය යුතුය.

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

ML ආකෘති සංවර්ධනය සඳහා ප්රධාන භාෂාව වන්නේ Python ය. ලිනක්ස් හි භාවිතා කිරීම සඳහා වඩාත් ජනප්‍රිය වේදිකාව වේ ඇනකොන්ඩා.

අපි එය අපගේ සේවාදායකයේ ස්ථාපනය කරමු.

අපි දේශීය පැකේජ කළමනාකරු යාවත්කාලීන කිරීම ආරම්භ කරමු:

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

දැන් අපි ML විශේෂඥයින් සඳහා ජනප්‍රිය සංවර්ධන මෙවලමක් වන Jupyter Notebook දියත් කළ යුතුයි. එය ඔබට කේතය ලිවීමට සහ එය ක්රියාත්මක කිරීමේ ප්රතිඵල වහාම දැකීමට ඉඩ සලසයි. 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

අපි localhost:8080 සඳහා සබැඳිය භාවිතා කරමු. සම්පූර්ණ මාර්ගය පිටපත් කර එය ඔබේ පරිගණකයේ දේශීය බ්‍රවුසරයේ ලිපින තීරුවට අලවන්න. Jupyter Notebook විවෘත වනු ඇත.

අපි නව සටහන් පොතක් නිර්මාණය කරමු: New - Notebook - Python 3.

අපි ස්ථාපනය කර ඇති සියලුම සංරචකවල නිවැරදි ක්‍රියාකාරිත්වය පරීක්ෂා කරමු. අපි උදාහරණ PyTorch කේතය Jupyter වෙත ඇතුළු කර ක්‍රියාත්මක කිරීම ක්‍රියාත්මක කරමු (ධාවන බොත්තම):

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

ප්රතිඵලය මේ වගේ දෙයක් විය යුතුය:

ඔබට සමාන ප්‍රති result ලයක් තිබේ නම්, අපි සියල්ල නිවැරදිව වින්‍යාස කර ඇති අතර අපට ස්නායුක ජාලයක් සංවර්ධනය කිරීම ආරම්භ කළ හැකිය!

ස්නායු ජාලයක් නිර්මාණය කිරීම

රූප හඳුනාගැනීම සඳහා අපි ස්නායු ජාලයක් නිර්මාණය කරමු. අපි මෙය පදනමක් ලෙස ගනිමු නායකත්වය.

ජාලය පුහුණු කිරීම සඳහා අපි පොදුවේ පවතින 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)

පුහුණු දත්ත පිළිබඳ ජාල පුහුණුව

අපි අපේ ස්නායු ජාලය පුහුණු කිරීම ආරම්භ කරමු. ඔබ මෙම කේතය ධාවනය කිරීමෙන් පසුව, කාර්යය අවසන් වන තෙක් ඔබට යම් කාලයක් රැඳී සිටීමට සිදුවනු ඇති බව කරුණාවෙන් සලකන්න. මට විනාඩි 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 (Comute Unified Device Architecture) යනු ග්‍රැෆික් සැකසුම් ඒකක (GPUs) මත සාමාන්‍ය පරිගණකකරණය සඳහා NVIDIA විසින් සංවර්ධනය කරන ලද සමාන්තර පරිගණක වේදිකාවකි. 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

ග්‍රැෆික් සැකසුම් ඒකකයක (GPU) ඔබේ පළමු ස්නායු ජාලය. ආරම්භක මාර්ගෝපදේශය

උපකරණ

පරිසරය සකස් කිරීම

ස්නායු ජාලයක් නිර්මාණය කිරීම

CIFAR10 පූරණය කිරීම සහ සාමාන්‍යකරණය කිරීම

ස්නායු ජාල අර්ථ දැක්වීම

පුහුණු දත්ත පිළිබඳ ජාල පුහුණුව

පරීක්ෂණ දත්ත මත ජාල පරීක්ෂාව

GPU මත ස්නායුක ජාලයක් පුහුණු කිරීම

අදහස් එක් කරන්න

ග්‍රැෆික් සැකසුම් ඒකකයක (GPU) ඔබේ පළමු ස්නායු ජාලය. ආරම්භක මාර්ගෝපදේශය

උපකරණ

පරිසරය සකස් කිරීම

ස්නායු ජාලයක් නිර්මාණය කිරීම

CIFAR10 පූරණය කිරීම සහ සාමාන්‍යකරණය කිරීම

ස්නායු ජාල අර්ථ දැක්වීම

පුහුණු දත්ත පිළිබඳ ජාල පුහුණුව

පරීක්ෂණ දත්ත මත ජාල පරීක්ෂාව

GPU මත ස්නායුක ජාලයක් පුහුණු කිරීම

අදහස් එක් කරන්න ඊ-මේල් මගින් පිලිතුරු දෙන්න අවලංගු

අදහස් එක් කරන්න