[DL] 단순한 Layer 구현해보기

 

이번글에서는 단순한 Layer 부터 한번 구현해 보겠습니다.

• 앞의 글에서본 계산 그래프의 곱셈 노드를 'MultiLayer', 덧셈 노드를 'AddLayer'라는 이름으로 구현합니다.

곱셈 계층

• 모든 계층은 forward()와 backward()라는 공통의 Method(인터페이스)를 갖도록 구현합니다.
• forward()는 Forward Propagation(순전파), backward()는 Back propagation(역전파)를 처리합니다.
• 한번 구현해 보겠습니다.

# coding: utf-8

class MulLayer:
    def __init__(self):
        self.x = None
        self.y = None

	# x와 y를 인수라 받고 두 값을 곱해서 반환
    def forward(self, x, y):
        self.x = x
        self.y = y                
        out = x * y

        return out

	# 상류에서 넘어온 미분(dout)에 순전파 때의 값을 
    # 서로 바꿔 곱한 후 하류로 흘려줌
    def backward(self, dout):
        dx = dout * self.y  # x와 y를 바꾼다.
        dy = dout * self.x

        return dx, dy

• 인스턴스 변수인 x,y를 초기화 합니다. 이 두 변수는 Forward PropagatIon(순전파)시 입력 값을 유지하기 위해서 사용합니다.
• forward()에서는 x, y를 인수로 받고 두 값을 곱해서 반환 합니다.
• 반면 backward()에서는 상류에서 넘어온 미분(dout)에 Forward PropagatIon(순전파) 때의 값을 '서로 봐꿔' 곱한 후 하류로 흘립니다.

• MulLayer를 사용하여 순전파를 다음과 같이 구현할 수 있습니다.

# coding: utf-8
from layer_naive import *

apple = 100
apple_num = 2
tax = 1.1

mul_apple_layer = MulLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple, apple_num)
price = mul_tax_layer.forward(apple_price, tax)

print(price) # 200

• 각 변수에 대한 미분은 backward() 에서 구할 수 있습니다.

# backward (역전파)

dprice = 1
dapple_price, dtax = mul_tax_layer.backward(dprice)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)

print(dapple, dapple_num, dtax) # 2.2 110 200

• backward() 역전파의 호출 순서는 forward() 순전파 때와는 반대입니다.
• 또, backward()가 받는 인수는 '순전파의 출력에 대한 미분'임에 주의합니다.

---

덧셈 계층

class AddLayer:
	def __init__(self):
    	pass
        
	# 입력받은 두 인수 x, y를 더해서 반환
    def forward(self, x, y):
    	out = x + y
        return out
        
	# 상류에서 내려온 미분(dout)을 그대로 하류로 흘려줌
    def backward(self, dout):
    	dx = dout * 1
        dy = dout * 1
        return dx, dy

• 덧셈 계층에서는 초기화가 필요 없기 때문에 _init_()에서는 아무 일도 하지 않습니다.
  • 즉, pass는 아무것도 하지 말라는 명령입니다.
• 덧셈 계층의 forward()에서는 입력받은 두 인수 x, y를 더해서 반환합니다.
• backward()에서는 상류에서 내려온 미분(dout)을 그대로 하류로 흘릴 뿐입니다.

그러면 덧셈, 곱셈 계층을 사용하여 사과 2개와 귤 3개를 사는 상황을 구현해 보겠습니다.

# coding: utf-8
from layer_naive import *

apple = 100
apple_num = 2
orange = 150
orange_num = 3
tax = 1.1

# layer
mul_apple_layer = MulLayer()
mul_orange_layer = MulLayer()
add_apple_orange_layer = AddLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple, apple_num)  # (1)
orange_price = mul_orange_layer.forward(orange, orange_num)  # (2)
all_price = add_apple_orange_layer.forward(apple_price, orange_price)  # (3)
price = mul_tax_layer.forward(all_price, tax)  # (4)

# backward
dprice = 1
dall_price, dtax = mul_tax_layer.backward(dprice)  # (4)
dapple_price, dorange_price = add_apple_orange_layer.backward(dall_price)  # (3)
dorange, dorange_num = mul_orange_layer.backward(dorange_price)  # (2)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)  # (1)

