הרשת העצבית הראשונה שלך ביחידת עיבוד גרפית (GPU). מדריך למתחיל

במאמר זה, אספר לכם כיצד להגדיר סביבת למידת מכונה ב-30 דקות, ליצור רשת עצבית לזיהוי תמונות ולאחר מכן להפעיל את אותה רשת על מעבד גרפי (GPU).

ראשית, הבה נגדיר מהי רשת עצבית.

במקרה שלנו, זהו מודל מתמטי, כמו גם התגלמות התוכנה או החומרה שלו, הבנוי על עקרון הארגון והתפקוד של רשתות עצביות ביולוגיות - רשתות של תאי עצב של אורגניזם חי. מושג זה עלה תוך כדי לימוד התהליכים המתרחשים במוח וניסיון ליצור מודל של תהליכים אלו.

רשתות עצביות אינן מתוכנתות במובן הרגיל של המילה, הן מאומנות. היכולת ללמוד היא אחד היתרונות העיקריים של רשתות עצביות על פני אלגוריתמים מסורתיים. מבחינה טכנית, למידה מורכבת ממציאת מקדמי הקשרים בין נוירונים. במהלך תהליך האימון, הרשת העצבית מסוגלת לזהות תלות מורכבת בין נתוני קלט ונתוני פלט, וכן לבצע הכללה.

מנקודת המבט של למידת מכונה, רשת עצבית היא מקרה מיוחד של שיטות זיהוי תבניות, ניתוח מבחין, שיטות מקבץ ושיטות אחרות.

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

ראשית, בואו נסתכל על הציוד. אנחנו צריכים שרת עם מערכת ההפעלה לינוקס מותקנת עליו. הציוד הנדרש להפעלת מערכות למידת מכונה הוא חזק למדי וכתוצאה מכך יקר. למי שאין מכונה טובה בהישג יד, אני ממליץ לשים לב להצעות של ספקי ענן. ניתן לשכור את השרת הנדרש במהירות ולשלם רק עבור זמן השימוש.

בפרויקטים שבהם יש צורך ליצור רשתות עצביות, אני משתמש בשרתים של אחד מספקי הענן הרוסיים. החברה מציעה שרתי ענן להשכרה במיוחד עבור למידת מכונה עם מעבדים גרפיים חזקים של Tesla V100 (GPU) מבית NVIDIA. בקיצור: שימוש בשרת עם GPU יכול להיות יעיל (מהיר) עשרות מונים בהשוואה לשרת בעלות דומה שמשתמש ב-CPU (יחידת העיבוד המרכזית הידועה) לצורך חישובים. זה מושג הודות לתכונות של ארכיטקטורת ה-GPU, המתמודדת עם חישובים מהר יותר.

כדי ליישם את הדוגמאות המתוארות להלן, רכשנו את השרת הבא למספר ימים:

• דיסק SSD 150 גיגה
• זיכרון RAM 32 GB
• מעבד Tesla V100 16 Gb עם 4 ליבות

התקנו את אובונטו 18.04 במחשב שלנו.

הקמת הסביבה

עכשיו בואו נתקין את כל הדרוש לעבודה על השרת. מכיוון שהמאמר שלנו מיועד בעיקר למתחילים, אדבר על כמה נקודות שיהיו שימושיות עבורם.

הרבה מהעבודה בעת הגדרת סביבה נעשית דרך שורת הפקודה. רוב המשתמשים משתמשים ב-Windows כמערכת ההפעלה שלהם. הקונסולה הסטנדרטית במערכת ההפעלה הזו משאירה הרבה מה לרצוי. לכן, נשתמש בכלי נוח 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 и זרימת מתיחה.

השימוש במסגרת מאפשרת להגביר את מהירות הפיתוח ולהשתמש בכלים מוכנים למשימות סטנדרטיות.

בדוגמה זו נעבוד עם 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 ייפתח.

בואו ניצור מחברת חדשה: חדש - מחברת - Python 3.

בואו נבדוק את הפעולה הנכונה של כל הרכיבים שהתקנו. בואו נזין את קוד PyTorch לדוגמה לתוך Jupyter ונפעיל את הביצוע (כפתור הפעלה):

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

התוצאה צריכה להיות משהו כזה:

אם יש לך תוצאה דומה, אז הגדרנו הכל נכון ונוכל להתחיל לפתח רשת עצבית!

יצירת רשת עצבית

ניצור רשת עצבית לזיהוי תמונה. בואו ניקח את זה כבסיס מַנהִיגוּת.

נשתמש במערך הנתונים הזמין לציבור של CIFAR10 כדי לאמן את הרשת. יש לו כיתות: "מטוס", "מכונית", "ציפור", "חתול", "צבי", "כלב", "צפרדע", "סוס", "ספינה", "משאית". התמונות ב-CIFAR10 הן בגודל 3x32x32, כלומר, תמונות צבעוניות של 3 ערוצים של 32x32 פיקסלים.

לעבודה, נשתמש בחבילה שיצרה 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 (Compute Unified Device Architecture) היא פלטפורמת מחשוב מקבילית שפותחה על ידי NVIDIA עבור מחשוב כללי על יחידות עיבוד גרפיות (GPUs). עם CUDA, מפתחים יכולים להאיץ באופן דרמטי יישומי מחשוב על ידי מינוף הכוח של GPUs. הפלטפורמה הזו כבר מותקנת בשרת שלנו שרכשנו.

תחילה נגדיר את ה-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