그래픽 처리 장치(GPU)의 첫 번째 신경망입니다. 초보자 가이드

이번 글에서는 30분 만에 머신러닝 환경을 설정하고, 이미지 인식을 위한 신경망을 만든 뒤, 동일한 네트워크를 그래픽 프로세서(GPU)에서 실행하는 방법을 알려드리겠습니다.

먼저 신경망이 무엇인지 정의해 보겠습니다.

우리의 경우 이것은 생물학적 신경 네트워크, 즉 살아있는 유기체의 신경 세포 네트워크의 조직 및 기능 원리를 기반으로 구축된 수학적 모델이자 소프트웨어 또는 하드웨어 구현입니다. 이 개념은 뇌에서 일어나는 과정을 연구하고 이러한 과정을 모델링하려고 시도하는 동안 발생했습니다.

신경망은 일반적인 의미로 프로그래밍되는 것이 아니라 훈련됩니다. 학습 능력은 기존 알고리즘에 비해 신경망의 주요 장점 중 하나입니다. 기술적으로 학습은 뉴런 간의 연결 계수를 찾는 것으로 구성됩니다. 훈련 과정에서 신경망은 입력 데이터와 출력 데이터 간의 복잡한 종속성을 식별하고 일반화를 수행할 수 있습니다.

기계 학습의 관점에서 볼 때 신경망은 패턴 인식 방법, 판별 분석, 클러스터링 방법 및 기타 방법의 특별한 경우입니다.

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

먼저 장비를 살펴보겠습니다. Linux 운영 체제가 설치된 서버가 필요합니다. 기계 학습 시스템을 작동하는 데 필요한 장비는 매우 강력하고 결과적으로 비용이 많이 듭니다. 좋은 머신을 가지고 있지 않은 분들은 클라우드 제공 업체의 제안에 주목할 것을 권장합니다. 필요한 서버를 빠르게 임대하고, 사용한 시간만큼만 비용을 지불하면 됩니다.

신경망을 생성해야 하는 프로젝트에서는 러시아 클라우드 제공업체 중 하나의 서버를 사용합니다. 이 회사는 NVIDIA의 강력한 Tesla V100 그래픽 프로세서(GPU)를 사용하여 기계 학습을 위한 임대용 클라우드 서버를 특별히 제공합니다. 간단히 말해서, GPU가 있는 서버를 사용하는 것은 계산을 위해 CPU(잘 알려진 중앙 처리 장치)를 사용하는 유사한 비용의 서버에 비해 수십 배 더 효율적(빠를 수 있음)이 될 수 있습니다. 이는 계산에 더 빠르게 대처하는 GPU 아키텍처의 기능으로 인해 달성됩니다.

아래 설명된 예제를 구현하기 위해 며칠 동안 다음 서버를 구입했습니다.

• SSD 디스크 150GB
• RAM 32GB
• Tesla V100 16Gb 프로세서, 4코어

우리 컴퓨터에 Ubuntu 18.04를 설치했습니다.

환경 설정

이제 서버 작업에 필요한 모든 것을 설치해 보겠습니다. 우리 기사는 주로 초보자를 대상으로하므로 초보자에게 유용한 몇 가지 사항에 대해 이야기하겠습니다.

환경을 설정할 때 많은 작업이 명령줄을 통해 수행됩니다. 대부분의 사용자는 Windows를 작업 OS로 사용합니다. 이 OS의 표준 콘솔에는 부족한 점이 많습니다. 따라서 편리한 도구를 사용하겠습니다. 명령/. 미니 버전을 다운로드하고 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입니다. Linux에서 가장 널리 사용되는 플랫폼은 아나콘다.

서버에 설치해 보겠습니다.

먼저 로컬 패키지 관리자를 업데이트합니다.

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!

현재 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 콘솔(상위 메뉴 - 새 콘솔 대화 상자)에서 다른 탭을 열면 SSH를 통해 포트 8080을 통해 서버에 연결됩니다.

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에 대한 링크를 사용해 보겠습니다. 전체 경로를 복사하여 PC 로컬 브라우저의 주소 표시줄에 붙여넣으세요. Jupyter Notebook이 열립니다.

새 노트북을 만들어 보겠습니다. New - Notebook - Python 3.

우리가 설치한 모든 구성 요소가 올바르게 작동하는지 확인해 보겠습니다. 예시 PyTorch 코드를 Jupyter에 입력하고 실행을 실행해 보겠습니다(실행 버튼).

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)

훈련 데이터에 대한 네트워크 훈련

신경망 훈련을 시작해 보겠습니다. 이 코드를 실행한 후 작업이 완료될 때까지 잠시 기다려야 한다는 점에 유의하세요. 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)))

결과는 꽤 좋아 보입니다. 네트워크는 사진 4장 중 3장을 정확하게 식별했습니다.

전체 데이터 세트에서 네트워크가 어떻게 작동하는지 살펴보겠습니다.

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)는 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가 설치된 서버를 선택했습니다.
• 우리는 신경망을 생성하기 위한 소프트웨어 환경을 설정했습니다.
• 우리는 이미지 인식을 위한 신경망을 만들고 훈련시켰습니다.
• GPU를 사용하여 네트워크 훈련을 반복하고 속도가 향상되었습니다.

댓글로 질문에 답변해 드리겠습니다.

출처 : habr.com