[DL] Convolution & Pooling Layer 구현해보기

이번에는 Convolution Layer, Pooling Layer를 한번 구현해 보겠습니다.

 

Convolution & Pooling Layer 구현해보기

4-Dimension Array (4차원 배열)

Convolution Neural Network(CNN)에서 Layer 사이를 흐르는 데이터는 4차원입니다.

• 예를 들어서 데이터의 형상이 (10, 1, 28, 28)이면?
• Height(높이): 28, Width(너비): 28, Channel(채널): 1개인 데이터가 10개라는 이야기 입니다.
• 이를 Python으로 구현하면 아래의 코드와 같습니다.

x = np.random.rand(10, 1, 28, 28) # 무작위로 데이터 생성
x[0, 0] # 또는 x[0][0] 첫번째 데이터의 첫 채널 공간 데이터에 접근

• 여기에서 10개의 데이터중 첫 번째 데이터에 접근하려면? 단순히 x[0]이라고 씁니다.
• Python의 index는 0부터 시작합니다. 마찬가지로 두 번째 데이터는 x[1] 위치에 있습니다.

x[0].shape # (1, 28, 28)
x[1].shape # (1, 28, 28)

• 또한 첫번째 데이터의 첫 채널의 공간 데이터에 접근하려면 다음과 같이 적습니다.

x[0, 0] # or x[0][0]

 

 

im2col로 데이터 전개하기

im2col은 Input Data(입력 데이터)를 filtering, 즉 Weight(가중치)계산을 하기 좋게 전개하는(펼치는) 함수입니다.

• 아래의 그림과 같이 3-Dimension Input Data에 im2col을 적용하면 2-Dimenion Array로 봐뀝니다.
  • 자세히는 Batch 안에 Data 수까지 포함한 4-Dimension Data를 2-Dimension으로 변환합니다.

대략적인 im2col의 동작

• im2col은 filtering 하기 좋게 데이터를 전개합니다.
• 구체적으로는 아래의 그림과 같이 입력 데이터에서 filter를 적용하는 영역(3-Dimension Block)을 한 줄로 늘여놓습니다.
• 이 전개에서 filter를 적용하는 모든 영역에서 수행하는게 im2col 입니다.

필터 적용 영역을 앞으로부터 순서대로 1줄로 펼친다.

• im2col로 Input Data를 전개한 다음에는 Convolution Layer의 filter(weight)를 1열로 전개하고, 두 Array의 곱을 계산하면 됩니다.
• 이는 Fully-Connected Layer (FC)의 Affine 계층에서 한 것과 거이 같습니다.

Convolution 연산의 filter 처리 상세 과정입니다.

• 위의 그림은 filter를 세로로 1열로 전개하고, im2col이 전개한 데이터와 행렬곱을 계산후, 출력 데이터를 변형(Reshape) 합니다.

 

Convoultional Layer (합성곱 계층) 구현하기

한번 Convoultional Layer (합성곱 계층)을 한번 구현해 보겠습니다.

• im2col 함수의 Interface는 다음과 같습니다.

im2col(input_data, filter_h, filter_w, stride=1, pad=0)

• input_data: (데이터 수, 채널 수, 높이, 너비)의 4차원 배열로 이뤄진 입력 데이터
• filter_h: 필터의 높이
• filter_w: 필터의 너비
• stride: 스트라이드
• pad: 패딩

 

• im2col은 '필터 크기, 'Stride', 'padding'을 고려하여 입력 데이터를 2-Dimension으로 전개합니다.

import sys, os
sys.path.append(os.pardir)
from common.util import im2col

x1 = np.random.rand(1, 3, 7, 7) # (데이터 수, 채널 수, 높이, 너비)
col1 = im2col(x1, 5, 5, stride=1, pad=0)
print(col1.shape) # (9, 75)

x2 = np.random.rand(10, 3, 7, 7) # 데이터 10개
col2 = im2col(x2, 5, 5, stride=1, pad=0)
print(col2.shape) # (90, 75)