print("price:", int(price))
print("dApple:", dapple)
print("dApple_num:", int(dapple_num))
print("dOrange:", dorange)
print("dOrange_num:", int(dorange_num))
print("dTax:", dtax)

• 하나하나의 명령은 단순합니다. 필요한 계층을 만들어서 Forward Propagation(순전파) Method인 forward()를 적절한 순서로 호출합니다.
• 그런 다음 Forward Propagation(순전파)와 반대 순서로 Back Propagation(역전파) Method인 Backward()를 호출하면 원하는 미분이 나옵니다.

---

Model Code (by Python)

# 곱셈 계층 정의
class MulLayer:
    def __init__(self):
        self.x = None  # 순전파 입력값 유지를 위해서 초기화
        self.y = None  # 순전파 입력값 유지를 위해서 초기화

    def forward(self, x, y):
        self.x = x  # 순전파 시 입력된 x값 저장
        self.y = y  # 순전파 시 입력된 y값 저장
        out = x * y  # 입력된 두 값의 곱 반환
        return out

# 상류에서 넘어온 미분(dout)에서 순전파 때의 값을 서로 봐꿔 곱한 후 하류로 흘림
    def backward(self, dout):
        dx = dout * self.y  # x에 대한 미분값 계산
        dy = dout * self.x  # y에 대한 미분값 계산
        return dx, dy  # 미분 결과 반환


# 덧셈 계층 정의
class AddLayer:
    def __init__(self):
        pass  # 덧셈 계층은 별도의 초기화 작업이 필요 없음

    def forward(self, x, y):
        out = x + y  # 입력된 두 값의 합 반환
        return out

# 상류에서 넘어온 미분(dout)에서 순전파 때의 값을 서로 봐꿔 곱한 후 하류로 흘림
    def backward(self, dout):
        dx = dout * 1  # x에 대한 미분값 계산
        dy = dout * 1  # y에 대한 미분값 계산
        return dx, dy  # 미분 결과 반환


