[카테고리:] 프로그래밍

0~9까지의 손글씨 숫자 데이터인 MNIST을 대상으로 99% 이상의 분류 정확도에 대한 모델 테스트에 대한 글입니다. 이와 유사한 글이 2개 있었는데, 첫번째는 퍼셉트론 방식이고 두번째는 DNN 방식입니다. 아래는 MNIST 데이터셋을 DNN 방식으로 분류한 글입니다.

Model 확장과 가중치값 변경을 통한 예측 정확도 향상

위의 글과는 다르게 이 글은 CNN 방식으로 분류 정확도를 개선했습니다. MNIST 분류에 대한 정확도 순위를 보면 약 40개여의 순위가 존재합니다. 다행인건 이 글의 모델이 이 순위의 상단에 위치한다는 것입니다.

파이토치를 사용했으며, 해당 코드를 대략적으로 살펴보면 다음과 같습니다. 늘 그렇듯이 필요한 패키지를 포함합니다.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dset
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.optim import lr_scheduler

배치 크기와 학습률, 에폭단위의 반복할 학습수를 먼저 지정합니다. 손실값에 큰 영향을 주는 하이퍼 파라메터입니다.

batch_size = 100
learning_rate = 0.001
num_epoch = 20

학습과 테스트를 위한 MNSIT 데이터를 로딩합니다.

mnist_train = dset.MNIST("./", train=True, 
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=(0.1307,), std=(0.3081,))
    ]),
    target_transform=None,
    download=True)

mnist_test = dset.MNIST("./", train=False, 
    transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize(mean=(0.1307,), std=(0.3081,))
    ]), target_transform=None, download=True)

train_loader = DataLoader(mnist_train, batch_size=batch_size, shuffle=True, drop_last=True)
test_loader = DataLoader(mnist_test, batch_size=batch_size, shuffle=False, drop_last=True)

중요한 점은 데이터에 대한 정규화가 적용됩니다. 정규화 방식은 전체 데이터에 대한 평균과 표준편차를 사용했습니다. 이 표준과 표준편차를 구하는 방식은 아래글을 참고하기 바랍니다.

이미지 Dataset에 대한 평균과 표준편차 구하기

