머신러닝 모델이 GPU에서 더 느리게 학습되는데 GPU의 종류 때문일까요?

[Jaeyoung-Choi]

해결하고자 하는 문제

colab환경에서 머신러닝을 공부중인데 처음 만들어본 MNIST분류 모델이 GPU를 이용해 back propagation을 계산하면 CPU를 이용했을 때 보다 약 2배정도 느리게 계산됩니다. 집접 계산하여 모델을 만들기 위해 텐서를 직접 계산하여 모델을 만들었고, numpy를 이용해 제작할 수 있었지만 gpu를 사용하기 위해 pytorch를 이용했습니다. 모델은 784개 노드의 입력 레이어에서 16 노드로 이루어진 레이어 2개를 통과해 10개의 노드로 출력되게 만들었습니다.

코드 혹은 오류

import torch
from torchvision import datasets as dsets
import torchvision.transforms as transforms

device = 'cuda' if torch.cuda.is_available() else 'cpu'

torch.manual_seed(42)
if device == 'cuda':
    torch.cuda.manual_seed_all(42)
    print(torch.cuda.current_device(), torch.cuda.device_count(), torch.cuda.get_device_name(0))

def sigmoid(X):
    return 1 / (1 + torch.exp(-X))

def softmax(X):
    return torch.exp(X) / torch.sum(torch.exp(X), dim = 0)

def dsigmoid(X):
    # return torch.exp(-X) / torch.pow(1 + torch.exp(-X), 2)
    return torch.mul(sigmoid(X), 1 - sigmoid(X))

def dsoftmax(X):
    #return torch.mul((torch.sum(torch.exp(X), dim = 1) - torch.exp(X)) / torch.pow(torch.sum(torch.exp(X), dim = 1), 2), torch.exp(X))
    return softmax(X) - torch.pow(softmax(X), 2)

lr = 0.001
class model:
    def __init__(self):
        self.W = [torch.normal(torch.zeros((784, 16)), torch.tensor([2])).to(device),
                  torch.normal(torch.zeros((16, 16)), torch.tensor([2])).to(device),
                  torch.normal(torch.zeros((16, 10)), torch.tensor([2])).to(device)]
        self.B = [torch.normal(torch.zeros((16)), torch.tensor(2)).to(device),
                  torch.normal(torch.zeros((16)), torch.tensor(2)).to(device),
                  torch.normal(torch.zeros((10)), torch.tensor(2)).to(device)]
    
    def forward(self, X):
        L1 = sigmoid(torch.matmul(X, self.W[0]) + self.B[0])
        L2 = sigmoid(torch.matmul(L1, self.W[1]) + self.B[1])
        Y = softmax(torch.matmul(L2, self.W[2]) + self.B[2])
        return Y

    def loss(self, X, Y):
        return torch.sum(torch.pow(self.forward(X) - Y, 2)) # / 원소 갯수(어케 구함?)
    
    def backward(self, X, Y):
        dW = [0, 0, 0]
        dB = [0, 0, 0]
        L1 = sigmoid(torch.matmul(X, self.W[0]) + self.B[0])
        L2 = sigmoid(torch.matmul(L1, self.W[1]) + self.B[1])
        FOR = softmax(torch.matmul(L2, self.W[2]) + self.B[2])

        dB[2] = torch.mul(dsoftmax(torch.matmul(L2, self.W[2]) + self.B[2]), 2 * (FOR - Y))
        # dW[2] = torch.mul(torch.reshape(L2, (16, 1)).expand(16, 10), dB[2].expand(16, 10)) #dB == dsoftmax
        dW[2] = torch.matmul(torch.transpose(torch.unsqueeze(L2, 0), 0, 1), torch.unsqueeze(dB[2], 0))

        # dB[1] = torch.mul(dsigmoid(torch.matmul(L1, self.W[1]) + self.B[1]), torch.sum(torch.transpose(dW[2], 0, 1), dim = 0))
        # dW[1] = torch.mul(torch.reshape(L1, (16, 1)).expand(16, 16), dB[1].expand(16, 16)) #dB == dsoftmax

        # dB[0] = torch.mul(dsigmoid(torch.matmul(X, self.W[0]) + self.B[0]), torch.sum(torch.transpose(dW[1], 0, 1), dim = 0))
        # dW[0] = torch.mul(torch.reshape(X, (784, 1)).expand(784, 16), dB[0].expand(784, 16)) #dB == dsoftmax

        # dB[1] = torch.mul(torch.reshape(torch.sum(torch.mul(self.W[2], dB[2].expand(16, 10)), dim = 1), (1, 16)), dsigmoid(torch.matmul(L1, self.W[1]) + self.B[1]))
        dB[1] = torch.mul(torch.matmul(dB[2], torch.transpose(self.W[2], 0, 1)), dsigmoid(torch.matmul(L1, self.W[1]) + self.B[1]))
        # dW[1] = torch.mul(torch.reshape(L1, (16, 1)).expand(16, 16), dB[1].expand(16, 16)) #dB == dsoftmax
        dW[1] = torch.matmul(torch.transpose(torch.unsqueeze(L1, 0), 0, 1), torch.unsqueeze(dB[1], 0))

        # dB[0] = torch.mul(torch.reshape(torch.sum(torch.mul(self.W[1], dB[1].expand(16, 16)), dim = 1), (1, 16)), dsigmoid(torch.matmul(X, self.W[0]) + self.B[0]))
        dB[0] = torch.mul(torch.matmul(dB[1], torch.transpose(self.W[1], 0, 1)), dsigmoid(torch.matmul(X, self.W[0]) + self.B[0]))
        # dW[0] = torch.mul(torch.reshape(X, (784, 1)).expand(784, 16), dB[0].expand(784, 16)) #dB == dsoftmax
        dW[0] = torch.matmul(torch.transpose(torch.unsqueeze(X, 0), 0, 1), torch.unsqueeze(dB[0], 0))


        self.W[2] = self.W[2] + torch.mul(dW[2], -1 * lr)
        self.B[2] = self.B[2] + torch.mul(dB[2], -1 * lr)

        self.W[1] = self.W[1] + torch.mul(dW[1], -1 * lr)
        self.B[1] = self.B[1] + torch.mul(dB[1], -1 * lr)

        self.W[0] = self.W[0] + torch.mul(dW[0], -1 * lr)
        self.B[0] = self.B[0] + torch.mul(dB[0], -1 * lr)

