오차역전파법

수치미분을 통하여 신경망의 가중치 매개변수를 구했지만 수치미분은 시간이 오래걸린다.

 

계산그래프

계산 그래프를 통하여 계산과정을 알아보면 오차역전파법을 잘 이해할수 있다.

계산그래프

위처럼 어떠한 값을 수식에 넣고 계산해 나가는 것이 계산그래프 같은것.

문제의 흐름을 살펴 보면 1. 계산 그래프를 구성 2. 그래프에서 계산을 왼쪽에서 오른쪽으로 진행한다.

이처럼 왼쪽에서 오른쪽으로 진행하는 단계를 순전파(forward propagation)라고 한다.

이것을 반대로 한다면 역전파(backward propagation) 라고 한다.

 

계산그래프를 사용하는 목적은 국소적계산과 역전파를 통해 '미분'을 효율적으로 계산할 수 있는 점에 있다.

국소적계산 - 각 노드에서 단순한 계산을 하고 중간에 저장을 할수 있다.

역전파의 계산

역전파를 사용하면 미분값을 전달하여 값을 구할수가 있다.

 

연쇄법칙

위 국소적 미분을 전달하는 원리는 연쇄법칙이다.

계산절차를 보면 신호 E에 노드의 국소적 미분을 곱한 후 다음 노드로 전달한다.

여기서 국소적 미분은 순전파때의 미분을 구한다는것이고 x에 대한 y의 미분을 구하는것이다.

 

합성함수 : 여러 함수로 구성된 함수 
합성 함수의 미분은 합성 함수를 구성하는 각 함수의 미분의 곱으로 나타낼 수 있다.

합성함수 미분의 예

 

위 식을 연쇄법칙을 통해 미분δz/δx를 구해보면

위에서 구한 미분을 이용하여 구할수가 있다.

위 과정을 그래프로 그려본것

위 그래프에 앞에서 구한 식을 넣어보았다.

 

 

역전파

이처럼 연쇄법칙은 이뤄 진다는 것을 알수 있었다.

이제 역전파의 구조를 설명해보자

 

• 덧셈노드의 역전파

z=x+y를  대상으로 역전파를 살펴보자

미분은dz/dx =1, dz/dy =1 이 될것이다.

덧셈논드의 역전파 그래프

위를 예시로 그래프를 그려보면 역전파에서는 그대로 출력된다는걸 알수 있다.

 

• 곱셈노드의 역전파

z=xy라고 가정하면

미분값은 dz/dx=y, dz/dy=x 이다

곱셈 노드 역전파를 구현보면 '서로 바꾼 값'을 곱해서 보낸다.

덧셈 노드 역전파와 달리 곱셈 노드 역전파의 경우 그대로 값을 보내지 않아서 순방향입력신호가 필요하여 곱셈노드 역전파 구현시 순전파의 입력 신호를 변수에 저장해둡니다.

 

단순한 계층 구현

위에서 해던것을 파이썬으로 구현한다. 곱셉노드를 mulLayer, 덧셈노드를 addLayer

 

곱셈계층

class MulLayer:
    def __init__(self):
        self.x = None
        self.y = None
 
    def forward(self, x, y):
        self.x = x
        self.y = y                
        out = x * y
 
        return out
 
    def backward(self, dout):
        dx = dout * self.y  # x와 y를 바꾼다.
        dy = dout * self.x
 
        return dx, dy
 

여기서 dout은 미분값

위 사과 계산하는것을 코드로 구현한 것이다.

 

덧셈계층

덧셈계층은 곱셈계층과 구성은 같으나 그대로 보내주는것이므로 역전파쪽만 바꿔주면되므로 그냥 적겟다.

class AddLayer:
    def __init__(self):
        pass
 
    def forward(self, x, y):
        out = x + y
 
        return out
 
    def backward(self, dout):
        dx = dout * 1
        dy = dout * 1
 
        return dx, dy

위 식의 미분 값

 

class Relu:
    def __init__(self) -> None:
        self.mask = None
    
    def forward(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0
 
        return out
 
    def backward(self, dout):
        dout[self.mask] = 0
        dx = dout
 
        return dx

class Sigmoid:
    def __init__(self) -> None:
        self.mask = 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

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

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)
 
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 = []
 
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)
    
    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)