다음은 신경망입니다.

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.layer = nn.Sequential(
            nn.Conv2d(1, 16, 3, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.Conv2d(16, 32, 3,padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),           
            nn.Conv2d(32, 64, 3,padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)        
        )
        self.fc_layer = nn.Sequential(
            nn.Linear(64*7*7, 128),
            nn.BatchNorm1d(128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.BatchNorm1d(64),
            nn.ReLU(),            
            nn.Linear(64, 10),
        )       

    def forward(self,x):
        out = self.layer(x)
        out = out.view(batch_size, -1)
        out = self.fc_layer(out)
        return out

중요한 부분은 Convolution Layer와 Affine Layer에 배치정규화가 반영되어 있다는 점입니다. 물론 신경망 구성 레이어와 각 레이어의 뉴런수도 중요한 하이퍼파라메터입니다.

학습 코드입니다. 미분값 계산을 통해 얻어진 경사도 방향으로의 하강 방식은 Adam 방식을 사용했고, 학습률을 고정하지 않고 ReduceLROnPlateau 클래스를 사용하여 손실값의 감소 경향에 따라 변경하도록 하였습니다.

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

model = CNN().to(device)
loss_func = nn.CrossEntropyLoss().to(device)
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,threshold=0.1, patience=1, mode='min')    

for i in range(1, num_epoch+1):
    for _,[image,label] in enumerate(train_loader):
        x = image.to(device)
        y_= label.to(device)
        
        optimizer.zero_grad()
        output = model.forward(x)
        loss = loss_func(output, y_)
        loss.backward()
        optimizer.step()

    scheduler.step(loss)      
    print('Epoch: {}, Loss: {}, LR: {}'.format(i, loss.item(), scheduler.optimizer.state_dict()['param_groups'][0]['lr']))

학습 데이터를 통해 학습된 모델을 테스트 데이터를 통해 정확도를 얻는 코드는 다음과 같습니다.

correct = 0
total = 0

model.eval()
with torch.no_grad():
  for image,label in test_loader:
      x = image.to(device)
      y_= label.to(device)

      output = model.forward(x)
      _,output_index = torch.max(output, 1)

      total += label.size(0)
      correct += (output_index == y_).sum().float()

  print("Accuracy of Test Data: {}%".format(100.0*correct/total))

실제 실행해 보면, 정확도가 99.5을 넘기는 것을 볼 수 있었습니다. 아래는 그 중 하나의 출력 결과입니다.

이 글은 PyTorch를 이용한 딥러닝 개발 시에 Tensor 연산에 대한 내용을 빠르게 참조하기 위해 정리한 글입니다.

#1. 난수값으로 구성된 2×3 텐서 생성

import torch

x = torch.rand(2,3)
print(x)

#2. 정규분포 난수값으로 구성된 2×3 텐서 생성

import torch

x = torch.randn(2,3)
print(x)

#3. [0,10) 까지의 정수형 난수값으로 구성된 2×3 텐서 생성

import torch

x = torch.randint(0,10,size=(2,3))
print(x)

#4. 0으로 채워진 2×3 텐서 생성

import torch

x = torch.zeros(2,3)
print(x)

#5. 다른 텐서의 형상과 동일한 Zero 텐서 생성하기

import torch

ref = torch.rand(2,3)
x = torch.zeros_like(ref)
print(x)

#6. 1로 채워진 2×3 텐서 생성하기

import torch

x = torch.ones(2,3)
print(x)

#7. 다른 텐서의 형상과 동일한 1값으로 구성된 텐서 생성하기

import torch

ref = torch.rand(2,3)
x = torch.ones_like(ref)
print(x)

#8. 텐서의 타입 얻기

import torch

x = torch.rand(2,3)
print(x.type()) # torch.FloatTensor
print(type(x)) # 

#9. 요소값을 정수형 값으로 변환한 텐서 생성하기

import torch

x = torch.rand(2,3) + 1.5
int_x = x.type(dtype=torch.IntTensor)
print(int_x)

#10. 넘파이 배열로부터 텐서 만들기, 텐서로부터 넘파이 배열 만들기

import torch
import numpy as np

x1 = np.ndarray(shape=(2,3), dtype=int, buffer=np.array([1,2,3,4,5,6]))
x2 = torch.from_numpy(x1)
print(x2, x2.type())

x3 = x2.numpy()
print(x3)

#11. 요소값 배열을 통해 실수형 텐서 만들기

import torch

x = torch.FloatTensor([[1,2,3],[4,5,6]])
print(x)

#12. 텐서를 GPU에, 또는 CPU로 옮기기

import torch

x = torch.FloatTensor([[1,2,3],[4,5,6]])

cpu = torch.device('cpu')
gpu = torch.device('cuda')

if torch.cuda.is_available():
    x_gpu = x.to(gpu)
    print(x_gpu)

x_cpu = x_gpu.to(cpu)
print(x_cpu)

#13. 텐서의 크기

import torch

x = torch.FloatTensor(2,3,4,4)
print(x.size()) # torch.Size([2, 3, 4, 4])
print(x.size()[1:2]) torch.Size([3])

#14. 텐서의 요소값 접근

import torch

x = torch.randn(4,3)
print(x)
''' output:
tensor([[ 0.1477,  0.4707, -0.7333],
        [ 0.8718,  0.1213,  0.6299],
        [ 0.2991,  1.1437, -0.7631],
        [ 1.3319,  0.8322, -2.4153]])
'''

print(x[1:3,:])
''' output:
tensor([[ 0.8718,  0.1213,  0.6299],
        [ 0.2991,  1.1437, -0.7631]])
'''

#15. 인덱스값으로 지정된 요소값으로 구성된 새로운 텐서 생성하기(값 복사됨)

import torch

x = torch.randn(4,3)
print(x)
'''output:
tensor([[-0.1728,  0.0887, -0.0186],
        [ 0.9492, -0.0452,  0.5660],
        [-0.4184, -0.2162,  1.0297],
        [-0.5110,  0.2452,  1.0734]])
'''

selected = torch.index_select(x,dim=1,index=torch.LongTensor([0,2]))
print(selected)
'''output:
tensor([[-0.1728, -0.0186],
        [ 0.9492,  0.5660],
        [-0.4184,  1.0297],
        [-0.5110,  1.0734]])
'''

#16. 마스크 텐서로 새로운 텐서 생성하기

import torch

x = torch.randn(2,3)
print(x)
'''output:
tensor([[ 0.1622,  1.1205, -0.4761],
        [ 0.9225,  0.2151,  0.2192]])
'''

mask = torch.BoolTensor([[False, False, True],[False,True,False]])
out = torch.masked_select(x, mask)
print(out)
'''output:
tensor([-0.4761,  0.2151])
'''

#17. 2개의 텐서 결합하기

import torch

x = torch.FloatTensor([[1,2,3],[4,5,6]])
y = torch.FloatTensor([[-1,-2,-3],[-4,-5,-6]])

z1 = torch.cat([x,y], dim=0)
print(z1)
'''
tensor([[ 1.,  2.,  3.],
        [ 4.,  5.,  6.],
        [-1., -2., -3.],
        [-4., -5., -6.]])
'''

z2 = torch.cat([x,y], dim=1)
print(z2)
'''
tensor([[ 1.,  2.,  3., -1., -2., -3.],
        [ 4.,  5.,  6., -4., -5., -6.]])
'''

#18. 2개의 텐서 결합하기(stack 함수)

import torch

x = torch.FloatTensor([[1,2,3],[4,5,6]])
x_stack = torch.stack([x,x,x,x],dim=0)
print(x_stack)
'''
tensor([[[1., 2., 3.],
         [4., 5., 6.]],

        [[1., 2., 3.],
         [4., 5., 6.]],

        [[1., 2., 3.],
         [4., 5., 6.]],

        [[1., 2., 3.],
         [4., 5., 6.]]])
'''

y_stack = torch.stack([x,x,x,x],dim=1)
print(y_stack)
'''
tensor([[[1., 2., 3.],
         [1., 2., 3.],
         [1., 2., 3.],
         [1., 2., 3.]],

        [[4., 5., 6.],
         [4., 5., 6.],
         [4., 5., 6.],
         [4., 5., 6.]]])
'''

#19. 하나의 텐서를 n개로 분해하기

import torch

z1 = torch.FloatTensor([
    [ 1.,  2.,  3.],
    [ 4.,  5.,  6.],
    [-1., -2., -3.],
    [-4., -5., -6.]
])
x_1,x_2 = torch.chunk(z1,2,dim=0)
print(x_1,x_2,sep='\n')
'''
tensor([[1., 2., 3.],
        [4., 5., 6.]])
tensor([[-1., -2., -3.],
        [-4., -5., -6.]])
'''

y_1,y_2 = torch.chunk(z1,2,dim=1)
print(y_1,y_2,sep='\n')
'''
tensor([[ 1.,  2.],
        [ 4.,  5.],
        [-1., -2.],
        [-4., -5.]])
tensor([[ 3.],
        [ 6.],
        [-3.],
        [-6.]])
'''

#20. 하나의 텐서를 분리하기

import torch

z1 = torch.FloatTensor([
    [ 1.,  2.,  3.],
    [ 4.,  5.,  6.],
    [-1., -2., -3.],
    [-4., -5., -6.]
])
x1,x2 = torch.split(z1,2,dim=0)
print(x1,x2,sep='\n')
'''
tensor([[1., 2., 3.],
        [4., 5., 6.]])
tensor([[-1., -2., -3.],
        [-4., -5., -6.]])
'''

y1,y2 = torch.split(z1,2,dim=1)
print(y1,y2,sep='\n')
'''
tensor([[ 1.,  2.],
        [ 4.,  5.],
        [-1., -2.],
        [-4., -5.]])
tensor([[ 3.],
        [ 6.],
        [-3.],
        [-6.]])
'''

y = torch.split(z1,2,dim=1)
for i in y:
    print(i)
'''
tensor([[ 1.,  2.],
        [ 4.,  5.],
        [-1., -2.],
        [-4., -5.]])
tensor([[ 3.],
        [ 6.],
        [-3.],
        [-6.]])
'''

#21. 1개 요소를 갖는 축 제거

import torch

x1 = torch.FloatTensor(10,1,3,1,4)
x2 = torch.squeeze(x1)
print(x1.size(),x2.size()) # torch.Size([10, 1, 3, 1, 4]) torch.Size([10, 3, 4])

#22. unsqueeze 연산

import torch

x1 = torch.FloatTensor(10,3,4)
x2 = torch.unsqueeze(x1, dim=0)
print(x1.size(),x2.size()) # torch.Size([10, 3, 4]) torch.Size([1, 10, 3, 4])

x3 = torch.unsqueeze(x1, dim=1)
print(x1.size(),x3.size()) # torch.Size([10, 3, 4]) torch.Size([10, 1, 3, 4])

#23. 다양한 분포를 갖는 텐서 만들기

import torch
import torch.nn.init as init

x1 = init.uniform_(torch.FloatTensor(3,4),a=0,b=9)
print(x1)

x2 = init.normal_(torch.FloatTensor(3,4),std=0.2)
print(x2)

x3 = init.constant_(torch.FloatTensor(3,4),3.1415926)
print(x3)

#24. 텐서간의 합

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = torch.FloatTensor([[1,2,3],[4,5,6]])

add1 = torch.add(x1,x2)
print(add1)

add2 = x1+x2
print(add2)

#25. 텐서의 브로드케스트 합

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = x1 + 10
print(x2)

#26. 텐서 요소간의 곱

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = torch.FloatTensor([[1,2,3],[4,5,6]])

x3 = torch.mul(x1,x2)
print(x3)
'''
tensor([[ 1.,  4.,  9.],
        [16., 25., 36.]])
'''

x4 = x1*x2
print(x4)
'''
tensor([[ 1.,  4.,  9.],
        [16., 25., 36.]])
'''

#27. 텐서 요소간의 나누기

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = torch.FloatTensor([[1,2,3],[4,5,6]])

x3 = torch.div(x1,x2)
print(x3)
'''
tensor([[1., 1., 1.],
        [1., 1., 1.]])
'''

x4 = x1/x2
print(x4)
'''
tensor([[1., 1., 1.],
        [1., 1., 1.]])
'''

#28. 텐서 요소의 제곱

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])