mnist_train = dsets.MNIST(root='MNIST_data/', # 다운로드 경로 지정
                          train=True, # True를 지정하면 훈련 데이터로 다운로드
                          transform=transforms.ToTensor(), # 텐서로 변환
                          download=True)

mnist_test = dsets.MNIST(root='MNIST_data/', # 다운로드 경로 지정
                         train=False, # False를 지정하면 테스트 데이터로 다운로드
                         transform=transforms.ToTensor(), # 텐서로 변환
                         download=True)

def one_hot_encoding(x):
    arg = [0] * 10
    arg[x] = 1
    return arg

mnist_test_X = []
for i in range(10000):
    mnist_test_X.append(mnist_test[i][0].reshape(1, 784))

mnist_test_X = torch.cat(mnist_test_X, dim = 0)
mnist_test_X = mnist_test_X.to(device)

mnist_train_X = []
for i in range(60000):
    mnist_train_X.append(mnist_train[i][0].reshape(1, 784))

mnist_train_X = torch.cat(mnist_train_X, dim = 0)
mnist_train_X = mnist_train_X.to(device)

mnist_test_Y = []
for i in range(10000):
    mnist_test_Y.append(one_hot_encoding(mnist_test[i][1]))
mnist_test_Y = torch.tensor(mnist_test_Y).to(device)

mnist_train_Y = []
for i in range(60000):
    mnist_train_Y.append(one_hot_encoding(mnist_train[i][1]))
mnist_train_Y = torch.tensor(mnist_train_Y).to(device)

M = model()

for tr in range(100):
    loss_sum = torch.tensor([0], dtype=torch.float).to(device)
    for i in range(60000):
        #print(tr, i, M.loss(mnist_train_X[i], mnist_train_Y[i]).to(torch.device('cpu')), end = '\t')
        M.backward(mnist_train_X[i], mnist_train_Y[i])
        loss_sum += M.loss(mnist_train_X[i], mnist_train_Y[i])
        #print(M.loss(mnist_train_X[i], mnist_train_Y[i]).to(torch.device('cpu')))
    print(tr, loss_sum)

