출처: https://sacko.tistory.com/45?category=632408

이전 포스팅에서 다룬 배치 정규화는 일종의 정규화(Regularization) 기법이라고 볼 수 있다. 과적합(overfitting)의 위험을 줄이고 학습속도를 개선하는 등의 문제를 해결하기 위해 고안된 것이다. 배치 정규화 이외에도 가중치 감소(Weight Decay), 드롭아웃(Dropout) 등이 비슷한 목적을 위해서 제안된 방법들이다.

머신러닝에서는 학습된 모델이 학습 데이터에만 높은 정확도를 보이길 원치 않는다. 궁극적으로 학습한 모델이 범용적으로 사용되어야 하기 때문에 학습 데이터에만 잘맞는 overfitting 문제를 피해야 한다. 신경망의 층이 깊어질수록, 학습률이 작을수록 과적합되는 경향이 있다.  

가중치 감소, 드롭아웃

문과생도 이해하는 딥러닝 (11)

1. 가중치 감소 Weight Decay

가중치 감소는 학습 중에 가중치가 큰 것에 대해서는 일종의 패널티를 부과해 과적합의 위험을 줄이는 방법이다. 가중치의 제곱 법칙(L2 법칙; 많이 사용된다)를 손실함수에 더해 손실함수 값이 더 커지게 한다. 그만큼 가중치가 커지는 것을 억제하기 되는 것이다.

L2 법칙은 1/2곱하기 λ(람다) 곱하기 W제곱 이다.

람다는 정규화의 세기를 조절하는 하이퍼파라미터이다.

람다를 크게 설정할수록 가중치에 대한 페널티가 커진다. 

가중치 감소 이전 (Overfitting)

가중치 감소 이후

가중치 감소 이후 오버피팅 문제는 어느정도 해소된 것으로 보인다

2. 드롭아웃 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

from scratch.common.multi_layer_net_extend import MultiLayerNetExtend from scratch.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()

드롭아웃은 머신러닝에서 자주 나오는 앙상블 기법(Ensemble)과 유사하다. 앙상블 기법은 서로 다른 모델들을 학습해서 개별 모델들에서 나온 출력의 평균을 내어 추론하는 학습 방식이다. 드롭아웃은 학습할 때 뉴런을 무작위로 학습해 매번 다른 모델들을 학습시킨다는 측면에서 앙상블 기법과 유사하다.

출처: https://sacko.tistory.com/44?category=632408

이전 포스팅에서는 초기 가중치 설정에 따라서 활성화 값의 분포가 어떻게 나타나는지 파악했으며 활성화함수 별로 적절한 초기 가중치 설정 방법이 있다는 것을 알았다. 이번에는 또다른 이슈에 대해 다루고자 한다. 4번째 포스팅에서 배치(Batch)에 대해서 포스팅을 했었다. 배치는 일종의 랜덤 샘플링으로 전체 학습데이터를 한 번 학습할 때 다 학습에 사용하면 많은 시간이 걸리기 때문에... (수천만, 수억 개의 데이터를 한 번에 다 사용한다면???) 미니배치 방식으로 랜덤하게 학습 데이터에서 배치 크기만큼 꺼내서 한 번의 학습에 사용하는 방식이다.

이번 포스팅에서 다루는 배치 정규화는 초기 가중치 설정 문제와 비슷하게 가중치 소멸 문제(Gradient Vanishing) 또는 가중치 폭발 문제(Gradient Exploding)를 해결하기 위한 접근 방법 중 하나이다. 정규화(Normalization)는 통계에서 다루는 정규화를 말한다. 기본적인 개념으로 사용되기 때문에 먼저 이를 숙지해야 된다. 

배치 정규화 Batch Normalization

문과생도 이해하는 딥러닝 (10)

1. 배치 정규화 도입

학습의 효율을 높이기 위해 도입되었다. 배치 정규화는 Regularization을 해준다고 볼 수 있음

• 학습 속도가 개선된다 (학습률을 높게 설정할 수 있기 때문)
• 가중치 초깃값 선택의 의존성이 적어진다 (학습을 할 때마다 출력값을 정규화하기 때문)
• 과적합(overfitting) 위험을 줄일 수 있다 (드롭아웃 같은 기법 대체 가능)
• Gradient Vanishing 문제 해결

