[DL] 올바른 학습을 위해 - Overfitting, Dropout, Hyperparameter

올바른 학습을 위해 

Machine Learning에서 Overfitting이 되는 일이 많습니다. Overiftting(오버피팅)은 신경망이 Training data(훈련 데이터)에만 지나치게 적용되어서 그 외의 데이터에는 제대로 대응하지 못하는 상태입니다.

Overfitting (오버피팅)

• 오버피팅은 매개변수가 많고 표현력이 높은 모델인 경우, 훈련데이터가 적은 경우에 주로 일어납니다.
• 이 두 요건을 충족하여 Overiftting(오버피팅)을 일으켜 보겠습니다.
• MNIST Dataset의 훈련데이터중 300개만 사용하고, 7-Layer Network를 사용해서 Network의 복잡성을 높혀보겠습니다.
• 각 Layer의 Neuron은 100개, Activation Function(활성화 함수)는 ReLU 함수를 사용합니다.

# 데이터를 읽는 코드 (Data Loader)
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

# 오버피팅을 재현하기 위해 학습 데이터 수를 줄임
x_train = x_train[:300]
t_train = t_train[:300]

• 아래는 Training을 수행하는 코드 입니다. 

network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10,
                        weight_decay_lambda=weight_decay_lambda)
optimizer = SGD(lr=0.01) # 학습률이 0.01인 SGD로 매개변수 갱신

max_epochs = 201
train_size = x_train.shape[0]
batch_size = 100

train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)
epoch_cnt = 0

for i in range(1000000000):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    grads = network.gradient(x_batch, t_batch)
    optimizer.update(network.params, grads)

    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)

        print("epoch:" + str(epoch_cnt) + ", train acc:" + str(train_acc) + ", test acc:" + str(test_acc))

        epoch_cnt += 1
        if epoch_cnt >= max_epochs:
            break

• train_acc_list와 test_acc_list에는 epoch단위의 정확도를 저장합니다. 그래프로 그리면 아래의 그래프 처럼 나옵니다.

# 그래프 그리기
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, train_acc_list, marker='o', label='train', markevery=10)
plt.plot(x, test_acc_list, marker='s', label='test', markevery=10)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

Train data & Test data epoch간 정확도 추이

• Training data를 사용하여 측정한 정확도는 100 epoch를 지나는 시점부터는 거이 100%입니다.
• 다만 Test 데이터에 대해서는 큰 차이를 보입니다. 이러한 현상은 Training data에만 적응해버린, 즉 fitting되버린 결과입니다.
• Training 때 사용되지 않은 Test data에 제대로 대응하지 못하는 것을 이 그래프에서 확인할 수 있습니다.

---

Weight Decay (가중치 감소)

Overiftting을 억제 하기 위해서 사용되던 방법으로 Weight Decay(가중치 감소)라고 있습니다.

• Training 과정에서 큰 Weight(가중치)에 대해서는 그에 상응하는 패널티를 부과하여 Overfitting을 억제하는 방법입니다.
• 원래 Overfitting은 Weight Parameter(가중치 매개변수)의 값이 커서 발생하는 경우가 많기 때문입니다.
• 일단, 신경망 학습의 목적은 Loss Function(손실 함수)의 값을 줄이는 것입니다. 
• 예를 들어보면, 가중치 제곱 노름(norm. L2 노름)을 손실함수에 더해줍니다.
• 그러면 가중치가 커지는 것을 억제할 수 있습니다. 
• 여기서 λ(람다)는 정규화의 세기를 조절하는 하이퍼파라미터이며, 크게 설정할수록 큰 가중치에 대한 페널티가 커집니다.
• 또 1/2λW**2 의 앞쪽의 1/2은 1/2λW**2의 미분 결과인 λW를 조절하는 역할의 상수입니다.
• 한번 λ = 0.1로 Weight Decay(가중치 감소)를 적용해 보겠습니다.

Weight Decay (가중치 감소) Network code (by python)

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
from collections import OrderedDict
from common.layers import *
from common.gradient import numerical_gradient