x2 = torch.pow(x1,2)
print(x2)
'''
tensor([[ 1.,  4.,  9.],
        [16., 25., 36.]])
'''

x3 = x1**2
print(x3)
'''
tensor([[ 1.,  4.,  9.],
        [16., 25., 36.]])
'''

#29. 텐서 요소의 지수 연산

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = torch.exp(x1)
print(x2)

#30. 텐서 요소의 로그 연산

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = torch.log(x1)
print(x2)

#31. 행렬곱

import torch

x1 = torch.FloatTensor([[1,2,3],[4,5,6]])
x2 = torch.FloatTensor([[1,2,3],[4,5,6],[7,8,9]])
x3 = torch.mm(x1,x2)
print(x3)
'''
tensor([[30., 36., 42.],
        [66., 81., 96.]])
'''

#32. 배치 행렬곱 연산(맨 앞에 batch 차원은 유지하면서 뒤에 요소들의 행렬곱)

import torch

x1 = torch.FloatTensor([
    [[1,2,3],[4,5,6]],
    [[1,2,3],[4,5,6]],
])
x2 = torch.FloatTensor([
    [[1,2,3],[4,5,6],[7,8,9]],
    [[1,2,3],[4,5,6],[7,8,9]],
])
x3 = torch.bmm(x1,x2)
print(x3)
'''
tensor([[[30., 36., 42.],
         [66., 81., 96.]],

        [[30., 36., 42.],
         [66., 81., 96.]]])
'''