배치 정규화는 활성화함수의 활성화값 또는 출력값을 정규화(정규분포로 만든다)하는 작업을 말한다. 배치 정규화를 활성화함수 이전에 하는지 이후에 하는지는 계속된 논의와 실험이 진행중이라고 한다. 신경망의 각 layer에서 데이터(배치)의 분포를 정규화하는 작업이다. 일종의 노이즈를 추가하는 방법으로 (bias와 유사) 이는 배치마다 정규화를 함으로써 전체 데이터에 대한 평균의 분산과 값이 달라질 수 있다. 학습을 할 때마다 활성화값/출력값을 정규화하기 때문에 초기화(가중치 초깃값) 문제에서 비교적 자유로워진다.

각 hidden layer에서 정규화를 하면서 입력분포가 일정하게 되고, 이에 따라 Learning rate을 크게 설정해도 괜찮아진다. 결과적으로 학습속도가 빨라지게 된다.

출처: http://sanghyukchun.github.io/88/

입력 분포의 균일화

학습을 할 때 hidden layer의 중간에서 입력분포가 학습할 때마다 변화하면서 가중치가 엉뚱한 방향으로 갱신될 문제가 발생할 수 있다. 신경망의 층이 깊어질수록 학습 시에 가정했던 입력분포가 변화하여 엉뚱한 학습이 될 수 있다.

2. 배치 정규화 알고리즘

간다하게 배치 정규화는 학습 시의 미니배치를 한 단위로 정규화를 하는 것으로 분포의 평균이 0, 분산이 1이 되도록 정규화하는 것을 말한다.

먼저 Input으로 사용된 미니배치의 평균과 분산을 계산을 한다. 그 다음 hidden layer의 활성화값/출력값에 대해서 평균이 0, 분산이 1이 되도록 정규화(Normalization)를 한다(=변환; transform). 그럼으로써 데이터 분포가 덜 치우치게 되고 배치 정규화 단계마다 확대scale와 이동shift 변환(transform)을 수행한다.

파란색 선이 배치 정규화를 했을 때의 결과이다. 훨씬 학습이 빠른 것을 알 수 있다. 가중치 초깃값에 영향을 받지 않는 것도 확인할 수 있다.

3. 기타 참고

배치 정규화는 가중치의 scale을 정규화하여 gradient exploding을 방지한다

기타 참고자료

출처: https://image.slidesharecdn.com/normalization1-170224122539/95/normalization-17-1024.jpg?cb=1487939204

Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariance Shift

NIPS 2015와 관련하여 그리고 배치 정규화와 연결되어 본 논문이 많이 언급된다. 국내, 해외 가릴 것 없이 리뷰가 많이 되고 있으며 대부분의 배치 정규화에 대한 블로그 정리 글은 이 paper에 기반한 것들이 많다. 활성화함수의 변경(ReLU 사용)이나 낮은 학습률의 설정, 초기화 작업 등은 간접적으로 Gradient Vanishing 또는 Gradient Exploding을 해결하는 방법이라고 보고 training 과정 자체에서 학습을 안정화시키고(vanishing, exploding 해결) 학습속도를 개선하는 방법으로 배치 정규화가 제안되었다. 일종의 Whitening 이라고 한다.

"Training 할 때는 mini-batch의 평균과 분산으로 normalize 하고, Test 할 때는 계산해놓은 이동 평균으로 normalize 한다. Normalize 한 이후에는 scale factor와 shift factor를 이용하여 새로운 값을 만들고, 이 값을 내놓는다. 이 Scale factor와 Shift factor는 다른 레이어에서 weight를 학습하듯이 back-prop에서 학습하면 된다."

출처 :

https://shuuki4.wordpress.com/2016/01/13/batch-normalization-%EC%84%A4%EB%AA%85-%EB%B0%8F-%EA%B5%AC%ED%98%84/

참고자료

배치 정규화에 대해서 잘 정리된 블로그

http://funmv2013.blogspot.kr/2016/09/batch-normalization.html

1. Batch Normalization (ICML 2015)
   http://sanghyukchun.github.io/88/
2. Normalization in Deep Learning
   https://calculatedcontent.com/2017/06/16/normalization-in-deep-learning/
3. Batch Normalization 설명 및 구현
   https://shuuki4.wordpress.com/2016/01/13/batch-normalization-%EC%84%A4%EB%AA%85-%EB%B0%8F-%EA%B5%AC%ED%98%84/
4. Layer Normalization
   https://www.slideshare.net/ssuser06e0c5/normalization-72539464
5. 배치정규화 (Batch Normalization)
   http://astralworld58.tistory.com/65

출처: https://sacko.tistory.com/43?category=632408

이전 포스팅에서는 최적화 기법들을 살펴보면서 최적의 가중치 매개변수를 찾기 위해 어떤 것들을 사용하는지 알아보았다. 확률적 경사하강법 이외에도 다양한 방법으로 적절한 기울기 값을 구하고 손실함수가 낮아지는 방향으로 계산(또는 학습)하는 방법들이 있으며 자신의 문제에 따라 적합한 방법을 사용하는 것이 좋다.