class MultiLayerNet:
    """완전연결 다층 신경망

    Parameters
    ----------
    input_size : 입력 크기（MNIST의 경우엔 784）
    hidden_size_list : 각 은닉층의 뉴런 수를 담은 리스트（e.g. [100, 100, 100]）
    output_size : 출력 크기（MNIST의 경우엔 10）
    activation : 활성화 함수 - 'relu' 혹은 'sigmoid'
    weight_init_std : 가중치의 표준편차 지정（e.g. 0.01）
        'relu'나 'he'로 지정하면 'He 초깃값'으로 설정
        'sigmoid'나 'xavier'로 지정하면 'Xavier 초깃값'으로 설정
    weight_decay_lambda : 가중치 감소(L2 법칙)의 세기
    """
    def __init__(self, input_size, hidden_size_list, output_size,
                 activation='relu', weight_init_std='relu', weight_decay_lambda=0):
        self.input_size = input_size
        self.output_size = output_size
        self.hidden_size_list = hidden_size_list
        self.hidden_layer_num = len(hidden_size_list)
        self.weight_decay_lambda = weight_decay_lambda
        self.params = {}

        # 가중치 초기화
        self.__init_weight(weight_init_std)

        # 계층 생성
        activation_layer = {'sigmoid': Sigmoid, 'relu': Relu}
        self.layers = OrderedDict()
        for idx in range(1, self.hidden_layer_num+1):
            self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
                                                      self.params['b' + str(idx)])
            self.layers['Activation_function' + str(idx)] = activation_layer[activation]()

        idx = self.hidden_layer_num + 1
        self.layers['Affine' + str(idx)] = Affine(self.params['W' + str(idx)],
            self.params['b' + str(idx)])

        self.last_layer = SoftmaxWithLoss()

    def __init_weight(self, weight_init_std):
        """가중치 초기화
        
        Parameters
        ----------
        weight_init_std : 가중치의 표준편차 지정（e.g. 0.01）
            'relu'나 'he'로 지정하면 'He 초깃값'으로 설정
            'sigmoid'나 'xavier'로 지정하면 'Xavier 초깃값'으로 설정
        """
        all_size_list = [self.input_size] + self.hidden_size_list + [self.output_size]
        for idx in range(1, len(all_size_list)):
            scale = weight_init_std
            if str(weight_init_std).lower() in ('relu', 'he'):
                scale = np.sqrt(2.0 / all_size_list[idx - 1])  # ReLU를 사용할 때의 권장 초깃값
            elif str(weight_init_std).lower() in ('sigmoid', 'xavier'):
                scale = np.sqrt(1.0 / all_size_list[idx - 1])  # sigmoid를 사용할 때의 권장 초깃값
            self.params['W' + str(idx)] = scale * np.random.randn(all_size_list[idx-1], all_size_list[idx])
            self.params['b' + str(idx)] = np.zeros(all_size_list[idx])

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

        return x

    def loss(self, x, t):
        """손실 함수를 구한다.
        
        Parameters
        ----------
        x : 입력 데이터
        t : 정답 레이블 
        
        Returns
        -------
        손실 함수의 값
        """
        y = self.predict(x)

        weight_decay = 0
        for idx in range(1, self.hidden_layer_num + 2):
            W = self.params['W' + str(idx)]
            weight_decay += 0.5 * self.weight_decay_lambda * np.sum(W ** 2)

        return self.last_layer.forward(y, t) + weight_decay

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

        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy

    def numerical_gradient(self, x, t):
        """기울기를 구한다(수치 미분).
        
        Parameters
        ----------
        x : 입력 데이터
        t : 정답 레이블
        
        Returns
        -------
        각 층의 기울기를 담은 딕셔너리(dictionary) 변수
            grads['W1']、grads['W2']、... 각 층의 가중치
            grads['b1']、grads['b2']、... 각 층의 편향
        """
        loss_W = lambda W: self.loss(x, t)

        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            grads['W' + str(idx)] = numerical_gradient(loss_W, self.params['W' + str(idx)])
            grads['b' + str(idx)] = numerical_gradient(loss_W, self.params['b' + str(idx)])

        return grads

    def gradient(self, x, t):
        """기울기를 구한다(오차역전파법).

        Parameters
        ----------
        x : 입력 데이터
        t : 정답 레이블
        
        Returns
        -------
        각 층의 기울기를 담은 딕셔너리(dictionary) 변수
            grads['W1']、grads['W2']、... 각 층의 가중치
            grads['b1']、grads['b2']、... 각 층의 편향
        """
        # forward
        self.loss(x, t)

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

        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 결과 저장
        grads = {}
        for idx in range(1, self.hidden_layer_num+2):
            grads['W' + str(idx)] = self.layers['Affine' + str(idx)].dW + self.weight_decay_lambda * self.layers['Affine' + str(idx)].W
            grads['b' + str(idx)] = self.layers['Affine' + str(idx)].db

        return grads

---

Test Code

# coding: utf-8
import os
import sys

sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.multi_layer_net import MultiLayerNet
from common.optimizer import SGD

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

# 오버피팅을 재현하기 위해 학습 데이터 수를 줄임
x_train = x_train[:300]
t_train = t_train[:300]

