[DL] Training Related Skills - SGD, Momentum, AdaGrad, Adam (학습 관련 기술들)

Parameter(매개변수) 갱신

신경망 학습의 목적은 Loss Function (손실 함수)의 값을 가능한 낮추는 매개변수를 찾는것입니다. 이는 곧 매개변수의 최적값을 찾는 문제이며, 이러한 문제를 푸는것은 Optimization(최적화) 라고 합니다.

• 그리고 최적의 Parameter(매개변수) 값을 찾는 단소로 Parameter(매개변수)의 Gradient(기울기-미분)을 이용했습니다.
• Parameter(매개변수)의 Gradient를 구해, 기울어진 방향으로 Parameter(매개변수) 값을 갱신하는 일을 몇 번이고 반복해서 점점 최적의 값에 다가갔습니다. 이것이 확률적 경사 하강법 - Stochastic Gradient Descent(SGD)라고 합니다.
• 또한 확률적 경사 하강법 - Stochastic Gradient Descent(SGD) 은 가장 크게 기울어진 방향으로 가는것이 Stochastic Gradient Descent(SGD)의 전략입니다.

---

Stochastic Gradient Descent (SGD) - 확률적 경사 하강법

Stochastic Gradient Descent(SGD)는 수식으로 아래와 같이 쓸 수 있습니다.

 

• W ← W − η ∗ ∂L / ∂W
• 여기서 'W'는 갱신할 'Weight Parameter' (가중치 매개변수)
• '∂L / ∂W' 는 'W'에 대한 Loss Function(손실 함수)의 Gradient(기울기)입니다.
• 'η': 학습률을 의미하는데 정해진 상수값(보통 0.01이나, 0.001과 같은 값을 미리 정함)을 사용합니다.
• 또한 '←' 는 우변의 값으로 좌변의 값을 갱신한다는 뜻입니다. 즉, SGD는 기울어진 방향으로 일정 거리만 가겠다는 단순한 방법입니다.

class SGD:
	def __init__(self):
    	self.lr = lr # lr은 학습률 (learning rate)
        
	# update()는 SGD 과정에서 반복해서 호출됨
	def update(self, params, grads):
    	for key in params.keys():
        	params[key] -= self.lr * grads[key]

• 여기서 초기화때 받는 인수인 lr은 Learning Rate(학습률)을 뜻합니다.
• 이 Learning Rate(학습률)은 인스턴스 변수로 유지합니다.
• update(params, grads)Method는 SGD과정에서 반복해서 불리는 Dictionary 변수 입니다.
  • params['W1'], grads['W1']등과 같이 각각 Weight Parameter (가중치 매개변수) & Gradient (기울기)를 저장합니다.

---

SGD(확률적 경사하강법)의 단점

Stochastic Gradient Descent(SGD)는 단순하고 구현도 쉽지만, 문제에 따라서 비효율적 일때가 있습니다.
한번 SGD의 단점을 한번 알아보겠습니다.

• 이 함수의 한번 Gradient를 구해보겠습니다. 기울기를 구할때에는 편미분을 사용합니다.
• f에 대한 x의 편미분은 x에 대해서 미분하고, y는 상수로 취급합니다. 따라서 첫 번째 항만 살아남습니다.
• f에 대한 y의 편미분은 y에 대해서 미분하고, x는 상수로 취급합니다. 따라서 두 번째 항만 살아남습니다.
• 따라서 Gradient(기울기)는 (x에 대한 편미분 값, y에 대한 편미분 값)으로 나타납니다. 한번 편미분을 구해보겠습니다.

f(x, y)를 x에 대해 편미분: ∂f/∂x = (1/20) * 2x = x/10

f(x, y)를 y에 대해 편미분하면: ∂f/∂y = 2y

• 따라서 함수 f(x,y) = (x/10, 2y)가 Graident Vector (기울기 벡터)가 됩니다.
• Gradient(기울기)를 보면 y축 방향은 가파르고(크고) x축 방향은 작다는것(완만) 하다는것이 특징입니다.
• 또한 최소값이 되는 정보는 (x, y) = (0, 0)이지만, 보여주는 Gradient(기울기) 대부분은 (0, 0)방향을 가리키지 않습니다.