최적화 만큼 초기 신경망의 가중치 값을 어떻게 설정하느냐도 상당히 중요한 문제이다. 초기값을 무엇으로 하느냐에 따라서 학습의 성패가 결정나기도 한다.

신경망 초기 가중치 설정

문과생도 이해하는 딥러닝 (9)

가중치 초깃값을 0으로 하면?

가중치의 초기값을 0으로 default를 주고 시작하면 올바른 학습을 기대하기 어렵다. 오차역전파에서 가중치의 값이 똑같이 갱신되기 때문이다. 가중치가 각각 영향이 있어야 하는데 고르게 되어버리는 상황이 발생하면 각각의 노드를 만든 의미를 잃어버리게 된다. 그래서 다른 샘플 코드나 예제를 보면 np.random.randn()을 사용하여 무작위로 가중치를 설정하는 것을 볼 수 있다.

1. Sigmoid 가중치 초깃값 설정 : Xavier

표준편차가 1

활성화함수가 시그모이드 함수인 경우 활성화 값이 0과 1에 주로 분포되어 있다. 이는 시그모이드 함수의 미분 값이 0에 가까워지도록 한다. 따라서 역전파의 기울기 값은 점점 작아지다가 사라지는 Gradient Vanishing 문제가 발생하며 층이 깊어질수록 기울기는 더 사라진다.

표준편차가 0.01

기울기가 사라지는 문제는 발생하지 않았으나 0.5 주변으로 값이 여전히 치우쳐있기 때문에 뉴런을 다수 사용한 이점이 없다. 뉴런 100개가 똑같은 값을 출력한다면 100개가 다 필요한 이유가 없다.

Xavier 초기값

Xavier Glorot & Yoshua Bengio의 논문에서 권장하는 가중치 초기값.

앞 층의 입력 노두 수에 더하여 다음 계층의 출력 노드 수를 함께 고려하여 초기값을 설정하는 방법

아래 그래프를 보면 앞의 두 방식보다 고르게 분포되어 학습이 효율적으로 이루어질 수 있음을 엿볼 수 있다. 시그모이드 함수를 사용했음에도 표현력의 문제가 발생하지 않는다.

import numpy as np import matplotlib.pyplot as plt def sigmoid(x): return 1 / (1 + np.exp(-x)) x = np.random.randn(1000, 100) node_num= 100 hidden_layer_size = 5 activations ={} for i in range(hidden_layer_size): if i != 0: x = activations[i-1] w = np.random.randn(node_num, node_num) / np.sqrt(node_num) a = np.dot(x, w) z = sigmoid(a) activations[i] = z fig = plt.figure(figsize=(10,2)) for i, a in activations.items(): plt.subplot(1, len(activations), i+1) plt.title(str(i+1) + "-layer") plt.yticks([],[]) plt.hist(a.flatten(), 30, range=(0,1)) plt.show()

2. ReLU 가중치 초깃값 설정 : He

He 초깃값은 ReLU에 특화된 초깃값이다.

계층의 노드가 n개 일 때 표준편차 (2/n)−−−−−√ 인 정규분포를 사용

ReLU는 음의 영역은 0을 출력하는 활성화함수로 정규분포 표준편차를 사용하거나 Xavier를 사용할 경우 Hidden Layer의 계층이 깊어질수록 가중치의 값이 0으로 수렴하여 가중치가 사라지는 Gradient Vanishing 문제가 발생한다.

3. 활성화함수 별 가중치 초기값 설정 방식에 따른 활성화값 분포 비교

Sigmoid 함수 - Std 0.01, Xavier, He

ReLU 함수 - Std 0.01, Xavier, He

ReLU함수에서 가중치 초기값 설정 방식에 따른 가중치 분포를 확인하면, He가 가장 고르게 나타나는 것을 확인할 수 있다.

표준편차를 0.01로 한 경우 층이깊어질수록 가중치가 0으로 사라진 것을 볼 수 있으며, Xavier 역시 초반 

Tanh 함수 - Std 0.01, Xavier, He

4. 예제: MNIST 데이터셋으로 가중치 초깃값 비교

ReLU를 활성화함수로 했을 때 초기 가중치 설정에 따른 결과는 위와 같다. 표준정규분포 0.01로 했을 때 학습이 전혀이루어지고 있지 않음을 알 수 있다. 이는 앞에서 보았던 기울기가 0에 가까워져 발생하는 현상이다. 순전파에서 전파할 때 0에 가까웠기 때문에 역전파 시에도 기울기(미분의 값)가 작아져 가중치가 거의 갱신되지 않는 것이다.