# weight decay（가중치 감쇠） 설정 =======================
#weight_decay_lambda = 0 # weight decay를 사용하지 않을 경우
weight_decay_lambda = 0.1
# ====================================================

network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100], output_size=10,
                        weight_decay_lambda=weight_decay_lambda)
optimizer = SGD(lr=0.01) # 학습률이 0.01인 SGD로 매개변수 갱신

max_epochs = 201
train_size = x_train.shape[0]
batch_size = 100

train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)
epoch_cnt = 0

for i in range(1000000000):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    grads = network.gradient(x_batch, t_batch)
    optimizer.update(network.params, grads)

    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)

        print("epoch:" + str(epoch_cnt) + ", train acc:" + str(train_acc) + ", test acc:" + str(test_acc))

        epoch_cnt += 1
        if epoch_cnt >= max_epochs:
            break


# 그래프 그리기==========
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, train_acc_list, marker='o', label='train', markevery=10)
plt.plot(x, test_acc_list, marker='s', label='test', markevery=10)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

Weight Decay를 이용한 Training Data와 Test Data에 대한 정확도 추이

• Training Data, Test Data에 대한 정확도 차이는 여전히 있지만, Weight Decay를 이용하지 않은 결과과 비교하면 차이가 줄은것을 확인할 수 있습니다. 즉, Overfitting이 어느정도 억제되었다는 의미로 볼 수 있습니다.

---

Dropout (드롭아웃)

Weight Decay(가중치 감소)는 간단하게 구현할 수 있고, 어느정도 지나친 학습(Overfitting)을 억제 할 수 있습니다.
그러나, 신경망 모델이 복잡해지면 Weight Decay(가중치 감소)만으로는 대응하기 어려워입니다. 이럴때는 흔히 Dropout(드롭아웃)이라는 기법을 이용합니다.

• Dropout은 Neuron을 임의로 삭제하면서 학습하는 방법입니다.
• Training때, Hidden Layer(은닉층)의 뉴런을 무작위로 골라서 삭제합니다.
• 데이터를 흘릴 때마다 삭제할 뉴런을 무작위로 선택하고, 시험때는 모든 뉴런에 신호를 전달합니다.
• 단 Test때에 각 뉴런의 출력에 훈련 때 삭제 안한 비율을 곱하여 출력합니다.

왼쪽이 일반적인 신경망, 오른쪽이 Dropout을 적용한 신경망입니다. Dropout은 뉴런을 무작위로 선택해 삭제하여 신호 전달을 차단합니다.

• 한번 Dropout을 구현해 보겠습니다. 아래는 Dropout을 구현한 코드 입니다.

class Dropout:
	def __init__(self, dropout_ratio=0.5):
    	self.dropout_ratio = dropout_ratio
        self.mask = None
        
	def forward(self, x, train_flg=True):
    	if train_flg:
        	self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
		else:
        	return x * (1.0 - self.dropout_ratio)
            
	def backward(self, dout):
    	return dout*self.mask

• 여기서 중요하게 봐야하는점은 Training시, Forward Propagation(순전파)때 마다 self.mask에 삭제할 뉴런을 False로 표시한다는 점입니다.
• self.mask는 x와 형상과 같은 배열을 무작위로 생성하고, 그 값이 dropout_ratio보다 큰 원소만 True로 설정합니다.
• Backpropagation(역전파)때의 동작은 ReLU와 같습니다.
• 이말은, Forward Propagation(순전파)때 신호를 통과시키는 뉴런은 Backpropagation(역전파)때도 신호를 그대로 통과시키고
•  Forward Propagation(순전파)때 신호를 통과시키지 않는 뉴런은Backpropagation(역전파)때도 신호를 차단합니다.
• 그러면 한번 Dropout의 효과를 MNIST 데이터셋으로 한번 확인해보겠습니다.
  • 7-Layer Network. 각 Layer의 Neuron은 100개, Activation Function은 ReLU를 써서 진행했습니다.

import os
import sys
sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.multi_layer_net_extend import MultiLayerNetExtend
from common.trainer import Trainer

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

# 오버피팅을 재현하기 위해 학습 데이터 수를 줄임
x_train = x_train[:300]
t_train = t_train[:300]

# 드롭아웃 사용 유무와 비울 설정
use_dropout = True  # 드롭아웃을 쓰지 않을 때는 False
dropout_ratio = 0.2

network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100],
                              output_size=10, use_dropout=use_dropout, dropout_ration=dropout_ratio)
trainer = Trainer(network, x_train, t_train, x_test, t_test,
                  epochs=301, mini_batch_size=100,
                  optimizer='sgd', optimizer_param={'lr': 0.01}, verbose=True)
