CNN with pytorch

CNN

CNN은 아래 사진 처럼 convolution 과정과 Pooling 과정을 반복 한후 Fully connected layer를 통해서 데이터를 출력 합니다.

pytorch에서 conolution과 pooling 과정을 어떻게 적용하는지 알아보겠습니다.

 

Convolution Layers

pytorch에서는 Convolutoin연산을 위해 Conv2d를 많이 사용합니다.
Conv2d의 파라미터에대해 알아 보겠습니다.

Parameters

• in_channels (int) : input 이미지 채널 수
• out_channels (int) : ouput 데이터의 채널 수
• kernel_size (int or tuple) : kenrl의 사이즈
• stride (int or tuple, optional) : Stride의 사이즈
• padding (int, tuple or str, optional) : padding 사이즈
• padding_mode (string, optional) : 다음 중 panddind mode 설정 'zeros', 'reflect', 'replicate' or 'circular'
• dilation (int or tuple, optional) – 커널 간격의 사이즈
• groups (int, optional) – 입력 층의 그룹 수
• bias (bool, optional) – bias를 사용할지 말지 결정하는 파라미터

입출력 shpae

• input($N, C_{in},H_{in},W_{in}$)
  • N : batch size
  • $C_{in}$ : input 데이터의 channel
  • $H_{in}$ : input 데이터의 높이
  • $W_{in}$ : input 데이터의 넓이
• output($N, C_{out},H_{out},W{out})
  • N : batch size
  • $C_{out}$ : output 데이터의 channel
  • $H_{out}$ : $\frac{H_{in} + 2 * padding[0] - dilation[0] * (kernel_size[0] - 1)}{stride[0]}+ 1$
  • $W_{out}$ : $\frac{W_{in} + 2 * padding[1] - dilation[1] * (kernel_size[1] - 1)}{stride[1]}+ 1$

code

import torch
import torch.nn as nn
import torch.nn.functional as F

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels = 1, out_channels = 10, kernel_size = 5, stride = 1)            
        self.conv2 = nn.Conv2d(in_channels = 10, out_channels = 20, kernel_size = 5, stride = 1)            
        self.fc_layer = nn.Linear(20 * 12 * 12, 10)


    def forward(self, x):
        print("연산 전", x.size())

        x = F.relu(self.conv1(x))
        print("conv1 연산 후", x.size())

        x = F.relu(self.conv2(x))        
        print("conv2 연산 후",x.size())

        x = x.view(-1, 20 * 12 * 12)
        print("flatten 이후 ", x.size())

        x = F.relu(self.fc_layer(x))
        print("fc_layer 연산 후", x.size())

        return x
cnn  = CNN()
output = cnn(torch.randn(10, 1, 20, 20))

연산 전 torch.Size([10, 1, 20, 20])
conv1 연산 후 torch.Size([10, 10, 16, 16])
conv2 연산 후 torch.Size([10, 20, 12, 12])
flatten 이후  torch.Size([10, 2880])
fc_layer 연산 후 torch.Size([10, 10])

 

Poling Layers

Pooling 연산을 위해서는 pytorch의 MaxPoold2d 활용하면 됩니다.

parameters

• kernel_size : 커널 사이즈
• stride – stride 사이즈
• padding – zero padding 을 적용 할 사이즈
• dilation – 커널 사이 간격 사이즈
• return_indices – True일 경우 최대 인덱스를 반환
• ceil_mode : True 일 경우, output size에 대하여 ceil 함수 적용

입출력 Shape

• input: ($N, C, H_{in}, W_{in}) or ($C, H_{in}, W_{in})
  • N : batch size
  • $C_{in}$ : input 데이터의 channel
  • $H_{in}$ : input 데이터의 높이
  • $W_{in}$ : input 데이터의 넓이
• output: ($N, C, H_{out}, W_{out}) or ($C, H_{out}, W_{out})
  • N : batch size
  • $C_{out}$ : output 데이터의 channel
  • $H_{out}$ : $\frac{H_{in} + 2 * padding[0] - dilation[0] * (kernel_size[0] - 1)}{stride[0]}+ 1$
  • $W_{out}$ : $\frac{W_{in} + 2 * padding[1] - dilation[1] * (kernel_size[1] - 1)}{stride[1]}+ 1$

code

import torch
import torch.nn as nn
import torch.nn.functional as F

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels = 1, out_channels = 10, kernel_size = 5, stride = 1)            
        self.conv2 = nn.Conv2d(in_channels = 10, out_channels = 20, kernel_size = 5, stride = 1)            
        self.m = nn.MaxPool2d(2, stride = 2)
        self.fc_layer = nn.Linear(20 * 6 * 6, 10)


    def forward(self, x):
        print("연산 전", x.size())

        x = F.relu(self.conv1(x))
        print("conv1 연산 후", x.size())

        x = F.relu(self.conv2(x))        
        print("conv2 연산 후",x.size())

        x = F.relu(self.m(x))
        print("maxpooling 연산 후",x.size())

        x = x.view(-1, 20 * 6 * 6)
        print("flatten 이후 ", x.size())

        x = F.relu(self.fc_layer(x))
        print("fc_layer 연산 후", x.size())

        return x
cnn  = CNN()
output = cnn(torch.randn(10, 1, 20, 20))

연산 전 torch.Size([10, 1, 20, 20])
conv1 연산 후 torch.Size([10, 10, 16, 16])
conv2 연산 후 torch.Size([10, 20, 12, 12])
maxpooling 연산 후 torch.Size([10, 20, 6, 6])
flatten 이후  torch.Size([10, 720])
fc_layer 연산 후 torch.Size([10, 10])

Refrenect

• https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html
• https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html