위 그래프를 보면 He 초기값을 사용했을 때 학습의 진도가 가장 빨랐음을 알 수 있다.

출처: https://sacko.tistory.com/42?category=632408

지금까지 신경망이 이론적으로 어떻게 구성되고 이를 코드로 어떻게 구현하는지 살펴보았다. 딥러닝은 깊은 신경망 계층을 말하며 수 많은 모듈의 조합으로 이루어진 것이라고 볼 수 있다. 따라서 모듈과 함수가 많은 만큼 각각에 대한 하이퍼파라미터(hyper-parameter)가 많다. 하이퍼파라미터를 어떻게 설정하느냐에 따라서 학습의 결과가 천차만별로 달라질 수 있다.

딥러닝 모델 학습에서 많이들 중요성을 간과하는 부분이 이 최적화 부분이다. 신경망을 생성하면서 이 최적화 문제에 대해서 끊임 없이 고민해야 한다. 이는 Input으로 넣는 데이터와의 직접적인 연결성도 있으며 하이퍼파라미터에 따른 모델의 변화를 어느정도 이해하고 예측하여 튜닝 과정을 할 수 있어야 하기 때문이다. 눈가리고 모래에서 진주찾는 식으로 적절한 하이퍼파라미터 값을 찾는 것은 좋지 못한 방법이다.

신경망 학습 최적화 Optimization

문과생도 이해하는 딥러닝 (8)

신경망 모델의 학습과 그 결과에 따른 손실함수의 값을 최소화하는 방향으로 하이퍼파라미터의 값을 찾는 것이 최적화의 목표라고 할 수 있다. 하이퍼파라미터 매개변수의 수 n 만큼 가능한 매개변수의 조합이 n x n 만큼 증가하므로 이중에서 최적의 조합을 찾는 것은 쉽지 않다. 다양한 방법으로 자동으로 찾고자 하지만 여전히 이는 연구자의 주관이나 직관, 경험 등에 의존하고 있다.

최적의 가중치 값을 구하기 위해서 앞에서는 미분을 통해 기울기를 구하여 가중치 값을 갱신하는 방법인 확률적 경사하강법(Stochastic Gradient Descent; SGD) 방법을 사용하였다. 이는 무작정 가중치 값을 랜덤으로 콕콕콕 찍어서 찾는 방식보다는 훨씬 스마트한 방법이다.

확률적 경사하강법 이외에도 다양한 최적화 기법을 통해 최적의 하이퍼파라미터 조합을 찾을 수 있다.

출처: 하용호, 자습해도 모르겠던 딥러닝, 머리속에 인스톨 시켜드립니다

1. 확률적 경사하강법 복습

확률적 경사하강법 Stochastic Gradient Descent

SGD는 손실함수의 기울기를 계산하여서 이 기울기 값에 학습률(Learning Rate)를 계산하여 이 결과 값으로 기존의 가중치 값을 갱신한다.

class SGD: def __init__(self, lr=0.01): self.lr = lr def update(self, params, grads): for key in params.keys(): params[key] -= self.lr * grads[key]

위에서 update 함수를 통해 모듈화되어 가중치를 갱신할 수 있다.

경사하강법의 단점

경사하강법은 무작정 기울어진 방향으로 이동하는 방식이기 때문에 탐색경로가 비효율적이어서 한참을 탐색하게 된다. 또한 SGD는 방향에 따라서 기울기 값이 달라지는 경우에 적합하지 않은데 최소값의 방향으로만 움직이기 때문에 본래의 최저점으로 기울기의 방향이 좀처럼 향하지 않게 되고 다른 방향을 가리키게 되어 비효율이게 되기도 한다.

2. 모멘텀 Momentum

모멘텀은 '운동량'을 의미한다. 기울기에서 속도의 개념이 추가된 것으로 고등학교 물리 시간을 떠올려보면 자세히는 아니지만 지상의 마찰력 때문에 물체의 이동속도가 점점 감소한다고 배웠던 기억이 어렴풋이 기억이 난다. 속도가 크게 나올수록 기울기가 크게 업데이트 되어 확률적 경사하강법이 가지는 단점을 보완할 수 있다.

Momentum은 마찰력/공기저항 같은 것에 해당하며 기울기 업데이트 시 이 폭을 조절하는 역할을 한다. 이에 따라 속도 velocity가 변화한다.

모멘텀 Momentum