trainer.train()

train_acc_list, test_acc_list = trainer.train_acc_list, trainer.test_acc_list

# 그래프 그리기
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, marker='o', label='train', markevery=10)
plt.plot(x, test_acc_list, marker='s', label='test', markevery=10)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

왼쪽은 Dropout X, 오른쪽은 Dropout (0.15) 적용한 결과

• 위의 그림과 같이 Dropout을 적용하니까 Train Data, Test Data에 대한 정확도 차이가 줄었습니다.
• 그리고 Training Data에 대한 정확도가 100%에도 도달하지 않게 되었습니다.
• 이처럼 Dropout을 이용하면 표현력을 높이면서도, Overfitting을 억제하는 효과가 있습니다.

---

적절한 HyperParameter Value 찾기

HyperParameter는 각 층의 Neuron수, Batch size, 매개변수 갱신시의 Learning Rate와 Weight Decay 등입니다.

• 한번 Hyperparameter(하이퍼파라미터)의 값을 최대한 효율적으로 탐색하는 방법을 알아보겠습니다.

Validation Data (검증 데이터)

• Hyperparameter(하이퍼파라미터)를 다양한 값으로 설정하고 검증할 텐데, 여기서 주의할 점은 하이퍼파라미터의 성능을 평가할 때는 시험 데이터를 사용해서 안 된다는 것입니다.
• Test Data(시험 데이터)를 사용하여 하이퍼파라미터를 조정하면 Hyperparameter(하이퍼파라미터) 값이 Test Data(시험 데이터)에 Overfitting(오버피팅)되기 때문입니다.
• 그래서 하이퍼파라미터 조정용 데이터를 일반적으로 검증 데이터(validation data)라고 부릅니다. Hyperparameter(하이퍼파라미터)의 적정성을 평가하는 데이터인 셈입니다.
• 보통은 Training Data(훈련 데이터)중 20%를 Validation Data(검증 데이터)로 분리합니다.

각 데이터의 역할: Training Data(훈련 데이터 - 매개변수 학습), Validation Data (검증 데이터 - Hyperparameter(하이퍼파라미터) 성능 평가), Test Data(시험 데이터 - 신겸망의 범용 성능 평가)

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

# 훈련 데이터를 뒤섞음
x_train, t_train = shuffle_dataset(x_train, t_train)

# 20%를 검증 데이터로 분할
validation_rate = 0.2
validation_num = int(x_train.shape[0] * validation_rate)

x_val = x_train[:validation_num]
t_val = t_train[:validation_num]
x_train = x_train[validation_num:]
t_train = t_train[validation_num:]

---

Hyperparameter 최적화

Hyperparameter(하이퍼파라미터)를 최적화할 때, 최적 값이 존재하는 범위를 조금씩 줄여간다는 것입니다.
범위를 조금씩 줄이려면 대략적인 범위를 설정하고 그 범위에서 무작위로 Hyperparameter(하이퍼파라미터)값을 샘플링한 후, 그 값으로 정확도를 평가합니다. 이 과정을 반복하여 Hyperparameter(하이퍼파라미터)의 '최적 값'의 범위를 좁혀가는 것입니다.

• 보통 Hyperparameter(하이퍼파라미터)의 범위는 '대략적으로' 지정하는 것이 효과적입니다(0.001~1000)사이.
• 또한 Hyperparameter(하이퍼파라미터)를 최적화할 때는 오랜 시간(며칠~몇주 이상)이 걸립니다.
• 그래서 학습을 위한 epoch을 작게 하여, 1회 평가에 걸리는 시간을 단축하는 것이 효과적입니다. 이 말을 요약하면 아래와 같습니다. 

 

• 0단계
  하이퍼파라미터 값의 범위를 설정합니다.
• 1단계
  설정된 범위에서 하이퍼파라미터의 값을 무작위로 추출합니다.
• 2단계
  1단계에서 샘플링한 하이퍼파라미터 값을 사용하여 학습하고, 검증 데이터로 정확도를 평가합니다. (에폭은 작게 설정)
• 3단계
  1단계와 2단계를 특정 횟수(100회 등) 반복하며, 그 정확도의 결과를 보고 하이퍼파라미터의 범위를 좁힙니다.

---

Hyperparameter 최적화 구현하기

한번 MNIST 데이터셋을 사용하여 하이퍼파라미터를 최적화해보겠습니다.
Learning Rate(학습률)과 Weight Decay(가중치 감소)의 세기를 조절하는 계수를 탐색하는 문제입니다.

