딥러닝 - 더 깊게

더 깊은 신경망으로

• 아래 그림과 같은 신경망 구현

손글씨 숫자를 인식하는 심층 CNN

[그림1] 손글씨 숫자를 인식하는 심층 CNN

 

• 3X3 크기의 작은 필터로, 층이 깊어지면서 채널 수가 더 늘어나는 것이 특징이다.(합성곱 계층의 채널 수는 앞 계층에서부터 순서대로 16, 16, 32, 32, 64, 64로 늘어간다.) 
• 그림과 같이 풀링 계층을 추가해 중간 데이터의 공간 크기를 점차 줄여간다.
• 마지막 단의 완전연결 계층에서는 드롭아웃 계층을 사용한다.

 

위의 신경망 특징

• 3x3의 작은 필터를 사용한 합성곱 계층
• 활성화 함수는 ReLU
• 완전연결 계층 뒤에 드롭아웃 계층 사용
• Adam을 사용해 최적화
• 가중치 초깃값은 'He의 초깃값'
• 신경망 정확도는 99.38%

학습된 가중치 매개변수

import sys, os
sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import pickle
import numpy as np
from collections import OrderedDict
from layer import *


class DeepConvNet:
    """정확도 99% 이상의 고정밀 합성곱 신경망
    네트워크 구성은 아래와 같음
        conv - relu - conv- relu - pool -
        conv - relu - conv- relu - pool -
        conv - relu - conv- relu - pool -
        affine - relu - dropout - affine - dropout - softmax
    """
    def __init__(self, input_dim=(1, 28, 28),
                 conv_param_1 = {'filter_num':16, 'filter_size':3, 'pad':1, 'stride':1},
                 conv_param_2 = {'filter_num':16, 'filter_size':3, 'pad':1, 'stride':1},
                 conv_param_3 = {'filter_num':32, 'filter_size':3, 'pad':1, 'stride':1},
                 conv_param_4 = {'filter_num':32, 'filter_size':3, 'pad':2, 'stride':1},
                 conv_param_5 = {'filter_num':64, 'filter_size':3, 'pad':1, 'stride':1},
                 conv_param_6 = {'filter_num':64, 'filter_size':3, 'pad':1, 'stride':1},
                 hidden_size=50, output_size=10):
        # 가중치 초기화===========
        # 각 층의 뉴런 하나당 앞 층의 몇 개 뉴런과 연결되는가（TODO: 자동 계산되게 바꿀 것）
        pre_node_nums = np.array([1*3*3, 16*3*3, 16*3*3, 32*3*3, 32*3*3, 64*3*3, 64*4*4, hidden_size])
        wight_init_scales = np.sqrt(2.0 / pre_node_nums)  # ReLU를 사용할 때의 권장 초깃값
        
        self.params = {}
        pre_channel_num = input_dim[0]
        for idx, conv_param in enumerate([conv_param_1, conv_param_2, conv_param_3, conv_param_4, conv_param_5, conv_param_6]):
            self.params['W' + str(idx+1)] = wight_init_scales[idx] * np.random.randn(conv_param['filter_num'], pre_channel_num, conv_param['filter_size'], conv_param['filter_size'])
            self.params['b' + str(idx+1)] = np.zeros(conv_param['filter_num'])
            pre_channel_num = conv_param['filter_num']
        self.params['W7'] = wight_init_scales[6] * np.random.randn(64*4*4, hidden_size)
        self.params['b7'] = np.zeros(hidden_size)
        self.params['W8'] = wight_init_scales[7] * np.random.randn(hidden_size, output_size)
        self.params['b8'] = np.zeros(output_size)

        # 계층 생성===========
        self.layers = []
        self.layers.append(Convolution(self.params['W1'], self.params['b1'], 
                           conv_param_1['stride'], conv_param_1['pad']))
        self.layers.append(Relu())
        self.layers.append(Convolution(self.params['W2'], self.params['b2'], 
                           conv_param_2['stride'], conv_param_2['pad']))
        self.layers.append(Relu())
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
        self.layers.append(Convolution(self.params['W3'], self.params['b3'], 
                           conv_param_3['stride'], conv_param_3['pad']))
        self.layers.append(Relu())
        self.layers.append(Convolution(self.params['W4'], self.params['b4'],
                           conv_param_4['stride'], conv_param_4['pad']))
        self.layers.append(Relu())
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
        self.layers.append(Convolution(self.params['W5'], self.params['b5'],
                           conv_param_5['stride'], conv_param_5['pad']))
        self.layers.append(Relu())
        self.layers.append(Convolution(self.params['W6'], self.params['b6'],
                           conv_param_6['stride'], conv_param_6['pad']))
        self.layers.append(Relu())
        self.layers.append(Pooling(pool_h=2, pool_w=2, stride=2))
        self.layers.append(Affine(self.params['W7'], self.params['b7']))
        self.layers.append(Relu())
        self.layers.append(Dropout(0.5))
        self.layers.append(Affine(self.params['W8'], self.params['b8']))
        self.layers.append(Dropout(0.5))
        
        self.last_layer = SoftmaxWithLoss()

    def predict(self, x, train_flg=False):
        for layer in self.layers:
            if isinstance(layer, Dropout):
                x = layer.forward(x, train_flg)
            else:
                x = layer.forward(x)
        return x

    def loss(self, x, t):
        y = self.predict(x, train_flg=True)
        return self.last_layer.forward(y, t)

    def accuracy(self, x, t, batch_size=100):
        if t.ndim != 1 : t = np.argmax(t, axis=1)

        acc = 0.0

        for i in range(int(x.shape[0] / batch_size)):
            tx = x[i*batch_size:(i+1)*batch_size]
            tt = t[i*batch_size:(i+1)*batch_size]
            y = self.predict(tx, train_flg=False)
            y = np.argmax(y, axis=1)
            acc += np.sum(y == tt)

        return acc / x.shape[0]

    def gradient(self, x, t):
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.last_layer.backward(dout)

        tmp_layers = self.layers.copy()
        tmp_layers.reverse()
        for layer in tmp_layers:
            dout = layer.backward(dout)

        # 결과 저장
        grads = {}
        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18)):
            grads['W' + str(i+1)] = self.layers[layer_idx].dW
            grads['b' + str(i+1)] = self.layers[layer_idx].db

        return grads

    def save_params(self, file_name="params.pkl"):
        params = {}
        for key, val in self.params.items():
            params[key] = val
        with open(file_name, 'wb') as f:
            pickle.dump(params, f)

    def load_params(self, file_name="params.pkl"):
        with open(file_name, 'rb') as f:
            params = pickle.load(f)
        for key, val in params.items():
            self.params[key] = val

        for i, layer_idx in enumerate((0, 2, 5, 7, 10, 12, 15, 18)):
            self.layers[layer_idx].W = self.params['W' + str(i+1)]
            self.layers[layer_idx].b = self.params['b' + str(i+1)]

 