• 여기서는 2가지의 예시를 보여줍니다. 하나(x1)는 Batch_size가 1(데이터 1개), Channel 3개, 높이 * 너비가 7 x 7의 데이터입니다.
• 다른 하나(x2)는 Batch_size가 10(데이터 10개)이고, 나머지는 첫번째(x1)과 같습니다.
• im2col 함수를 적용한 두 경우 모두 2-Dimension의 원소는 75입니다. 이 값은 filter의 원소 수와 같습니다. (Channel 3개, 5x5 데이터)
• 또한 Batch_size가 1일때 im2col의 결과의 크기가 (9, 75)이고, 10일 때에는 (90, 75) 크기의 데이터가 저장됩니다.
• 그러면 한번 im2col을 사용하여 Convolutional Layer를 한번 구현해 보겠습니다.

class Convolution:
    def __init__(self, W, b, stride=1, pad=0):
        # 초기화 메소드
        self.W = W  # W는 필터의 가중치, 4차원 배열: (필터 개수, 채널 수, 필터 높이, 필터 너비)
        self.b = b  # b는 필터의 편향, 1차원 배열: (필터 개수,)
        self.stride = stride  # stride는 필터를 적용하는 간격
        self.pad = pad  # pad는 입력 데이터 주변을 덧댄 0의 개수

    def forward(self, x):
        # 순전파 메소드
        FN, C, FH, FW = self.W.shape  # FN: 필터 개수, C: 채널 수, FH: 필터 높이, FW: 필터 너비
        N, C, H, W = x.shape  # N: 데이터 개수, C: 채널 수, H: 높이, W: 너비
        out_h = int(1 + (H + 2*self.pad - FH) / self.stride)  # 출력 데이터의 높이 계산
        out_w = int(1 + (W + 2*self.pad - FW) / self.stride)  # 출력 데이터의 너비 계산
        
        # 입력 데이터와 필터를 2차원 배열로 전개하고 내적함
        col = im2col(x, FH, FW, self.stride, self.pad)  # im2col 함수는 입력 데이터를 필터링하기 좋은 형태로 변환
        col_W = self.W.reshape(FN, -1).T  # 필터의 가중치를 2차원 배열로 변환 후 전치
        out = np.dot(col, col_W) + self.b  # 변환된 입력 데이터와 필터 가중치의 내적을 계산하고 편향을 더함
        
        # 결과를 적절히 변형하여 출력 형태로 조정
        # reshape에서 -1은 원소의 개수에 맞춰 자동으로 크기를 설정
        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)
        # transpose를 사용하여 축의 순서를 변경 (배치 크기, 필터 개수, 높이, 너비 순으로 조정)
        
        return out

• Convolutional Layer는 filter(Weight), Bias(편향), Stride, Padding을 인수로 받아서 초기화합니다.
• filter는 (FN, C, FH, FW)의 4-Dimension의 형상입니다. FN은 filter 개수, C는 Channel, FH는 필터 높이, FW는 필터 너비 입니다.

 

Pooling Layer 구현하기

Pooling Layer 구현도 Convolutional Layer와 마찬가지로 im2col을 사용해 입력 데이터를 전개합니다.

• 단, Pooling의 경우엔 Channel 쪽이 독립적이라는 점이 Convolutional Layer때와는 다릅니다.
• 구체적으로는 아래의 그림과 같이 Pooling 적용 영역을 채널마다 독립적으로 전개합니다.

Input data에 Pooling 적용 영역을 전개 (2x2 Pooling의 예)

• 이렇게 전개를 하고, 전개한 행렬에서 행 별 최대값을 구하고 적절한 형상으로 성형하기만 하면 됩니다.

Pooling Layer 구현의 흐름, Pooling 적용 영역에서 가장 큰 원소는 회색으로 표시

• 이것이 Pooling Layer의 forward 처리 흐름입니다. 이걸 Python Code로 한번 구현해 보겠습니다.

class Pooling:
    def __init__(self, pool_h, pool_w, stride=1, pad=0):
        # 초기화 메소드
        self.pool_h = pool_h  # 풀링 윈도우의 높이
        self.pool_w = pool_w  # 풀링 윈도우의 너비
        self.stride = stride  # 풀링을 적용하는 간격
        self.pad = pad        # 입력 데이터 주변을 덧댄 0의 개수

    def forward(self, x):
        # 순전파 메소드
        N, C, H, W = x.shape  # N: 데이터 개수, C: 채널 수, H: 높이, W: 너비
        out_h = int(1 + (H - self.pool_h) / self.stride)  # 출력 데이터의 높이 계산
        out_w = int(1 + (W - self.pool_w) / self.stride)  # 출력 데이터의 너비 계산
        
        # 입력 데이터를 풀링에 적합한 형태로 전개
        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)  # 입력 데이터를 필터링하기 좋은 형태로 변환
        col = col.reshape(-1, self.pool_h * self.pool_w)  # 각 풀링 영역을 행으로 변형

        # 최댓값 연산
        out = np.max(col, axis=1)  # 각 풀링 윈도우 내의 최대값을 찾음

        # 결과를 적절히 변형하여 출력 형태로 조정
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)
        # transpose를 사용하여 축의 순서를 변경 (배치 크기, 채널 수, 높이, 너비 순으로 조정)

        return out