• Hyperparameter(하이퍼파라미터)의 무작위 추출 코드는 아래와 같습니다.
  • (0.001~1000)사이 log scale 범위 내의 무작위 추출

weight_decay = 10 ** np.random.uniform(-8, -4)
lr = 10 ** np.random.uniform(-6, -2)

• 무작위로 추출한 값을 사용하여 학습을 수행합니다.
• 그 후, 다양한 Hyperparameter(하이퍼파라미터)값으로 학습을 반복하며 신경망에 좋을 것 같은 값이 어디에 존재하는지 관찰합니다.

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.multi_layer_net import MultiLayerNet
from common.util import shuffle_dataset
from common.trainer import Trainer

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)

# 결과를 빠르게 얻기 위해 훈련 데이터를 줄임
x_train = x_train[:500]
t_train = t_train[:500]

# 20%를 검증 데이터로 분할
validation_rate = 0.20
validation_num = int(x_train.shape[0] * validation_rate)
x_train, t_train = shuffle_dataset(x_train, t_train)
x_val = x_train[:validation_num]
t_val = t_train[:validation_num]
x_train = x_train[validation_num:]
t_train = t_train[validation_num:]


def __train(lr, weight_decay, epocs=50):
    network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100],
                            output_size=10, weight_decay_lambda=weight_decay)
    trainer = Trainer(network, x_train, t_train, x_val, t_val,
                      epochs=epocs, mini_batch_size=100,
                      optimizer='sgd', optimizer_param={'lr': lr}, verbose=False)
    trainer.train()

    return trainer.test_acc_list, trainer.train_acc_list


# 하이퍼파라미터 무작위 탐색
optimization_trial = 100
results_val = {}
results_train = {}
for _ in range(optimization_trial):
    # 탐색한 하이퍼파라미터의 범위 지정
    weight_decay = 10 ** np.random.uniform(-8, -4)
    lr = 10 ** np.random.uniform(-6, -2)

    val_acc_list, train_acc_list = __train(lr, weight_decay)
    print("val acc:" + str(val_acc_list[-1]) + " | lr:" + str(lr) + ", weight decay:" + str(weight_decay))
    key = "lr:" + str(lr) + ", weight decay:" + str(weight_decay)
    results_val[key] = val_acc_list
    results_train[key] = train_acc_list

# 그래프 그리기
print("=========== Hyper-Parameter Optimization Result ===========")
graph_draw_num = 20
col_num = 5
row_num = int(np.ceil(graph_draw_num / col_num))
i = 0

for key, val_acc_list in sorted(results_val.items(), key=lambda x:x[1][-1], reverse=True):
    print("Best-" + str(i+1) + "(val acc:" + str(val_acc_list[-1]) + ") | " + key)

    plt.subplot(row_num, col_num, i+1)
    plt.title("Best-" + str(i+1))
    plt.ylim(0.0, 1.0)
    if i % 5: plt.yticks([])
    plt.xticks([])
    x = np.arange(len(val_acc_list))
    plt.plot(x, val_acc_list)
    plt.plot(x, results_train[key], "--")
    i += 1

    if i >= graph_draw_num:
        break

plt.show()

실선은 Validation Data에 대한 정확도, 점선은 Training Data에 대한 정확도

Best-1 (val acc:0.83) | Ir:0.0092, weight dec ay:3.86e - 07
Best-2 (val acc:0.78) | Ir:0.00956, weight dec ay:6.04e - 07
Best-3 (val acc:0.77) | lr:0.00571, weight decay:1.27e - 06
Best-4 (val acc:0.74) | Ir:0.00626, weight decay:1.43e - 05
Best-5 (val acc:0.73) | lr:0.OO52, weight dec ay:8.97e - 06

• 이렇게 적절한 값이 위치한 범위를 좁혀가다가 특정 단계에서 최종 하이퍼파라미터 값을 하나 선택합니다.

---

Summary

• 매개변수 갱신 방법에는 확률적 경하 하강법(SGD) 외에도 모멘텀, AdaGrad, Adam 등이 있습니다.
• 가중치 초깃값을 정하는 방법은 올바른 학습을 하는 데 매우 중요합니다.
• 가중치의 초깃값으로는 Xavier 초깃값과 He 초깃값이 효과적입니다.
• 배치 정규화를 이용하면 학습을 빠르게 진행할 수 있으며, 초깃값에 영향을 덜 받게 됩니다.
• 오버피팅을 억제하는 정규화 기술로는 가중치 감소와 드롭아웃이 있습니다.
• 하이퍼파라미터 값 탐색은 최적 값이 존재할 법한 범위를 점차 좁히면서 하는 것이 효과적입니다.