• 한번 예로 들어서 함수에 SGD를 초기값을 (-7.0, 2.0)으로 적용해서 한번 보겠습니다.

• 확률적 경사 하강법 - Stochastic Gradient Descent(SGD)과 같이 심하게 굽이진 움직임들 보여줍니다. 비효율적인 움직임으로 볼 수 있습니다.
• 즉 확률적 경사 하강법 - Stochastic Gradient Descent(SGD)의 단점은 Anisotropy Function(비등방성 함수 - 방향에 따라 성질, Gradient가 달라지는 함수)에서 탐색 경로가 비효율적이라는 것입니다.
• 이럴때 SGD 같이 무작정 기울어진 방향으로 진행하는 것이 본래의 최소값과 다른 방향을 가리켜서라는 점도 생각해볼 필요가 있습니다.
• 이때 확률적 경사 하강법 - Stochastic Gradient Descent(SGD)의 단점들을 개선해주는 Momentum(모멘텀), AdaGrad, Adam이라는 3가지 방법을 한번 보겠습니다.

---

Stochastic Gradient Descent(SGD) 대체 기법

Momentum (모멘텀)

Momentum(모멘텀)은 물리에서 '운동량'을 뜻하는 단어입니다. 수식을 한번 보겠습니다.

v ← αv − η ∗ ∂L/∂W
W ← W + v

• 여기서 'W'는 갱신할 'Weight Parameter' (가중치 매개변수)
• '∂L / ∂W' 는 'W'에 대한 Loss Function(손실 함수)의 Gradient(기울기)입니다.
• 'η': 학습률을 의미하는데 정해진 상수값(보통 0.01이나, 0.001과 같은 값을 미리 정함)을 사용합니다.
• 'v': 속도를 의미하는데 Gradient(기울기) 방향으로 힘을 받아 물체가 가속되는 것을 나타냅니다.
• 'α': 물리에서의 지면 마찰 & 공기 저항에 해당합니다. (0.9 등의 값으로 설정합니다)
• 아래 코드는 Momentum을 구현한 코드 입니다.

import numpy as np

class Momentum:
    def __init__(self, lr=0.01, momentum=0.9):
        self.lr = lr  # 학습률(learning rate)
        self.momentum = momentum  # 모멘텀(momentum) 파라미터
        self.v = None  # 모멘텀을 저장하기 위한 딕셔너리

    def update(self, params, grads):
        if self.v is None:
            self.v = {}  # v를 초기화합니다.
            for key, val in params.items():
                self.v[key] = np.zeros_like(val)  # 각 파라미터에 대해 모멘텀을 0으로 초기화합니다.

        for key in params.keys():
            # 모든 파라미터에 대해 반복하여 업데이트 수행
            # 모멘텀을 이용하여 파라미터 업데이트
            self.v[key] = self.momentum * self.v[key] - self.lr * grads[key]
            params[key] += self.v[key]  # 새로운 파라미터 값 적용

• Momentum(모멘텀)을 사용해서 아래의 수식의 최적화 문제를 풀어보겠습니다.

• 그림에서 보듯, Momentum(모멘텀)의 갱신 경로는 공이 바락을 구르듯 움직입니다. '지그재그 정도'가 덜한 것을 알 수 있습니다.
• 이는 x축의 힘은 아주 작지만 방향은 변하지 않아서 한 방향으로 일정하게 가속하기 때문입니다.
• 거꾸로 y축의 힘은 크지만 위아래로 번갈아 받아서 상층하여 y축 방향의 속도는 안정적이지 않습니다.
• 전체적으로 확률적 경사 하강법 - Stochastic Gradient Descent(SGD)보다 x축 방향으로 빠르게 다가가 지그재그 움직임이 줄어듭니다.

---

AdaGrad

• Learning Rate(학습률 - η)이 너무 작으면 학습 시간이 길어지고, 너무 크면 발산하여 학습이 제대로 이뤄지지 않습니다.
• 이 Learning Rate(학습률) 확률적 감소(learning rate decay)는 Learning Rate(학습률)을 점차 줄이는 방식입니다.
• Learning Rate(학습률)을 서서히 낮추는 가장 간단한 방법은 Parameter(매개변수) 전체의 Learning Rate(학습률)값을 일괄적으로 낮추는 것을 발전 시킨것이 AdaGrad입니다.
• AdaGrad 방식은 '각각의' Parameter(매개변수)에 맞게 '맞춤형' 값을 만들고 Adaptive(적응적)으로 Learning Rate(학습률)을 조정하면서 학습을 진행합니다. 수식은 아래와 같습니다.