훈련용 코드

# 훈련용 코드
import sys, os
sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from mnist import load_mnist
from deep_convnet import DeepConvNet
from trainer import Trainer

(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)

network = DeepConvNet()  
trainer = Trainer(network, x_train, t_train, x_test, t_test,
                  epochs=20, mini_batch_size=100,
                  optimizer='Adam', optimizer_param={'lr':0.001},
                  evaluate_sample_num_per_epoch=1000)
trainer.train()

# 매개변수 보관
network.save_params("deep_convnet_params.pkl")
print("Saved Network Parameters!")

 

[그림2] 인식하지 못한 이미지들

• 사람도 판단하기 어려운 이미지다. - 그만큼 이 심층 CNN 정확도가 높다는 의미

 

정확도를 높이려면

• <What is the class of this image?> 웹사이트는 다양한 데이터셋을 대상으로 그동안 논문 등에서 발표한 기법들의 정확도 순위를 정리해두었다.

 

MNIST 데이터셋에 대한 각 기법의 순위(2020년 12월 시점)

[그림3] MNIST 데이터셋에 대한 각 기법의 순위(2020년 12월 시점)

• 상위권은 대부분 CNN 기초 한 기법  1위 오류율 0.21% CNN을 기초로 했다.
• 이 목록에서의 CNN들은 그다지 깊은 심층망이 아니다. (합성곱 계층 2개에 완전연결 계층 2개 정도인 신경망)
• 앙상블 학습, 학습률 감소, 데이터 확장 등이 정확도 향상에 공헌하고 있다.
• 데이터 확장은 손쉬운 방법이면서도 정확도 개선에 효과적이다.

 

 

데이터 확장(data augmentation)

• 입력 이미지(훈련 이미지)를 알고리즘을 동원해 '인위적'으로 확장한다.
• 아래 그림과 같이 입력 이미지를 회전하거나 세로로 이동하는 등 미세한 변화를 주어 미이지의 개수를 늘리는 것이다. 
• 데이터가 얼마 없을 경우 효과적인 수단

 

데이터 확장의 예

[그림4] 데이터 확장의 예

crop

• 이미지 일부를 잘라낸다.

filp

• 이미지 좌우를 뒤집는다.

스케일 변화

• 일반적 이미지에서 밝기 등의 외형 변화나 확대 · 축소 등

 

깊게 하는 이유

• 현재까지 알려진 층을 깊게 하는 이유
  • ILSVRC로 대표되는 대규모 이미지 인식 대회의 결과
  • 매개변수 수가 줄어든다.
  • 층을 깊게 한 신경망은 깊지 않은 경우보다 적은 매개변수로 같은(혹은 그 이상)수준의 표현력을 달성할 수 있다.

합성곱 연산의 예

 

[그림5] 합성곱 연산의 예

 

3x3의 합성곱 계층을 2회 반복학 예

 

[그림6] 3x3의 합성곱 계층을 2회 반복한 예

 

작은 필터를 겹쳐 신경망을 깊게 할 때의 장점은 매개변수 수를 줄여 넓은 수용 영역(receptive fileld)을 소화할 수 있다는 데 있다.

 

신경망을 깊게 할 시

• 학습해야 할 문제를 계층적으로 분해할 수 있다.
  • 각 층이 학습해야 할 문제를 더 단순한 문제로 대체할 수 있다.
• 정보를 계층적으로 전달할 수 있다.
  • 에지를 추출한 층의 다음 층은 에지 정보를 쓸 수 있고, 더 고도의 패턴을 효과적으로 학습하리라 기대할 수 있다.

 

출처 : 밑바닥부터 시작하는 딥러닝

https://www.hanbit.co.kr/store/books/look.php?p_code=B8475831198

밑바닥부터 시작하는 딥러닝