if __name__ == '__main__':
    # 문제1: 사과 가격 계산 예시
    apple = 100  # 사과 한 개 가격
    apple_num = 2  # 사과 개수
    tax = 1.1  # 세금

    # 계층 생성
    mul_apple_layer = MulLayer()  # 사과 가격 계산을 위한 곱셈 계층
    mul_tax_layer = MulLayer()  # 세금 계산을 위한 곱셈 계층

    # 순전파
    apple_price = mul_apple_layer.forward(apple, apple_num)  # 사과 가격 계산
    price = mul_tax_layer.forward(apple_price, tax)  # 최종 가격 계산

    print(price)  # 최종 가격 출력

    # 역전파
    dprice = 1  # 가격에 대한 미분값 초기화
    dapple_price, dtax = mul_tax_layer.backward(dprice)  # 세금 계산 역전파
    dapple, dapple_num = mul_apple_layer.backward(dapple_price)  # 사과 가격 계산 역전파

    print(dapple, dapple_num, dtax)  # 미분 결과 출력

    # 문제2: 사과와 오렌지 가격 계산 예시
    orange = 150  # 오렌지 한 개 가격
    orange_num = 3  # 오렌지 개수

    # 계층 재사용 및 새로운 계층 생성
    mul_apple_layer = MulLayer()  # 사과 가격 계산을 위한 곱셈 계층 (재사용)
    mul_orange_layer = MulLayer()  # 오렌지 가격 계산을 위한 곱셈 계층
    add_apple_orange_layer = AddLayer()  # 사과와 오렌지 가격 합산을 위한 덧셈 계층
    mul_tax_layer = MulLayer()  # 세금 계산을 위한 곱셈 계층 (재사용)

    # 순전파
    apple_price = mul_apple_layer.forward(apple, apple_num)  # 사과 가격 계산
    orange_price = mul_orange_layer.forward(orange, orange_num)  # 오렌지 가격 계산
    all_price = add_apple_orange_layer.forward(apple_price,

---

Activation Function Layer (활성화 함수 계층) 구현하기

계산 그래프를 신경망에 적용해 보겠습니다. 신경망을 구성하는 Layer(계층)을 각각의 클래스 하나로 구현합니다.

ReLU 계층

• 활성화 함수로 사용되는 ReLU의 수식은 다음과 같습니다.

• x에 대한 y의 미분은 아래의 식처럼 구합니다.

• 위의 수식과 같이, Forward Propagation(순전파) 때의 입력인 x가 0보다 크면 Back Propagation(역전파)는 상류의 값을 그대로 하류로 흘립니다.
• 다만, Forward Propagation(순전파) 때 x가 0 이하면 Back Propagation(역전파) 때는 하류로 신호를 보내지 않습니다. (0을 보냅니다.) 계산 그래프로는 아래의 그림처럼 그립니다.

• 이제 한번 ReLU 계츨을 구현해 보겠습니다.

class Relu:
    def __init__(self):
        self.mask = None  # 입력값이 0 이하인지 여부를 저장하기 위한 변수를 초기화합니다.

    def forward(self, x):
        self.mask = (x <= 0)  # x의 값이 0 이하인 원소는 True, 그 외는 False로 하는 배열을 생성합니다.
        out = x.copy()  # 입력값 x의 복사본을 생성합니다.
        out[self.mask] = 0  # mask가 True인 위치, 즉 x의 값이 0 이하인 위치의 원소를 0으로 설정합니다.
        
        return out  # 활성화 함수를 적용한 결과를 반환합니다.
        
    def backward(self, dout):
        dout[self.mask] = 0  # 순전파 때 0 이하였던 원소에 대응하는 역전파 값은 0으로 설정합니다.
        dx = dout  # 나머지 원소는 그대로 dout을 반환합니다.
        
        return dx  # 입력값에 대한 미분값을 반환합니다.

• ReLU 클래스는 mask라는 인스턴스 변수를 가집니다.
• mask는 True/False로 구성된 Numpy Array(배열)로, Forward Propagation(순전파)의 입력인 x의 원소 값이 0이하인 index는 True, 그 외(0보다 큰 원소)는 False로 유지합니다.
• 예컨대 mask 변수는 True/False로 구성된 Numpy 배열을 유지합니다.

---

Sigmoid 계층

• Sigmoid 함수는 다음 식을 의미합니다.

• 위의 식을 계산 그래프로 그리면 아래의 그림처럼 됩니다.

Sigmoid 계층의 계산 그래프 (Forward Propagation - 순전파)

• 'x'와 '+' 노드말고도, 'exp' ,'/' 노드가 있는데, 'exp' 노드는 y = exp(x) 계산을 수행하고 '/' 노드는 y = 1/x 계산을 수행합니다.
• 계산은 '국소적 계산'의 전파로 이뤄집니다. 이제 위의 계산 그래프의 Back Propagation(역전파)의 흐름을 오른쪽에서 왼쪽으로 한 단계씩 싶어보겠습니다.

1단계

• '/' 노드, y = 1/x 을 미분하면 다음 식이 됩니다.

• Back Propagation(역전파) 때는 상류에서 흘러온 값에 -y**2 (순전파의 출력을 제곱한 후 마이너스를 붙인 값)을 곱해서 하류로 전달합니다.
• 계산 그래프에서는 다음과 같습니다.

2단계

• '+'노드는 상류의 값을 여과 없이 하류로 내보내지는게 다입니다.

3단계

• 'exp' 노드는 y = exp(x) 연산을 수행하며, 그 미분은 다음과 같습니다.

• 계산 그래프에서는 상류의 값에 Forward Propagation(순전파) 때의 출략(이 예에서는 exp(-x))을 곱해 하류로 전파합니다.

4단계

• 'x'노드는 Forward Propagation(순전파) 때의 값을 '서로 봐꿔' 곱합니다. 여기서는 -1를 곱합니다.

• 위에 계산 그래프를 보면, Sigmoid 계층의 Back Propagation(역전파)를 계산 그래프를 완성했습니다.
• 이러한 계산 그래프의 중간 과정을 모두 묶어 단순한 'Sigmoid' 노드 하나로 대체할 수 있습니다.

Sigmoid 계층의 계산 그래프 (간소화 버전)

• 계산 그래프와, 간소화 그래프의 간소화 버전의 결과는 같습니다.
• 그렇지만, 간소화 버전은 Back Propagation(역전파) 과정의 중간 과정을 생략하여 더 효율적인 계산이라고 할 수 있습니다.
• 또한 Node를 그룹화 하여 Sigmoid 계층의 세세한 내용을 노출하지 않고 입력, 출력에만 집중 할 수 있다는 것도 좋은 포인트 입니다.

미분 수식 정리

• 이처럼 Sigmoid 계층의 Back Propagation(역전파)는 Forward Progagation(순전파)의 출력(y)만으로 계산할 수 있습니다.

Sigmoid 계층의 계산 그래프: 순전파의 출력 y만으로 역전파를 계산할 수 있다.

• 그러면 한번 Sigmoid 계층을 Python으로 구현해 보겠습니다.
• 여기서는 Forward Progagation(순전파)의 출력을 인스턴스 변수 out에 보관했다가, Back Propagation(역전파)때 그 값을 사용합니다.

class Sigmoid:
    def __init__(self):
        self.out = None  # 순전파의 출력값을 저장하기 위한 변수를 초기화합니다.

    def forward(self, x):
        out = 1 / (1 + np.exp(-x))  # 시그모이드 함수를 적용합니다.
        self.out = out  # 순전파의 결과를 저장합니다. 이 값은 역전파 때 사용됩니다.
        return out  # 활성화 함수를 적용한 결과를 반환합니다.
        
    def backward(self, dout):
        dx = dout * (1.0 - self.out) * self.out  # 시그모이드 함수의 미분을 적용합니다.
        return dx  # 입력값에 대한 미분값을 반환합니다.
        
# dout은 상류(다음 계층)에서 넘어온 미분값입니다.
# 시그모이드 함수의 미분은 y(1-y)이며, 여기서 y는 시그모이드 함수의 출력값입니다.
# 따라서, self.out이 y에 해당하고, (1.0 - self.out) * self.out이 y(1-y)에 해당합니다.
# 이를 상류에서 넘어온 미분값과 곱하여 이 계층을 통과할 때의 미분값을 구합니다.

---

Affine 계층

신경망의 Forward Propagation(순전파)에서는 Weight(가중치) 신호의 총합을 계산하기 때문에 행렬의 곱(Numpy에서는 np.dot())을 사용했습니다.

• Neuron(뉴런)의 Weight(가중치) 합은 Y = np.dot(X, W) + B처럼 계산합니다.
• 그리고 이 Y를 Activation Function(활성화 함수)로 변환해 다음 Layer(층)으로 전파하는 것이 신경망 Forward Propagation(순전파)의 흐름이였습니다.
• 행렬의 곱 계산은 대응하는 Dimension(차원)의 원소 수를 일치시키는게 핵심입니다. 행렬의 형상을 (2, 3)처럼 괄호로 표기하는 이뉴는 Numpy shape함수의 Output(출력) & 형태를 통일하기 위해서 입니다.

신경망의 Forward Propagation(순전파) 때 수행하는 행렬의 곱은 기하학에서 Affine Transformation(어파인 변환)이라고 합니다.

• 그러면 행렬의 곱과 Bias(편향)의 합을 계산 그래프로 한번 그려보겠습니다.
• 곱을 계산하는 노드를 'dot'이라 하면 np.dot(X, W) + B 계산은 아래의 그래프처럼 그려집니다.
• 참고로 지금까지의 계산 그래프는 노드 사이에 '스칼라 값'이 흘렀는데 반해, 이 예에서는 '행렬'이 흐르고 있습니다.

Affine 계층의 계산 그래프: 변수가 행렬임에 주의, 각 변수의 형상을 변수명 위에 표기

• 그러면 이번에는 Back propagation(역전파)에 대해 생각해 보겠습니다.
• 행렬을 사용한 Back propagation(역전파)도 행렬의 원소마다 전개해보면 스칼라 값을 사용한 지금까지의 계산 그래프와 같은 순서로 생각할 수 있습니다.
• WT의 T는 전치행렬을 뜻하며, W의 (i, j) 위치의 원소를 (j,i) 위치로 봐꾼것을 말합니다.

Affine 계층의 역전파, 변수가 다차원 배열임에 주의.

• 계산그래프에서 각 변수의 형상에 주의해서 살펴 봐야 합니다.
• 특히 X와 δL/δX은 같은 형상이고, W와 δL/δW도 같은 형상이라는 것을 기억하세요.

• 근데, 여기서 의문이 드는게 있습니다. 왜 행렬의 형상에 주의를 해야 할까요?
• 행렬의 곱에서 대응하는 차원의 원소 수를 일치시켜야 하기 때문입니다.

행렬 곱('dot' 노드)의 역전파는 행렬에 대응하는 차원의 원소수가 일치하도록 곱을 조립하여 구할 수 있다.

---

배치용 Affine 계층

• Affine 계층은 입력 데이터로 X 하나만을 고려한 것이였습니다.
• 이번 절에서는 데이터 N개를 묶어 Forward Propagation(순전파)하는 경우, 즉, 배치용 Affine 계층을 생각해 보겠습니다.
• 여기서 묶은 데이터를 '배치'라고 부릅니다.

배치용 Affine 계층의 계산 그래프

• 기존과 다른 부분은 input(입력)인 X의 형상이 (N, 2)가 된 것 뿐입니다. 그 뒤로는 지금까지와 같이 계산 그래프의 순서를 따라 순순히 행렬 계산을 합니다.
• 또한 Back propagation(역전파) 때는 행렬의 형상에 주의하면 δL/δX과 δL/δW은 이전과 같이 도출할 수 있습니다.
• 편항을 더할때도 주의해야 합니다. Forward Propagation(순전파)의 Bias(편향) 덧셈은 X, W에 대한 Bias(편향)이 각각의 데이터에 더해집니다.
• 그래서 Back propagation(역전파) 때는 각 데이터의 Back propagation(역전파)값이 Bias(편향)의 원소에 모여야 합니다.
• 이렇게 Affine 계층은 이렇게 구현 할 수 있습니다.

class Affine:
    def __init__(self, W, b):
        self.W = W  # 가중치(weight)를 초기화합니다.
        self.b = b  # 편향(bias)을 초기화합니다.
        self.x = None  # 입력 데이터를 저장하기 위한 변수를 초기화합니다.
        self.dW = None  # 가중치의 기울기를 저장하기 위한 변수를 초기화합니다.
        self.db = None  # 편향의 기울기를 저장하기 위한 변수를 초기화합니다.

    def forward(self, x):
        self.x = x  # 입력 데이터를 저장합니다.
        out = np.dot(x, self.W) + self.b  # 입력 데이터와 가중치의 내적을 계산하고 편향을 더합니다.
        return out  # 계산된 결과를 반환합니다.

    def backward(self, dout):
        dx = np.dot(dout, self.W.T)  # 상류에서 넘어온 미분값에 가중치의 전치를 곱하여 입력 데이터에 대한 미분값을 계산합니다. (오타 수정: np.dout -> np.dot, xelf.W.T -> self.W.T)
        self.dW = np.dot(self.x.T, dout)  # 입력 데이터의 전치와 상류에서 넘어온 미분값을 곱하여 가중치에 대한 미분값을 계산합니다.
        self.db = np.sum(dout, axis=0)  # 상류에서 넘어온 미분값을 축(axis) 0을 따라 합산하여 편향에 대한 미분값을 계산합니다.
        return dx  # 입력 데이터에 대한 미분값을 반환합니다.

---

Softmax-with-Loss 계층

출력층에서 사용하는 Softmax 함수에 관해 설명하겠습니다.

• Softmax 함수는 입력 값을 정규화하여 출력합니다. 예를 들어서 Mnist 데이터셋을 활용한 손글씨 숫자 인식에서의 Softmax 계층의 출력은 아래의 그림처럼 됩니다.
  • Input Image가 Affine 계층, ReLU 계층을 통과하여 변환되고, 마지막 Softmax 계층에 의해서 10개의 입력이 정규화 됩니다.
  • 이 그림에서는 숫자 '0'의 점수는 5.3이며, 이것이 Softmax 계층에 의해서 0.008(0.8%)로 변환됩니다.
  • 또한 '2'의 정수는 10.1에서 0.991(99.1%)로 변환됩니다.

• Softmax 계층은 입력 값을 정규화(출력의 합이 1이 되로록 변형)하여 출력합니다.
• 그리고 손글씨 숫자는 10개(Class 10개로 분류)이므로 Softmax 계층의 입력은 10개가 됩니다.

신경망에서 수행하는 작업은 학습, 추론 2가지 인데, 추론할때의 일반적으로 Softmax 계층을 사용하지 않습니다.
신경망은 추론할때 마지막 Affine 계층의 출력을 인식 결과로 이용합니다.
그리고 신경망에서 정규화 하지 않는 출력 결과를 Score(점수)라고 합니다.
즉, 신경망 추론에서 답을 하나만 내는 경우에는 가장 높은 Score(점수)만 알면 되니, Softmax 계층이 필요 없습니다.
다만, 신경망을 학습할때에는 Softmax 계층이 필요합니다.

• 그러면 이제 Softmax 계층을 한번 보겠습니다. Loss Function(손실 함수)인 Cross-Entropy Error(교체 엔트로피 오차)도 포함하여, 'Softmax-with-Loss 계층'이라는 이름으로 구현합니다.

Softmax-with-Loss 계층의 계산 그래프

• 보시다 시피, Softmax-with-Loss 계층은 복잡합니다. 여기서는 결과만 한번 보겠습니다.

간소화된 Softmax-with-Loss 계층의 계산 그래프

• 위의 계산 그래프에서 소프트맥수 함수는 'Softmax" 계층으로, Cross-Entropy Error'계층으로 표기했습니다.
• 여기서 3개의 클래스 분류를 가정하고 이전 Layer(계층)에서 3개의 입력(Score)를 받습니다.
• 그림과 같이 Softmax 계층은 입력 (a1, a2, a3)를 정규화하여 (y1, y2, y3)를 출력합니다.
• Cross-Entropy Error 계층은 Softmax 계층의 출력 (y1, y2, y3)와 정답 레이블 (t1, t2, t3)를 받고, 이 데이터로부터 Loss(손실) L을 출력합니다.
• 간소화된 Softmax-with-Loss 계층의 계산 그래프에서 주목할건 Back propagation(역전파)의 결과입니다.
• Softmax 계층의 Back propagation(역전파)는 (y1 - t1, y2- t2, y3 - t3)라는 '말끔한' 결과를 내놓고 있습니다.
• (y1 ~ y3)는 Softmax 계층의 출력이고, (t1 ~ t3)는 정답 레이블 이므로, (y1 - t1, y2- t2, y3 - t3)는 Softmax 계층의 출력과 정답 레이블의 차분인것입니다.
• 신경망의 Back propagation(역전파)는 이 차이인 오차가 앞 계층에 전해지는 것입니다.
• 이것이 신경망 학습의 중요한 성질입니다.
• 그러면 Softmax-with-Loss 계층을 구현한 코드를 보겠습니다.

---

Softmax-with-Loss Example Code (by Python)

class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None # 손실
        self.y = None # softmax의 출력
        self.t = None # 정답 레이블(원-핫 벡터)
        
    def forward(self, x, t):
        self.t = t
        self.y = softmax(x)  # 입력 x에 대해 softmax 함수를 적용합니다.
        self.loss = cross_entropy_error(self.y, self.t
        # softmax의 출력과 정답 레이블을 이용해 크로스 엔트로피 오차를 계산합니다.
        return self.loss  # 계산된 손실을 반환합니다.
        
    def backward(self, dout=1):
        batch_size = self.t.shape[0]  # 배치 크기를 구합니다.
        dx = (self.y - self.t) / batch_size
        # 손실 함수의 미분을 계산합니다. 여기서 dout=1은 손실 함수의 미분값이 1이라고 가정하기 때문입니다.
        return dx  # 입력값에 대한 미분값을 반환합니다.

• 주의해야 하는점은 Back propagation(역전파) 때는 전파하는 값을 Batch_size로 나눠서 데이터 1개당 오차를 앞 Layer(계층)으로 전파합니다.

---

Backprogagation(오차역전파)법 구현하기

신경망 학습의 전체적인 Flow

다시 한번 신경망 학습의 순서를 한번 보겠습니다.

전제

• 신경망에는 적응 가능한 Weight(가중치)와 Bias(편향)이 있고, 이 Weight(가중치)와 Bias(편향)을 Training Data(훈련 데이터)에 적응하도록 조정하는 과정을 Training(학습)이라고 합니다.
• 그리고 Neural Network Training(신경망 학습)은 4단계로 수행할 수 있습니다.

1단계 - Mini-Batch

• 훈련 데이터 중 일부를 무작위로 가져옵니다. 이렇게 선별한 데이터를 Mini-Batch(미니배치) 라고 합니다.
• 그리고 그 Mini-Batch(미니배치)의 Loss Function Value(손실 함수 값)을 줄이는 것이 목표입니다.

2단계 - Gradient(기울기) 산출

• Mini-Batch의 Loss Function 값을 줄이기 위해서 각 Weight Paraemter(가중치 매개변수)의 Gradient(기울기)를 구합니다.
• Gradient(기울기)는 Loss Function Value(손실 함수 값)을 가장 작게 하는 방향을 제시합니다.

3단계 - Parameter(매개변수) 갱신

• Weight Paraemter(가중치 매개변수)를 Gradient(기울기) 방향으로 아주 조금 갱신합니다.

4단계 - 반복

• 1~3단계를 반복합니다.

---

• 여기서 오차역전파법이 등장하는 단계는 2단계인 'Gradient(기울기)산출' 입니다.
• 앞에서는 이 Gradient(기울기)를 구하기 위해서 수치 미분을 사용했지만, 오차역전파법을 이용하면 Gradient(기울기)를 효율적, 빠르게 구할 수 있습니다.

---

오차역전파법을 이용한 신경망 구현하기

여기서 2층 신경망은 TwoLayerNet 클래스로 구현합니다. 한번 클래스 & 인스턴스 변수 및 Method를 정의한 표들을 살펴보겠습니다.

TwoLayerNet 클래스 & 인스턴스 변수

TwoLayerNet 클래스 & Method

• 알아야 할점은, Layer(계층)을 사용한다는 점입니다.
• Layer(계층)을 사용함으로써 인식 결과를 얻는 처리(predict())와 Gradient(기울기)를 구하는 처리 (gradient()) 계층의 전파만으로 동작이 이루어 집니다.

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


class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
        # 가중치 초기화
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) 
        self.params['b2'] = np.zeros(output_size)

        # 계층 생성
        self.layers = OrderedDict()
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu1'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

        self.lastLayer = SoftmaxWithLoss()
        
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        
        return x
        
    # x : 입력 데이터, t : 정답 레이블
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
    
    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
        
    # x : 입력 데이터, t : 정답 레이블
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t)
        
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        
        return grads
        
    def gradient(self, x, t):
        # forward
        self.loss(x, t)

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

        # 결과 저장
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads

• 인수는 차례대로 입력층 뉴런 수, 은닉층 뉴런 수, 출력층 뉴런 수, 가중치 초기화 시 정규분포의 스케일입니다.
• OrderedDict는 순서가 있는 딕셔너러 입니다. '순서가 있는' 딕셔너리에 추가한 순서를 기억한다는 것입니다.
• 그래서 Forward Propagation(순전파) 때는 추가한 순서대로 각 Layer(계층)의 forward() Method를 호출하면 처리가 됩니다.
• Back Propagation(역전파)때에는 Layer(계층)을 반대 순서로 호출 하기만 하면 됩니다.
• Affine, ReLU 계층이 각자의 내부에서 Forward Propagation(순전파), Back Propagation(역전파)를 처리하고 있으니까, 그냥 계층을 올바른 순서로 연결한 후 호출해주면 끝입니다.

---

Gradient(기울기) 검증하기

• 크게 2가지 방법이 있습니다.
• 수치 미분을 써서 Gradient(기울기)를 구하는 방법, 해석적으로 수식을 풀어서 Gradient(기울기)를 구하는 방법 2가지가 있습니다.
  • 수식을 풀어서 구하는 방법은 오차역전파법을 사용해서 매개변수가 많아도 효율적으로 계산이 가능합니다.