#33. 벡터의 내적

import torch

x1 = torch.tensor([1,2,3,4])
x2 = torch.tensor([2,3,4,5])
x3 = torch.dot(x1,x2)
print(x3) # tensor(40)

#34. 텐서의 전치

import torch

x1 = torch.tensor([[1,2,3],[4,5,6],[7,8,9]])
print(x1)
x2 = x1.t()
print(x2)

#35. 텐서의 내부 차원 간 바꿈

import torch

hwc_img_data = torch.rand(100, 64, 32, 3)
print(hwc_img_data.size()) # torch.Size([100, 64, 32, 3])
chw_img_data = hwc_img_data.transpose(1,2)
print(chw_img_data.size()) # torch.Size([100, 32, 64, 3])
chw_img_data = chw_img_data.transpose(1,3)
print(chw_img_data.size()) # torch.Size([100, 3, 64, 32])

#36. 벡터의 내적, 행렬과 벡터의 곱, 행렬간 곱

import torch

m = torch.randn(100,10)
v = torch.randn(10)

d = torch.matmul(v,v) # = torch.dot, 벡터의 내적
print(d)

v2 = torch.matmul(m,v) # = torch.mv, 행렬과 벡터의 곱
print(v2)

m2 = torch.matmul(m.t(), m) # = torch.mm, 행렬 곱
print(m2)

#37. 다항분포 확률값 기반의 샘플링

import torch
 
x1 = torch.FloatTensor(
    [
        [1,2,3,4,5,6,7,8,9],
        [9,8,7,6,5,4,3,2,1],
        [1,2,3,4,5,6,7,8,9],
        [9,8,7,6,5,4,3,2,1]
    ]
)
i = torch.multinomial(x1.exp(), 1)
print(i)
'''
output:
tensor([[8],
        [0],
        [7],
        [1]])
'''

torch.multinomial 함수는 2개의 인자를 받는데, 첫번째 인자는 확률로 해석될 수 있는 텐서이고 두번째는 샘플링할 개수이다. 첫번째 인자는 확률로 해석할 수 있지만, 정규화될 필요는 없다. 여기서 정규화란 더해서 1이 되어야 한다는 의미이다. 결과에서 보면 알 수 있듯이 샘플링된 값의 인덱스 값이 반환된다.

#38. 상위 n개 가져오기

import torch
 
x = torch.rand(10)
print(x) # tensor([0.9097, 0.3766, 0.6321, 0.0760, 0.0137, 0.1760, 0.0655, 0.7696, 0.5172, 0.4140])

scores, indices = torch.topk(x, 3)

for i in range(0,3):
    print(indices[i].item(), scores[i].item())
'''output:
0 0.909696102142334
7 0.769554853439331
2 0.6320836544036865
'''