AdaGrad 수식

h ← h + ∂L/∂W ⊙ ∂L/∂W
W← W − η ∗ 1/√h ∗ ∂L/∂W

• 여기서 'W'는 갱신할 'Weight Parameter' (가중치 매개변수)
• '∂L / ∂W' 는 'W'에 대한 Loss Function(손실 함수)의 Gradient(기울기)입니다.
• 'η': 학습률을 의미하는데 정해진 상수값(보통 0.01이나, 0.001과 같은 값을 미리 정함)을 사용합니다.
• 'h'는 기존 기울기 값을 제곱하여 계속 더해줍니다. '⊙'는 행렬별 원소의 곱셈을 의미합니다.
• 또한 Parameter(매개변수)를 갱신할때 1/√h를 곱해 Learning Rate(학습률)을 조정합니다.
• Parameter(매개변수)의 원소 중에서 많이 움직인(크게 갱신된) 왼소는 Learning Rate(학습률)이 낮아지는데, Learning Rate(학습률) 감소가 Parameter(매개변수)의 원소마다 다르게 적용됩니다. 이유는 무엇일까요?

AdaGrad는 과거의 기울기를 제곱하여 계속 더하기 때문에 학습을 진행할수록 갱신 강도가 약해집니다.
이 문제를 개선한 기법으로 RMSProp이 있다. RMSProp에서는 먼 과거의 기울기는 서서히 잊고 새로운 기울기 정보를 크게 반영합니다.
이를 지수이동평균(Exponential Moving Average)이라 하며 과거 기울기의 반영 규모를 기하급수적으로 감소시킵니다.

• 그러면 한번 AdaGrad의 구현을 한번 살펴 보겠습니다.

import numpy as np

class AdaGrad:
    def __init__(self, lr=0.01):
        self.lr = lr  # 학습률(learning rate)
        self.h = None  # 매개변수에 대한 제곱 그래디언트를 누적하기 위한 딕셔너리

    def update(self, params, grads):
        if self.h is None:
            self.h = {}  # h를 초기화
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)  # 각 매개변수에 대한 h를 0으로 초기화
        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)  
            # 매개변수 업데이트: 학습률을 적응적으로 조정하여 업데이트
            # np.sqrt(self.h[key]) + 1e-7는 0으로 나누는 것을 방지하기 위한 작은 값

• 주의해서 봐야하는 것은 마지막줄에 1e-7이라는 작은 값을 더하는 부분입니다. 이 작은 값은 0으로 나누는 것을 방지하기 위한 작은 값입니다.
• self.h[key]에 0이 담겨있다 해도, 0으로 나누는 사태를 방지합니다.

---

Adam

Adam은 Momentum(모멘텀)과 AdaGrad를 융합한 듯한 방법입니다. 

• 특징은 하이퍼파라미터의 '편향 보정'이 진행이 된다는것이 Adam의 특징입니다. 
• 한번 Adam 클래스 코드를 한번 보고 최적화 문제를 풀어본 결과는 아래의 그림과 같습니다.

class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        self.lr = lr  # 학습률(learning rate)
        self.beta1 = beta1  # 모멘텀(momentum)의 지수 가중 평균 파라미터
        self.beta2 = beta2  # RMSProp의 지수 가중 평균 파라미터
        self.iter = 0  # 반복 횟수
        self.m = None  # 1차 모멘텀
        self.v = None  # 2차 모멘텀

    def update(self, params, grads):
        if self.m is None:
            self.m, self.v = {}, {}
            for key, val in params.items():
                self.m[key] = np.zeros_like(val)  # 각 매개변수에 대한 1차 모멘텀을 0으로 초기화합니다.
                self.v[key] = np.zeros_like(val)  # 각 매개변수에 대한 2차 모멘텀을 0으로 초기화합니다.

        self.iter += 1
        lr_t = self.lr * np.sqrt(1.0 - self.beta2**self.iter) / (1.0 - self.beta1**self.iter)  
        # 편향 보정된 학습률 계산

        for key in params.keys():
            self.m[key] += (1 - self.beta1) * (grads[key] - self.m[key])  # 1차 모멘텀 업데이트
            self.v[key] += (1 - self.beta2) * (grads[key]**2 - self.v[key])  # 2차 모멘텀 업데이트
            params[key] -= lr_t * self.m[key] / (np.sqrt(self.v[key]) + 1e-7)  # 매개변수 업데이트