• 여기서 수치 미분은 오차역전파법의 결과를 비교하여 제대로 구현했는지 검증하는 과정을 거칩니다.
• 이 검증하는 작업을 '기울기 확인(Gradient Check)'라고 합니다.

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 부모 디렉터리의 파일을 가져올 수 있도록 설정
import numpy as np
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# 데이터 읽기
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

x_batch = x_train[:3]
t_batch = t_train[:3]

grad_numerical = network.numerical_gradient(x_batch, t_batch)
grad_backprop = network.gradient(x_batch, t_batch)

# 각 가중치의 차이의 절댓값을 구한 후, 그 절댓값들의 평균을 낸다.
for key in grad_numerical.keys():
    diff = np.average( np.abs(grad_backprop[key] - grad_numerical[key]) )
    print(key + ":" + str(diff))

# Result

        W2:9.71260696544e-13
        b2:1.20570232964e-10
        W1:2.86152966578e-13
        b1:1.19419626098e-12
        수치 미분과 오차역전파법으로 구한 기울기의 차이가 매우 작다.
        실수 없이 구현되었을 확률이 높다.
        정밀도가 유한하기 때문에 오차가 0이 되지는 않는다.

---

오차역전파법을 이용한 학습 구현하기

지금까지와 다른 부분은 Grdient(기울기)를 오차역전파법으로 구한다는 점 뿐입니다.

