오차역전파 - 오차역전파법 구현

728x90

신경망 학습 순서

신경망에는 적응 가능한 가중치와 편향이 있고, 이 가중치와 편향을 훈련 데이터에 적응하도록 조정하는 과정을 '학습'이라 한다.

단계 - 미니배치
- 훈련 데이터 중 일부를 무작위로 가져온다. 이렇게 선별한 데이터를 미니배치라 하며, 그 미니배치의 손실 함수 값을 줄이는 것이 목표다.
단계 - 기울기 산출
- 미니배치의 손실 함수 값을 줄이기 위해 가중치 매개변수의 기울기를 구한다. 기울기는 손실 함수의 값을 가장 작게 하는 방향을 제시한다.
단계 - 매개변수 갱신
- 가중치 매개변수를 기울기 방향으로 아주 조금 갱신한다.
단계 - 반복
- 1~3단계 반복

기존에는 기울기를 구하기 위해 수치 미분을 사용했다. 하지만 수치 미분은 구현하기는 쉽지만 계산이 오래 걸린다.
오차역전파법을 이용하면 느린 수치 미분과 달리 기울기를 효율적이고 빠르게 구할 수 있다.

오차역전파법을 적용한 신경망 구현

TwoLayerNet 클래스의 인스턴스 변수

인스턴스 변수	설명
params	딕셔너리 변수로, 신경망의 매개변수를 보관
	params['W1']은 1번째 층의 가중치, params['b1']은 1번째 층의 편향
	params['W2']는 2번째 층의 가중치, params['b2']는 2번째 층의 편향
layers	순서가 있는 딕셔너리 변수로, 신경망의 계층을 보관
layers	layers['Affine1'], layers['Relu1'], layers['Affine2']와 같이 각 계층을 순서대로 유지
lastLayer	신경망의 마지막 계층
lastLayer	이 예에서는 SoftmaxWithLoss 계층

TwoLayerNet 클래스 메서드

메서드	설명
__init__(self,input_size,hidden_size,output,size,weight_init_std))	초기화를 수행
	인수는 앞에서부터 입력층 뉴런 수, 은닉층 뉴런 수, 출력층 뉴런 수, 가중치 초기화 시 정규분포의 스케일
predict(self,x)	예측(추론)을 수행한다.
predict(self,x)	인수 x는 이미지 데이터
loss(self,x,t)	손실 함수의 값을 구한다.
loss(self,x,t)	인수 x는 이미지 데이터, t는 정답 레이블
accuracy(self,x,t)	정확도를 구한다.
numerical_gradient(self,x,t)	가중치 매개변수의 기울기를 수치 미분 방식으로 구한다.
gradient(self,x,t)	가중치 매개변수의 기울기를 오차역전파법으로 구한다.

# 5.7 오차역전파법 구현

import sys, os 
sys.path.append(os.pardir)
import numpy as np
from layer import *
from 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):
        # 순전파
        self.loss(x, t)
        
        # 역전파
        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'] = self.layers['Affine1'].dW
        grads['b1'] = self.layers['Affine1'].db
        grads['W2'] = self.layers['Affine2'].dW
        grads['b2'] = self.layers['Affine2'].db
        
        return grads

오차역전파법으로 구한 기울기 검증

기울기를 구하는 두 가지 방법
1. 수치 미분을 써서 구하는 방법
2. 해석적으로 수식을 풀어 구하는 방법
해석적 방법은 오차역전파법을 이용해 매개변수가 많아도 효율적으로 계산이 가능하다.
수치 미분은 느려서 오차역전파를 제대로 구현해두면 쓸모는 없다. 하지만 수치 미분은 오차역전파법을 정확히 구현했는지 확인하기 위해서 필요하다.
수치 미분은 구현이 쉬워서 버그가 숨어있기 어렵지만 오차역전파는 구현하기 복잡해서 종종 실수나 버그가 발생한다.

# 오차역전파법으로 구한 기울기 검증하기 - 기울기 확인(gradient check)

import sys, os
sys.path.append(os.pardir)
import numpy as np
from 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))

오차역전파법을 사용한 학습 구현

# 오차역전파법을 사용한 학습 구현
import sys, os
sys.path.append(os.pardir)
import numpy as np
from 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.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)