class Momentum: def __init__(self, lr=0.01, momentum=0.9): self.lr = lr self.momentum = momentum self.v = None def update(self, params, grads): if self.v is None: self.v = {} for key, val in params.items(): self.v[key] = np.zeros_like(val) for key in params.keys(): self.v[key] = self.momentum * self.v[key]

3. AdaGrad

신경망 학습에서의 학습률 learning rate의 값은 일종의 보폭으로 생각할 수 있는데 한 번 갱신하는 가중치의 값을 양을 결정한다. 학습률을 너무 작게하면 보폭이 너무 작아서 많은 걸음을 걸어야 하므로 학습 시간을 아주 길게 해야 한다. 반대로 너무 크게 하면 최적의 점을 계속 지나치게 된다.

학습률을 정하는 방법으로 학습률 감소learning rate decay가 있다고 한다. 학습을 진행하면서 점차 학습률을 줄여나가는 방법이다. 하지만 학습이 계속되면서 학습률이 0에 가까워져서 학습이 진행이 안되는 문제가 발생한다.

AdaGrad는 과거의 기울기 값을 제곱해서 계속 더하는 식으로 학습률을 낮추는데 학습이 진행될수록 제곱의 값으로 학습의 정도가 크게 떨어진다. 

이를 개선하기 위해서 RMSProp이 사용된다. RMSProp은 과거의 모든 기울기를 균일하게 더하지 않고 새로운 기울기의 정보만 반영하도록 해서 학습률이 크게 떨어져 0에 가까워지는 것을 방지하는 방법이다.

AdaGrad

class AdaGrad: def __init__(self, lr=0.01): self.lr = lr self.h = None def update(self, params, grads): if self.h is None: self.h = {} for key, val in params.items(): self.h[key] = np.zeros_like(val) for key in params.keys(): self.h[key] += grads[key] * grads[key] params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-7)

4. Adam

잘 모르겠으면 일단 Adam을 사용하라는 말이 있다. 앞에서 언급했던 Momentum과 AdaGrad를 섞은 기법이라고 보면 된다.

따라서 하이퍼파라미터도 그만큼 많다. 모멘텀에서 사용하는 계수와 학습률에 대한 계수가 사용된다.

학습률을 줄여나가고 속도를 계산하여 학습의 갱신강도를 적응적으로 조정해나가는 방법이다.

5. MNIST로 학습 최적화 진도

from scratch.dataset.mnist import load_mnist from scratch.common.util import smooth_curve from scratch.common.multi_layer_net import MultiLayerNet from scratch.common.optimizer import * import matplotlib.pyplot as plt # 0. MNIST 데이터 읽기========== (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True) train_size = x_train.shape[0] batch_size = 128 max_iterations = 2000 # 1. 실험용 설정========== optimizers = {} optimizers['SGD'] = SGD() optimizers['Momentum'] = Momentum() optimizers['AdaGrad'] = AdaGrad() optimizers['Adam'] = Adam() #optimizers['RMSprop'] = RMSprop() networks = {} train_loss = {} for key in optimizers.keys(): networks[key] = MultiLayerNet( input_size=784, hidden_size_list=[100, 100, 100, 100], output_size=10) train_loss[key] = [] # 2. 훈련 시작========== for i in range(max_iterations): batch_mask = np.random.choice(train_size, batch_size) x_batch = x_train[batch_mask] t_batch = t_train[batch_mask] for key in optimizers.keys(): grads = networks[key].gradient(x_batch, t_batch) optimizers[key].update(networks[key].params, grads) loss = networks[key].loss(x_batch, t_batch) train_loss[key].append(loss) if i % 100 == 0: print( "===========" + "iteration:" + str(i) + "===========") for key in optimizers.keys(): loss = networks[key].loss(x_batch, t_batch) print(key + ":" + str(loss)) # 3. 그래프 그리기========== markers = {"SGD": "o", "Momentum": "x", "AdaGrad": "s", "Adam": "D"} x = np.arange(max_iterations) plt.figure(figsize=(20,8)) for key in optimizers.keys(): plt.plot(x, smooth_curve(train_loss[key]), marker=markers[key], markevery=100, label=key) plt.xlabel("iterations") plt.ylabel("loss") plt.ylim(0, 1) plt.legend() plt.show()

===========iteration:0=========== SGD:2.37670101396 Momentum:2.33816339389 AdaGrad:2.12533763909 Adam:2.15575092649 ===========iteration:1900=========== SGD:0.154444681428 Momentum:0.020718003123 AdaGrad:0.0183070478127 Adam:0.0222197490211

참고

http://seamless.tistory.com/38

https://www.slideshare.net/yongho/ss-79607172