• Pooling Layer 구현은 3단계로 구성됩니다.

1. 입력 데이터를 전개한다.
2. 행렬 최대값을 구한다.
3. 적절한 모양으로 성형한다.

• 이러한 과정으로 Pooling Layer의 forward 처리가 구현됩니다.

---

Convolution Neural Network (CNN) 구현하기

Convolutional Layer & Pooling Layer를 구현했으니, 이 Layer들을 조합하여 손글씨 숫자를 인식하는 CNN을 한번 만들어 보겠습니다.

• 이번에는 이러한 구조로 CNN을 한번 구현해 보겠습니다.

단순한 CNN 네트워크의 구성

• 이 CNN Network는 "Convoultion-ReLU-Pooling-Affine-ReLU-Affine-Softmax" 순으로 흐릅니다.
• 초기화때의 인수는 다음 인수들을 받습니다.

 

• input_dim: 입력 데이터(채널 수, 높이, 너비)의 차원
• conv_param: 합성곱 계층의 하이퍼파라미터(딕셔너리)
  • filter_num: 필터 수
    • filter_size: 필터 크기
    • stride: 스트라이드
    • pad: 패딩
• hidden_size: 은닉층(완전연결)의 뉴런 수
• output_size: 출력층(완전연결)의 뉴런 수
• weight_init_std: 초기화 때의 가중치 표준편차

 

여기서 Convolutional Layer의 Hyperparameter는 Dictionary 형태로 주어집니다 (conv_param).

• 이것은 필요한 Hyperparameter의 값이 ['filter_num':30, 'filter_size':5, 'pad':0, 'stride': 1] 처럼 저장된다는 뜻입니다.
• 한번 코드를 설명드릴건데, 좀 길이가 길어서 3부분으로 나눠서 설명하겠습니다.

class SimpleConvNet:
    def __init__(self, input_dim=(1, 28, 28), 
                 conv_param={'filter_num': 30, 'filter_size': 5, 'pad': 0, 'stride': 1},
                 hidden_size=100, output_size=10, weight_init_std=0.01):
        # 합성곱 계층의 파라미터
        filter_num = conv_param['filter_num']  # 필터의 수
        filter_size = conv_param['filter_size']  # 각 필터의 크기
        filter_pad = conv_param['pad']  # 이미지 주변의 패딩
        filter_stride = conv_param['stride']  # 필터의 스트라이드
        input_size = input_dim[1]  # 입력 이미지 크기 (정사각형이라고 가정)

        # 합성곱 계층의 출력 크기를 계산
        conv_output_size = (input_size - filter_size + 2 * filter_pad) / filter_stride + 1
        conv_output_size = int(conv_output_size)
        
        # 풀링 계층을 가정하여 2x2 풀링 크기와 스트라이드 2를 사용
        # 이 경우 각 차원을 절반으로 줄임
        pool_output_size = int(filter_num * (conv_output_size / 2) * (conv_output_size / 2))
        
        # 네트워크 가중치 초기화
        self.params = {}

• 초기화 인수(_init_)으로 주어진 Convolutional Layer의 Parameter를 Dictionary에서 꺼내고, 출력 크기를 계산합니다.

 

self.params = {}
# 첫 번째 합성곱 계층의 가중치 초기화
self.params['W1'] = weight_init_std * np.random.randn(filter_num, input_dim[0], filter_size, filter_size)
# filter_num: 필터의 개수, input_dim[0]: 입력 채널 수 (예: 흑백 이미지는 1, 컬러는 3)
# filter_size: 필터의 높이와 너비
# np.random.randn은 정규분포를 따르는 난수를 생성, weight_init_std는 이 난수의 표준편차를 조절

self.params['b1'] = np.zeros(filter_num)
# 첫 번째 합성곱 계층의 편향 초기화
# 필터마다 하나의 편향 값을 갖으며, 모든 편향을 0으로 초기화

