ఈ కథనంలో, 30 నిమిషాలలో మెషిన్ లెర్నింగ్ వాతావరణాన్ని ఎలా సెటప్ చేయాలో, ఇమేజ్ రికగ్నిషన్ కోసం న్యూరల్ నెట్వర్క్ను ఎలా సృష్టించాలో, ఆపై అదే నెట్వర్క్ను గ్రాఫిక్స్ ప్రాసెసర్ (GPU)లో ఎలా అమలు చేయాలో నేను మీకు చెప్తాను.
ముందుగా, న్యూరల్ నెట్వర్క్ అంటే ఏమిటో నిర్వచిద్దాం.
మా విషయంలో, ఇది గణిత నమూనా, అలాగే దాని సాఫ్ట్వేర్ లేదా హార్డ్వేర్ అవతారం, జీవసంబంధ నాడీ నెట్వర్క్ల యొక్క సంస్థ మరియు పనితీరు యొక్క సూత్రంపై నిర్మించబడింది - జీవి యొక్క నాడీ కణాల నెట్వర్క్లు. మెదడులో సంభవించే ప్రక్రియలను అధ్యయనం చేస్తున్నప్పుడు మరియు ఈ ప్రక్రియలను మోడల్ చేయడానికి ప్రయత్నిస్తున్నప్పుడు ఈ భావన ఉద్భవించింది.
న్యూరల్ నెట్వర్క్లు పదం యొక్క సాధారణ అర్థంలో ప్రోగ్రామ్ చేయబడవు, అవి శిక్షణ పొందాయి. సాంప్రదాయ అల్గారిథమ్ల కంటే న్యూరల్ నెట్వర్క్ల యొక్క ప్రధాన ప్రయోజనాల్లో నేర్చుకునే సామర్థ్యం ఒకటి. సాంకేతికంగా, లెర్నింగ్ అనేది న్యూరాన్ల మధ్య కనెక్షన్ల గుణకాలను కనుగొనడం. శిక్షణ ప్రక్రియలో, న్యూరల్ నెట్వర్క్ ఇన్పుట్ డేటా మరియు అవుట్పుట్ డేటా మధ్య సంక్లిష్ట డిపెండెన్సీలను గుర్తించగలదు, అలాగే సాధారణీకరణను కూడా చేయగలదు.
మెషిన్ లెర్నింగ్ దృక్కోణం నుండి, న్యూరల్ నెట్వర్క్ అనేది నమూనా గుర్తింపు పద్ధతులు, వివక్షత విశ్లేషణ, క్లస్టరింగ్ పద్ధతులు మరియు ఇతర పద్ధతుల యొక్క ప్రత్యేక సందర్భం.
పరికరాలు
మొదట, పరికరాలను చూద్దాం. మనకు Linux ఆపరేటింగ్ సిస్టమ్తో ఇన్స్టాల్ చేయబడిన సర్వర్ అవసరం. మెషీన్ లెర్నింగ్ సిస్టమ్లను ఆపరేట్ చేయడానికి అవసరమైన పరికరాలు చాలా శక్తివంతమైనవి మరియు ఫలితంగా, ఖరీదైనవి. చేతిలో మంచి యంత్రం లేని వారికి, క్లౌడ్ ప్రొవైడర్ల ఆఫర్లకు శ్రద్ధ వహించాలని నేను సిఫార్సు చేస్తున్నాను. మీరు అవసరమైన సర్వర్ను త్వరగా అద్దెకు తీసుకోవచ్చు మరియు వినియోగ సమయానికి మాత్రమే చెల్లించవచ్చు.
న్యూరల్ నెట్వర్క్లను సృష్టించాల్సిన అవసరం ఉన్న ప్రాజెక్ట్లలో, నేను రష్యన్ క్లౌడ్ ప్రొవైడర్లలో ఒకరి సర్వర్లను ఉపయోగిస్తాను. NVIDIA నుండి శక్తివంతమైన Tesla V100 గ్రాఫిక్స్ ప్రాసెసర్లతో (GPU) మెషిన్ లెర్నింగ్ కోసం ప్రత్యేకంగా క్లౌడ్ సర్వర్లను కంపెనీ అద్దెకు అందిస్తుంది. సంక్షిప్తంగా: గణనల కోసం CPU (ప్రసిద్ధ సెంట్రల్ ప్రాసెసింగ్ యూనిట్)ని ఉపయోగించే సారూప్య ధర కలిగిన సర్వర్తో పోలిస్తే GPUతో సర్వర్ని ఉపయోగించడం పదుల రెట్లు ఎక్కువ సమర్థవంతంగా (వేగంగా) ఉంటుంది. GPU ఆర్కిటెక్చర్ యొక్క లక్షణాల కారణంగా ఇది సాధించబడుతుంది, ఇది గణనలను వేగంగా ఎదుర్కుంటుంది.
దిగువ వివరించిన ఉదాహరణలను అమలు చేయడానికి, మేము క్రింది సర్వర్ని చాలా రోజుల పాటు కొనుగోలు చేసాము:
- SSD డిస్క్ 150 GB
- RAM 32 GB
- Tesla V100 16 Gb ప్రాసెసర్, 4 కోర్లు
మేము మా మెషీన్లో ఉబుంటు 18.04ని ఇన్స్టాల్ చేసాము.
పర్యావరణాన్ని ఏర్పాటు చేయడం
ఇప్పుడు సర్వర్లో పని చేయడానికి అవసరమైన ప్రతిదాన్ని ఇన్స్టాల్ చేద్దాం. మా వ్యాసం ప్రాథమికంగా ప్రారంభకులకు సంబంధించినది కాబట్టి, వారికి ఉపయోగపడే కొన్ని పాయింట్ల గురించి నేను మాట్లాడతాను.
పర్యావరణాన్ని ఏర్పాటు చేసేటప్పుడు చాలా పని కమాండ్ లైన్ ద్వారా జరుగుతుంది. చాలా మంది వినియోగదారులు విండోస్ను తమ వర్కింగ్ ఓఎస్గా ఉపయోగిస్తున్నారు. ఈ OSలోని స్టాండర్డ్ కన్సోల్ కోరుకునేది చాలా ఉంది. అందువలన, మేము అనుకూలమైన సాధనాన్ని ఉపయోగిస్తాము . మినీ వెర్షన్ను డౌన్లోడ్ చేసి, 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 నమూనాలను అభివృద్ధి చేయడానికి ప్రధాన భాష పైథాన్. మరియు Linuxలో దాని ఉపయోగం కోసం అత్యంత ప్రజాదరణ పొందిన వేదిక .
దీన్ని మన సర్వర్లో ఇన్స్టాల్ చేద్దాం.
మేము స్థానిక ప్యాకేజీ నిర్వాహికిని నవీకరించడం ద్వారా ప్రారంభిస్తాము:
sudo apt-get updateకర్ల్ను ఇన్స్టాల్ చేయండి (కమాండ్ లైన్ యుటిలిటీ):
sudo apt-get install curlఅనకొండ డిస్ట్రిబ్యూషన్ యొక్క తాజా వెర్షన్ను డౌన్లోడ్ చేయండి:
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 నిపుణుల కోసం ప్రసిద్ధ డెవలప్మెంట్ సాధనం. ఇది కోడ్ను వ్రాయడానికి మరియు దాని అమలు ఫలితాలను వెంటనే చూడటానికి మిమ్మల్ని అనుమతిస్తుంది. జూపిటర్ నోట్బుక్ అనకొండతో చేర్చబడింది మరియు ఇప్పటికే మా సర్వర్లో ఇన్స్టాల్ చేయబడింది. మీరు మా డెస్క్టాప్ సిస్టమ్ నుండి దీనికి కనెక్ట్ చేయాలి.
దీన్ని చేయడానికి, మేము మొదట పోర్ట్ 8080ని పేర్కొనే సర్వర్లో జూపిటర్ను ప్రారంభిస్తాము:
jupyter notebook --no-browser --port=8080 --allow-rootతరువాత, మా Cmder కన్సోల్లో మరొక ట్యాబ్ను తెరవడం (టాప్ మెనూ - కొత్త కన్సోల్ డైలాగ్) మేము పోర్ట్ 8080 ద్వారా SSH ద్వారా సర్వర్కు కనెక్ట్ చేస్తాము:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameమేము మొదటి ఆదేశాన్ని నమోదు చేసినప్పుడు, మా బ్రౌజర్లో జూపిటర్ని తెరవడానికి మాకు లింక్లు అందించబడతాయి:
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 కోసం లింక్ని ఉపయోగిస్తాము. పూర్తి మార్గాన్ని కాపీ చేసి, మీ PC యొక్క స్థానిక బ్రౌజర్ చిరునామా బార్లో అతికించండి. జూపిటర్ నోట్బుక్ తెరవబడుతుంది.
కొత్త నోట్బుక్ని క్రియేట్ చేద్దాం: కొత్త - నోట్బుక్ - పైథాన్ 3.
మేము ఇన్స్టాల్ చేసిన అన్ని భాగాల సరైన ఆపరేషన్ను తనిఖీ చేద్దాం. జూపిటర్లో ఉదాహరణ PyTorch కోడ్ని నమోదు చేసి, ఎగ్జిక్యూషన్ను (రన్ బటన్) అమలు చేద్దాం:
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
ఫలితం ఇలా ఉండాలి:
మీకు ఇలాంటి ఫలితం ఉంటే, మేము ప్రతిదీ సరిగ్గా కాన్ఫిగర్ చేసాము మరియు మేము న్యూరల్ నెట్వర్క్ను అభివృద్ధి చేయడం ప్రారంభించవచ్చు!
న్యూరల్ నెట్వర్క్ను సృష్టిస్తోంది
మేము ఇమేజ్ రికగ్నిషన్ కోసం ఒక న్యూరల్ నెట్వర్క్ని క్రియేట్ చేస్తాము. దీన్ని ప్రాతిపదికగా తీసుకుందాం .
మేము నెట్వర్క్కు శిక్షణ ఇవ్వడానికి పబ్లిక్గా అందుబాటులో ఉన్న CIFAR10 డేటాసెట్ని ఉపయోగిస్తాము. ఇది తరగతులను కలిగి ఉంది: "విమానం", "కారు", "పక్షి", "పిల్లి", "జింక", "కుక్క", "కప్ప", "గుర్రం", "ఓడ", "ట్రక్". CIFAR10లోని చిత్రాలు 3x32x32, అంటే 3x32 పిక్సెల్ల 32-ఛానల్ రంగు చిత్రాలు.
పని కోసం, మేము చిత్రాలతో పని చేయడానికి PyTorch సృష్టించిన ప్యాకేజీని ఉపయోగిస్తాము - టార్చ్విజన్.
మేము ఈ క్రింది దశలను క్రమంలో చేస్తాము:
- శిక్షణ మరియు పరీక్ష డేటా సెట్లను లోడ్ చేయడం మరియు సాధారణీకరించడం
- న్యూరల్ నెట్వర్క్ నిర్వచనం
- శిక్షణ డేటాపై నెట్వర్క్ శిక్షణ
- పరీక్ష డేటాపై నెట్వర్క్ పరీక్ష
- GPUని ఉపయోగించి శిక్షణ మరియు పరీక్షను పునరావృతం చేద్దాం
మేము జూపిటర్ నోట్బుక్లో దిగువ అన్ని కోడ్లను అమలు చేస్తాము.
CIFAR10ని లోడ్ చేయడం మరియు సాధారణీకరించడం
కింది కోడ్ను జూపిటర్లో కాపీ చేసి అమలు చేయండి:
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 (కంప్యూట్ యూనిఫైడ్ డివైస్ ఆర్కిటెక్చర్) అనేది గ్రాఫిక్స్ ప్రాసెసింగ్ యూనిట్లపై (GPUలు) సాధారణ కంప్యూటింగ్ కోసం 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
