[파이토치로 시작하는 딥러닝 기초]10.1_Convolutional Neural Network

10. Convolution Neural Network

 

10.1 Convolution

• Convolution?
• Neuron과 Convolution
• Pooling

Convolution이란?

• 이미지위에서 stride값 만큼 filter(kernel)을 이동시키면서 겹쳐지는 부분의 각 원소의 값을 곱해서 모두 더한 값을 출력으로 하는 연산

Stride and Padding

• stride : filter를 한번에 얼마나 이동할 것인가
• padding : zero-padding (input 이미지의 상하좌우에 0의 띠가 둘러진다)

Python nn.Conv2d

입력의 형태

• input type: torch.Tensor 타입
• input shape : (N * C * H * W) => (batch_size, channel, height, width)

Convolution 의 output 크기

$${Output \space size = \frac{input \space size - filter \space size + (2 * padding)}{Stride} + 1}$$

 

실습

import torch
import torch.nn as nn

conv = nn.Conv2d(1, 1, 11, stride = 4, padding = 0)
conv

>>>
Conv2d(1, 1, kernel_size=(11, 11), stride=(4, 4))

inputs = torch.Tensor(1, 1, 227, 227)
inputs.shape

>>>
torch.Size([1, 1, 227, 227])

out = conv(inputs)
out.shape

>>>
torch.Size([1, 1, 55, 55])

Neuron과 Convolution

Perceptron과 ConVolution

Pooling

• 이미지의 사이즈를 줄이기 위해서 사용되기도 함
• fully connected 연산을 대체하기 위해서 Avarage Pooling을 사용하는 경우도 있음

CNN implementation 실습

inputs = torch.Tensor(1, 1, 28, 28)
conv1 = nn.Conv2d(1, 5, 5)
pool = nn.MaxPool2d(2)
out = conv1(inputs)
out2 = pool(out)

print("out size : ", out.size()) 
print("out2 size : ", out2.size())

>>>
out size :  torch.Size([1, 5, 24, 24])
out2 size :  torch.Size([1, 5, 12, 12])

MNIST에 CNN 적용하기

학습단계(Code 기준)

1. 라이브러리 가져오고(torch, torchvision, matplotlib 같은 것들)
2. GPU 사용 설정하고 random value를 위한 seed 설정!
3. 학습에 사용되는 parameter 설정(learning_rate, training_epochs, batch_size, etc)
4. 데이터 셋을 가져오고(학습에 쓰기 편하게) loader 만들기
5. 학습 모델 만들기(class CNN(torch.nn.Module)
6. Loss function(criterion)을 선택하고 최적화 도구 선택(optimizer)
7. 모델 학습 및 loss check(Criterion의 output)
8. 학습된 모델의 성능을 확인한다.

## 1. library를 가져오고
import torch
import torch.nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms

import torch.nn.init

## 2. GPU 사용 설정하고
device = 'cuda' if torch.cuda.is_available() else 'cpu'

torch.manual_seed(777)
if device == 'cuda':
    torch.cuda.manual_seed_all(777)

## 3. 학습에 사용되는 parameter 설정
learning_rate = 0.001
training_epochs = 15
batch_size = 100

## 4. dataset을 가져오고
mnist_train = dsets.MNIST(root = 'MNIST_data/',
                          train = True,
                          transform = transforms.ToTensor(),
                          download = True)
mnist_test = dsets.MNIST(root = 'MNIST_data/',
                         train = False,
                         transform = transforms.ToTensor(),
                         download = True)

data_loader = torch.utils.data.DataLoader(dataset = mnist_train,
                                          batch_size = batch_size, 
                                          shuffle = True,
                                          drop_last = True)

## 5. 모델 만들기
class CNN(nn.Module):
    
    def __init__(self):
        super(CNN, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        
        self.layer2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size = 3, stride = 1, padding = 1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        
        self.fc = nn.Linear(7*7*64, 10, bias = True)
        torch.nn.init.xavier_uniform_(self.fc.weight)
        
    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        
        return out

## 6. loss function 과 최적화 도구 선택
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)

## 7. training
total_batch = len(data_loader)
print('Learning Started.')

for epoch in range(training_epochs):
    avg_cost = 0
    
    for X, Y in data_loader:
        X = X.to(device)
        Y = Y.to(device)
        
        optimizer.zero_grad()
        hypothesis = model(X)
        
        cost = criterion(hypothesis, Y)
        cost.backward()
        optimizer.step()
        
        avg_cost += cost / total_batch
        
    print('[Epoch : {}] cost = {}'.format(epoch + 1, avg_cost))

print('learning Finished!!')

>>>
Learning Started.
[Epoch : 1] cost = 0.2222660630941391
[Epoch : 2] cost = 0.0628141239285469
[Epoch : 3] cost = 0.04567364975810051
[Epoch : 4] cost = 0.03739927336573601
[Epoch : 5] cost = 0.03022618591785431
[Epoch : 6] cost = 0.02474653162062168
[Epoch : 7] cost = 0.020215149968862534
[Epoch : 8] cost = 0.018039338290691376
[Epoch : 9] cost = 0.015427193604409695
[Epoch : 10] cost = 0.012006986886262894
[Epoch : 11] cost = 0.010384107939898968
[Epoch : 12] cost = 0.009809502400457859
[Epoch : 13] cost = 0.008090809918940067
[Epoch : 14] cost = 0.007567755412310362
[Epoch : 15] cost = 0.004932000767439604
learning Finished!!

with torch.no_grad(): ## 학습을 안하니까 no_grad()
    X_test = mnist_test.test_data.view(len(mnist_test), 1, 28, 28).float().to(device)
    Y_test = mnist_test.test_labels.to(device)
    
    prediction = model(X_test)
    correct_prediction = torch.argmax(prediction, 1) == Y_test
    accuracy = correct_prediction.float().mean()
    print('Accuracy : ', accuracy.item())
    
>>>
Accuracy :  0.9876999855041504