• Adam 갱신 과정도 그릇 바닥을 구르듯 움직입니다. 이 패턴은 Momentum(모멘텀)과 비슷하지만,  Momentum(모멘텀)보다 공의 좌우 흔들림이 적습니다. 이는 학습의 갱신 강도를 Adaptive(적응적)으로 조정해서 얻는 혜택입니다.

---

어떠한 갱신 방법을 사용할까요?

지금까지 4개의 최적화 기법. SGD, Momentum, AdaGrad, Adam을 알아보았습니다.

• 결과는 문제에 따라 달리질수도 있으니까 주의해야합니다. 그리고 Hyperparameter(Learning Rate등..)을 어떻게 설정하느냐에 따라서 결과도 봐뀝니다.
• 즉, 결론은 모든 문제에서 항상 뛰어난 기법은 없습니다. 상황을 고려해서 여러가지로 시도해봐야 합니다.

---

Weight(가중치)의 초깃값

만약 초깃값을 0을 하면?

Overfitting(오버피팅)을 억제해 범용 성능을 높이는 Weight Decay(가중치 감소) 기법은 Parameter(매개변수)의 값이 작아지도록 학습하는 방법입니다. Weight(가중치)값을 작게하여 Overfitting(오버피팅)이 일어나게 하지 않는 것입니다.

• 만약 Weight(가중치) 초기값을 0으로 하면 어떻게 될까요?
• 학습이 제대로 일어나지 않습니다. 이유는 바로 Backpropagation(오차역전파법)에서 모든 Weight(가중치)의 값이 똑같이 갱신되기 때문입니다.
• 예를 들어서 2-Layer Neural Network(2층 신경망)에서 첫번째, 두번째 Layer의 Weight(가중치)가 0이면, Forward Propagation(순전파)때의 Input Layer(입력층)의 Weight(가중치)가 0이기 때문에 두번째 Layer의 Neuron에 모두 같은 값이 전달됩니다. 
  • 즉, Backpropagation(역전파)때의 두번째 Layer의 Weight(가중치)가 모두 똑같이 갱신된다는 말이 됩니다.
• 이 상황을 막으러면 초깃값을 무작위로 설정을 해야 한다는 점이 있습니다.

---

Hidden Layer(은닉층)의 활성화값 분포

Hidden Layer(은닉층)의 활성화값의 분포를 관찰하면 중요한 정보를 얻을수 있습니다.

• Activation Function(활성화 함수)로 Sigmoid Function(시그모이드 함수)로 사용하는 5-Layer Neural Network(5층 신경망)에 무작위로 생성한 입력 데이터를 흘려보겠습니다.
• 그리고 각 Layer의 Activation Value(활성화값) 분포를 한번 Histogram(히스토그램)으로 보면서 Weight(가중치)의 초깃값에 따라 Hidden Layer(은닉층)의 Activation Value(활성화값)이 어떻게 변화하는지 한번 보겠습니다.

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

# 시그모이드 함수 정의
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
    
# 입력 데이터 생성 (1000개의 데이터, 각 데이터는 100개의 특성을 가짐)
input_data = np.random.randn(1000, 100)

# 각 은닉층의 노드(뉴런) 수
node_num = 100

# 은닉층 개수
hidden_layer_size = 5

# 은닉층의 활성화 값을 저장할 딕셔너리
activations = {}

# 입력 데이터로부터 순전파 시작
x = input_data