# coding: utf-8
import sys, os
sys.path.append(os.pardir)

import numpy as np
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# 데이터 읽기
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

# hyperparameter
iters_num = 10000 # 반복횟수
train_size = x_train.shape[0]
batch_size = 100 # 미니배치 크기
learning_rate = 0.1

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

# 1 epoch당 반복하는 횟수
iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
	# 미니배치 획득
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 오차역전파법으로 기울기 계산 (변경한 부분)
    #grad = network.numerical_gradient(x_batch, t_batch) # 수치 미분 방식
    grad = network.gradient(x_batch, t_batch) # 오차역전파법 방식(훨씬 빠르다)
    
    # 매개변수 갱신
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    
    # 학습 경과 기록
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    
    # 1epoch 당 accuray 계산
    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(train_acc, test_acc)

# Result

"""
train acc, test acc | 0.0992833333333, 0.1032
train acc, test acc | 0.898, 0.9026
train acc, test acc | 0.92135, 0.9216
train acc, test acc | 0.936016666667, 0.9337
train acc, test acc | 0.945316666667, 0.9431
train acc, test acc | 0.94675, 0.9427
train acc, test acc | 0.954766666667, 0.9521
train acc, test acc | 0.9602, 0.9551
train acc, test acc | 0.9634, 0.9581
train acc, test acc | 0.9656, 0.9597
train acc, test acc | 0.9683, 0.9615
train acc, test acc | 0.970516666667, 0.9629
train acc, test acc | 0.97305, 0.9649
train acc, test acc | 0.9731, 0.9661
train acc, test acc | 0.975916666667, 0.9659
train acc, test acc | 0.976383333333, 0.9666
train acc, test acc | 0.977916666667, 0.969
[Finished in 45.5s]
"""

---

Summary

- 계산 그래프를 이용하면 계산 과정을 시각적으로 파악할 수 있습니다.
- 계산 그래프의 노드는 국소적 계산으로 구성됩니다. 국소적 계산을 조합해 전체 계산을 구성합니다.
- 계산 그래프의 순전파는 통상의 계산을 수행합니다. 한편, 계산 그래프의 역전파로는 각 노드의 미분을 구할 수 있습니다.
- 신경망의 구성 요소를 계층으로 구현하여 기울기를 효율적으로 계산할 수 있습니다(오차역전파법).
- 수치 미분과 오차역전파법의 결과를 비교하면 오차역전파법의 구현에 잘못이 없는지 확인할 수 있습니다(기울기 확인).