# 두 번째 계층 (완전 연결 계층)의 가중치 초기화
self.params['W2'] = weight_init_std * np.random.randn(pool_output_size, hidden_size)
# pool_output_size: 풀링 계층 출력의 크기 (필터 수 * 감소된 높이 * 감소된 너비)
# hidden_size: 은닉층의 뉴런 수

self.params['b2'] = np.zeros(hidden_size)
# 두 번째 계층의 편향 초기화
# 은닉층의 뉴런 수만큼 편향을 0으로 초기화

# 세 번째 계층 (출력 계층)의 가중치 초기화
self.params['W3'] = weight_init_std * np.random.randn(hidden_size, output_size)
# hidden_size: 은닉층의 뉴런 수
# output_size: 출력층의 뉴런 수, 즉 분류하고자 하는 클래스 수

self.params['b3'] = np.zeros(output_size)
# 세 번째 계층의 편향 초기화
# 출력층의 뉴런 수만큼 편향을 0으로 초기화

• 위의 코드는 Weight Parameter(가중치 매개변수)를 초기화 하는 부분입니다.

 

self.layers = OrderedDict()
# 순서가 중요한 계층들을 관리하기 위해 OrderedDict을 사용하여 계층들을 저장

# 첫 번째 합성곱 계층
self.layers['Conv1'] = Convolution(self.params['W1'], self.params['b1'],
                                   conv_param['stride'], conv_param['pad'])
# Convolution 클래스의 인스턴스를 생성, 필터 가중치와 편향, 스트라이드, 패딩 정보를 전달

# 첫 번째 활성화 함수: ReLU
self.layers['Relu1'] = Relu()
# ReLU(Rectified Linear Unit) 활성화 함수, 음수를 0으로 처리하여 비선형성 추가

# 첫 번째 풀링 계층
self.layers['Pool1'] = Pooling(pool_h=2, pool_w=2, stride=2)
# Pooling 클래스의 인스턴스를 생성, 2x2 크기의 풀링 윈도우와 스트라이드 2를 설정

# 첫 번째 완전 연결 계층
self.layers['Affine1'] = Affine(self.params['W2'], self.params['b2'])
# Affine 계층 (또는 완전 연결 계층), 가중치와 편향을 전달

# 두 번째 활성화 함수: ReLU
self.layers['Relu2'] = Relu()
# 두 번째 ReLU 활성화 함수 인스턴스

# 두 번째 완전 연결 계층
self.layers['Affine2'] = Affine(self.params['W3'], self.params['b3'])
# 두 번째 Affine 계층, 출력층으로 연결되기 전의 마지막 은닉층

# 손실 계층: Softmax-with-Loss
self.last_layer = SoftmaxWithLoss()
# SoftmaxWithLoss 클래스의 인스턴스, 분류 문제에서 출력층의 손실 함수 및 출력 확률을 계산

• 순서가 있는 Dictionary (OrderedDict)인 Layer에 계층들을 차례로 추가합니다.
• 마지막으로 SoftmaxWithLoss 계층 만큼 last_alyer라는 별도 변수에 저장해둡니다.

 

• 이렇게 SimpleConvNet을 초기화를 하고, 추론을 수행하는 Predict, Loss 함수의 값을 구하는 Loss Method를 구현해 보겠습니다.

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        return x

    def loss(self, x, t):
        # x: 입력 데이터
        # t: 정답 레이블
        y = self.predict(x)
        return self.last_layer.forward(y, t)

 

• 그리고 Backpropagation(오차역전파법)으로 Gradient(기울기)를 구하는 구현은 다음과 같습니다.