# 각 은닉층에 대해 순전파 수행
for i in range(hidden_layer_size):
    # 첫 번째 은닉층일 경우 입력 데이터를 사용하고,
    # 그 이후의 은닉층부터는 이전 은닉층의 활성화 값을 사용
    if i != 0:
        x = activations[i-1]
    
    # 가중치 초기화 (평균이 0, 표준편차가 1인 정규분포를 따르는 난수)
    w = np.random.randn(node_num, node_num) * 1
    
    # 가중합 계산
    a = np.dot(x, w)
    
    # 활성화 함수 적용 (시그모이드 함수)
    z = sigmoid(a)
    
    # 활성화 결과를 딕셔너리에 저장
    activations[i] = z

• Layer가 5개가 있으며, 각 층의 Neuron은 100개 씩입니다.
• Input Data로서 1,000개의 데이터를 정규분포로 무작위로 생성하여 이 5-Layer Neural Network에 흘립니다.
• Activation 결과를 activation 변수에 저장합니다.
• 그리고 반복문을 통해서 아래의 과정을 계속 반복합니다.
  • 첫 번째 은닉층일 경우, 입력 데이터 x는 input_data로 초기화합니다. 그 이후의 은닉층은 이전 은닉층의 활성화 값을 사용합니다.
  • 가중치 w는 평균이 0이고 표준 편차가 1인 정규분포를 따르는 난수로 초기화합니다.
  • 행렬 곱 연산을 통해 입력 데이터와 가중치를 곱한 후, 그 결과를 시그모이드 함수에 적용하여 활성화 값을 계산합니다.
  • 이를 activations 딕셔너리에 저장합니다.

# 히스토그램 그리기
for i, a in activations.items():
    plt.subplot(1, len(activations), i+1)
    plt.title(str(i+1) + "-layer")
    plt.hist(a.flatten(), 30, range=(0,1))
plt.show()

Weight(가중치)를 표준편차가 1인 정규분포로 초기화 할때의 각 Layer의 Activation value(활성화값) 분포

• 그림을 보면 각 Layer의 Activaiton 값이 0, 1에 다 치우쳐 분포되어 있습니다.
• Sigmoid Function(시그모이드 함수)는 Output이 0,1에 가까워지면 미분은 0에 다가갑니다.
• 그래서 데이터가 0, 1에 치우쳐 분포하게 되면 Backpropagation(역전파)의 Gradient(기울기)값이 점점 작아지다가 사라집니다.
• 이 현상을 Gradient Vanishing(기울기 손실)이라고 합니다.

---

이번에는 Weight(가중치)의 표준편차를 0.01로 봐꿔서 해보겠습니다. 가중치 초깃값 설정 부분을 봐꾸면 됩니다.

# 가중치 초기화 (평균이 0, 표준편차가 1인 정규분포를 따르는 난수)
w = np.random.randn(node_num, node_num) * 0.01

• 그림을 보면 0.5 부근에 집중되었습니다. 0과 1 사이에 치우치진 않았으나 Gradient Vanishing 문제는 일어나지 않습니다.
• 근데 Activation Value(활성화 값)들이 치우쳤다는 것은 표현력 관점 부분에서는 큰 문제가 됩니다.
• 다수의 Neuron들이 같은 값이 출력하고 있는건 Neuron이 여러개 둔 의미가 없다는 것입니다.
• 그래서 Activation Value(활성화 값)들이 치우치면 표현력을 제한한다는 관점에서는 문제가 됩니다.

---

Xavier 초기값

Xavier 초깃값은 일반적인 딥러닝 프레임워크들이 표준적으로 사용하고 있습니다.

• Xavier 초깃값 : 초깃값의 표준편차가 1/√n이 되도록 설정합니다.
• n : 앞 층의 노드 수입니다.

Xavier 초기값: 초깃값의 표준편차가 1/√n이 되도록 설정합니다.

• Xavier 초깃값을 사용하면 앞 층의 노드가 많을수록 대상 노드의 초깃값으로 설정하는 가중치가 좁게 퍼집니다.
• 한번 Xavier 초깃값을 사용해서 실험해 보겠습니다.

node_num = 100 # 앞층의 노드 수
w = np.random.randn(node_num, node_num) / np.sqrt(node_num)

가중치의 초깃값으로 'Xavier 초기값'을 이용할 때의 각 층의 활성화값 분포