환경

사용중인 운영체제, 언어, 라이브러리의 버전을 적어주세요.
Python 3.7.11
pytorch 1.9.0+cu102
GPU: nvidia T4
CPU: Intel(R) Xeon(R) CPU @ 2.30GHz(46080 KB cache) * 2

시도해본 방법

인터넷을 검색하여 찾아보니 nvidia의 T4는 다른 GPU보다 float연산 성능이 떨어지지만 integer 연산 성능이 더 좋은 것을 보아하니 float 연산보다는 4bit integer 연산에 특화된 기종 같았습니다. 그래서 float텐서로 만들어진 제 모델에서 계산이 느리게 되는건가 생각됩니다.

[blackdew]

60000개의 이미지를 처리할 때에 이미지를 한개씩 for loop으로 처리하게 되면 GPU를 제대로 이용할 수 없습니다.
라이브러리에서는 행렬로 여러개의 데이터를 묶어서 한번에 처리하도록 되어있죠.
내부적으로 각 이미지들의 연산이 병렬처리가 되는데요. 이 때 GPU를 제대로 이용할 수 있게 됩니다.
지금 작성하신 코드는 for loop으로 이미지 하나씩 가져와서 처리하도록 되어있기에 GPU의 효과를 제대로 받을 수 어벗게 되는거죠.

(60000, 28, 28) 혹은 (60000, 784) 형태이 데이터를 한 번에 입력하여 학습시키는 방법에 대해서 찾아보세요.
아마 튜토리얼로 제공되는 기본 사용법이어서 익히는 데에 어렵지 않을거에요.

[hephaex]

추가로 컴퓨터 구조 관점에서 보충 설명을 드리겠습니다.
CPU에서 ML 코드(Pytorch, Tensorflow)를 실행하면 CPU memory에 데이터와 코드가 올라가고, CPU Memory의 코드가 실행되구요.
GPU에서 ML 코드(Pytorch, Tensorflow)를 실행하면 CPU memory에 데이터와 코드가 올라가서 GPU로 전송하고, 이후 GPU에 연산코어가 GPU 메모리에 저장된 데이터와 코드를 실행합니다.

for문을 사용하시면 GPU에서 CPU로 데이터를 주고 받는 부분이 매번 반복되기 때문에 연산이 실행되는 것보다 메모리간 복사에 더 많은 시간이 걸려서 CPU가 더 빠른 결과가 나온것으로 생각되네요.

[Jaeyoung-Choi]

텐서를 그레픽 메모리로 올리는 tensor.to(device)에서만 CPU 메모리에서 GPU 메모리로 데이터를 넘기고 for문을 사용하면 느려지는 이유는 데이터가 GDRAM과 GPU 사이에서 전달되는데 시간이 걸리기 때문이 아닌건가요??

[hephaex]

GDRAM과 CPU사이에 전달하는데, 이것이 for 루프가 실행될 때 마다 CPU가 이일을 하게 됩니다.
1번째 루프가 끝나고 CPU로 결과를 GPU Memory 에서 CPU memory로 내리고
다음번 루프를 실행할지 CPU가 체크해서 다음번 루프를 실행한다면
2번째 루프가 실행되면서 CPU memory에서 GPU memory로 다시 실행 경과를 전달하고,
GPU가 실행되면 그 결과를 다시 루프가 끝났으니 CPU memory로 내리는 과정이 반복되면,
GPU가 연산하는 시간보다 GPU memory와 CPU memory사이에 데이터를 주고 받는 것이 더 많아지겠죠.

이것을 피하기 위해서 for 루프를 가급적 사용하지 않고 반복 루프를 풀어서 실행한다거나 데이터를 가급적 GPU에서 머물도록하고 CPU로 전송은 결과가 나왔을 때만 하도록 코드를 고치면 더 빠른 실행결과를 얻을 수 있으니 좋겠죠.

[Jaeyoung-Choi]

아 그렇군요 답변 감사합니다!