def gradient(self, x, t):
    """
    각 층의 기울기를 담은 사전(dictionary) 변수
    grads['W1'], grads['W2'], ... 각 층의 가중치
    grads['b1'], grads['b2'], ... 각 층의 편향
    """
    # 순전파
    self.loss(x, t)
    # loss 메소드를 통해 순전파를 진행하고, 손실을 계산합니다. 이는 역전파의 시작점에서 사용됩니다.

    # 역전파
    dout = 1
    dout = self.last_layer.backward(dout)
    # 마지막 손실 계층에서 시작하여 기울기를 계산합니다. 이 초기 기울기는 1로 설정됩니다.

    layers = list(self.layers.values())
    layers.reverse()
    # 네트워크의 계층을 역순으로 정렬합니다. 역전파는 출력층에서 입력층 순으로 진행되어야 하기 때문입니다.

    for layer in layers:
        dout = layer.backward(dout)
    # 각 계층에 대해 역전파를 순차적으로 실행합니다. 이 과정에서 각 계층의 파라미터에 대한 기울기가 계산됩니다.

    # 결과 저장
    grads = {}
    grads['W1'], grads['b1'] = self.layers['Conv1'].dW, self.layers['Conv1'].db
    grads['W2'], grads['b2'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
    grads['W3'], grads['b3'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
    # 계산된 기울기를 grads 사전에 저장합니다. 각 계층의 가중치와 편향에 대한 기울기를 각각 저장합니다.

    return grads

• Backpropagation(오차역전파법)으로 Gradient(기울기)를 구하는 과정에서, Forward Propagation(순전파) & Back Propagation(역전파)를 반복합니다.
• 마지막으로 grads라는 Dictionary 변수에 각 Weight Parameter의 Gradient를 저장합니다.
• 이것이 SimpleConvNet의 구현입니다.

---

CNN 시각화하기

합성곱 계층을 시각화 해서 CNN이 무엇을 보고 있는것이 무엇인지 알아보도록 하겠습니다.

• 이 코드는 학습 전과 후의 Weight(가중치)를 비교해 보는 코드입니다.
• 결과는 아래의 사진에 나옵니다.

# coding: utf-8
import numpy as np
import matplotlib.pyplot as plt
from simple_convnet import SimpleConvNet

def filter_show(filters, nx=8, margin=3, scale=10):
    """
    c.f. https://gist.github.com/aidiary/07d530d5e08011832b12#file-draw_weight-py
    """
    FN, C, FH, FW = filters.shape
    ny = int(np.ceil(FN / nx))

    fig = plt.figure()
    fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=0.05, wspace=0.05)

    for i in range(FN):
        ax = fig.add_subplot(ny, nx, i+1, xticks=[], yticks=[])
        ax.imshow(filters[i, 0], cmap=plt.cm.gray_r, interpolation='nearest')
    plt.show()


network = SimpleConvNet()
# 무작위(랜덤) 초기화 후의 가중치
filter_show(network.params['W1'])

# 학습된 가중치
network.load_params("params.pkl")
filter_show(network.params['W1'])

학습 전과 후의 1번쨰 Layer의 합성곱 Layer의 Weight(가중치)

• Weight의 원소는 실수이지만, 이미지에서는 가장 작은 값은 검은색(0), 가장큰 값은(255)은 흰색으로 정규화 합니다.
• 학습 전 필터는 무작위로 규칙성이 없지만 학습을 마친 필터는 줄무늬, 덩어리 등 규칙을 띕니다.
• 이러한 필터는 에지(색상이 바뀐 경계), 블롭blob(국소적으로 덩어리진 영역) 등을 인식합니다.

가로, 세로 에지에 반응하는 필터

• 출력 이미지 1은 세로 에지에 흰 픽셀이 나타나고, 출력 이미지 2는 가로 에지에 흰 픽셀이 많이 나옵니다.
• 이건 학습된 filter 2개를 선택하여 입력 이미지에 합성곱 처리를 한 결과입니다.
• 'filter 1'은 세로 에지에, 'filter 2'는 가로 에지에 반응을 합니다.
• 이처럼 합성곱 필터는 에지와 블롭등의 원시적인 정보를 추출할 수 있습니다.

 

Layer 깊이에 따른 추출 정보의 변화

Layer(계층)이 더 깊어질수록 추출되는 정보 (정확히는 강하게 반응하는 뉴런)은 더 추상화 된다는 것을 알 수 있습니다.

• 1번째 층의 합성곱 계층망에서는 에지나 블롭 등의 저수준 정보가 추출되고 계층이 깊어질수록 추출되는 정보는 더 추상화됩니다.
  • (에지 -> 텍스처 -> 사물의 일부 등)
• 합성곱 & Pooling 계층을 여러겹 쌓고, 마지막으로 Fully-Connected Layer(FC)를 거쳐 출력하는 구조입니다.

CNN의 합성곱 계층에서 추출되는 정보.

• 첫번째 층은 에지 & 블롭, 3번째 층은 텍스처, 5번째 층은 사물의 일부, 마지막 Fully-Connected Layer(FC)는 사물의 Class에 뉴런이 반응합니다.