• Xavier 초깃값을 사용한 결과는 위의 결과처럼 됩니다. 위의 결과를 보면 층이 깊어지면서 형태가 얼그러집니다.
• 다만 앞선 방식들 보다는 확실히 넓게 분포됨을 알 수 있습니다. 데이터도 적당히 퍼져있고, Sigmoid 함수의 표현력도 제한받지 않으면서 학습이 효율적으로 이뤄질 것으로 기대됩니다.

층이 깊어지면 일그러지는 현상은 sigmoid 함수 대신 tanh(쌍곡선 함수)를 이용하면 개선됩니다.
tanh 함수도 S자 곡선이지만 (0, 0.5)에서 대칭인 시그모이드와는 다르게 원점 대칭입니다.
활성화 함수용으로는 원점에서 대칭인 함수가 바람직하다고 알려져 있습니다.

---

ReLU를 사용할때의 Weight(가중치) 초깃값 - He 초깃값

• ReLU로 Activation Function(활성화 함수)를 사용할 때에는 ReLU에 특화된 초깃값을 이용하라고 보통은 권장합니다. 
• 이 특화된 초깃값을 He 초깃값 이라고 합니다.
• He 초깃값은 앞 층의 노드가 n개일 때, 표준편차가 √(2/n)인 정규분포를 사용합니다. 이유는 무엇일까요? (Xavier 초깃값은 √(1/n))
• ReLU는 음의 영역이 0이라서 더 넓게 분포시키기 위해 2배의 계수가 필요하기 때문입니다.
• 그러면 한번 활성화값 분포를 보겠습니다.

• 표준편차가 0.01인 정규분포를 가중치 초깃값으로 사용한 경우? 각 층의 활성화값들은 아주 작은 값입니다.
  • 작은 값들이 흐르면 Backpropagation(역전파)때 Weight(가중치)의 Gradient(기울기)역시 작아진다는 의미입니다.
• Xavier 초깃값을 사용한 경우 에는 층이 깊어지면서 치우침이 조금씩 커집니다. 이 문제는 Gradient Loss(기울기 소실)문제가 발생 할 수 있습니다.
• He 초깃값을 사용한 경우 모든 층에서 균일하게 분포되었습니다. Backpropagation(역전파) 때도 적절한 값이 나옵니다.

Summary: 활성화 함수로 ReLU를 사용할 때는 He 초깃값을, S자 모양 곡선(sigmoid, tanh)일 때는 Xavier 초깃값을 사용합니다.

---

Ex. Mnist Dataset으로 본 Weight(가중치) 초깃값 비교

한번 Mnist Dataset으로 가지고 한번 Weight(가중치)의 초깃값을 주는 방식이 신경망 학습에 얼마나 영향을 주는지 한번 보겠습니다.

 

# 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.util import smooth_curve
from common.multi_layer_net import MultiLayerNet
from common.optimizer import SGD


# 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. 실험용 설정==========
weight_init_types = {'std=0.01': 0.01, 'Xavier': 'sigmoid', 'He': 'relu'}
optimizer = SGD(lr=0.01)

networks = {}
train_loss = {}
for key, weight_type in weight_init_types.items():
    networks[key] = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100],
                                  output_size=10, weight_init_std=weight_type)
    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 weight_init_types.keys():
        grads = networks[key].gradient(x_batch, t_batch)
        optimizer.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 weight_init_types.keys():
            loss = networks[key].loss(x_batch, t_batch)
            print(key + ":" + str(loss))


# 3. 그래프 그리기==========
markers = {'std=0.01': 'o', 'Xavier': 's', 'He': 'D'}
x = np.arange(max_iterations)
for key in weight_init_types.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, 2.5)
plt.legend()
plt.show()

• 뉴런 수가 100개인 5층 신경망에서 활성화 함수로 ReLU를 사용을 했습니다
• std=0.01일 때는 학습이 전혀 이뤄지지 않았고, Xavier와 He 초깃값의 경우는 학습이 순조롭게 이뤄진 것을 확인할 수 있습니다.
• 그리고 학습 진도는 He 초깃값 쪽이 더 빠르다고 알 수 있습니다.
• 또한 Weight(가중치) 초깃값이 중요하다는 것을 알 수 있습니다.