밑바닥부터 시작하는 딥러닝 - 4장 신경망 학습 II]

학습 알고리즘 구현하기

신경망학습의 절차

1단계- 미니배치 : 훈련 데이터를 무작위로 가져옴

2단계 - 기울기 산출 : loss funciton을 줄이기 위해 가중치 매개변수의 기울기를 구하고, 기울기는 손실함수 값을 가장 작게하는 방향으로 한다.

3단계 -  매개변수 갱신 : 가중치 매개변수를 기울기 방향으로 갱신

1-3 단계 반복

 

확률적 경사하강법(SGD)-> 확률적으로 무작위로 골라낸 데이터에 대해 신경망 학습 수행

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

  def predict(self,x): # 예측(추론) 수행
    W1,W2 = self.params['W1'] ,self.params['W2']
    b1,b2 = self.params['b1'] ,self.params['b2']
    a1 = np.dot(x,W1)+b1
    z1= sigmoid(a1)
    a2 = np.dot(z1,W2)+b2
    y = softmax(a2)

  #x 입력데이터 t 정답레이블
  def loss(self,x,t): #손실함수의 값
    y = self.predict(x)
    return cross_entropy_error(y,t)

  def accuracy(self,x,t): #정확도 구하기 
    y= self.predict(x)
    y= np.argmax(y,axis=1)
    t = np.argmax(t,axis=1)

    accuracy = np.sum(y==t)/float(x.shape[0])
    return accuracy

  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

 

미니배치 학습 구현

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=False,one_hot_label=False)

train_loss_list = []

#하이퍼파라미터
iters_num = 10000 #반복 횟수
train_size = x_train.shape[0]
batch_size=100 #미니배치 크기
learning_rate = 0.1
network = TwoLayerNet(input_size=784,hidden_size=50,output_size=10)

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)
  #매개변수 갱신
  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)

100개의 미니배치를 대상으로 SGD를 시행하여 매개변수를 갱신함. 갱신때맏 훈련데이터의 loss function을 계산하고 그 값을 배열에 추가한다. 학습 횟수가 늘어나면서 loss function이 감소한다. 

 

test data로 평가하기

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=False,one_hot_label=False)

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

#1에폭당 반복 수 
iter_per_epoch = max(train_size/batch_size,1)

#하이퍼파라미터
iters_num = 10000 #반복 횟수
train_size = x_train.shape[0]
batch_size=100 #미니배치 크기
learning_rate = 0.1
network = TwoLayerNet(input_size=784,hidden_size=50,output_size=10)

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)
  #매개변수 갱신
  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)

  #1에폭당 정확도 계산
  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 |" + str(train_acc)+ "," + str(test_acc))

1에폭마다 모든 train data 와 test data에 대한 정확도를 계산함.에폭이 진행될수록 train과 test 데이터의 accuracy가 좋아짐.