Ch5 오차역전파법
Study/밑바닥부터 시작하는 딥러닝 2021. 1. 25. 08:49
5.1 계산 그래프¶
- 계산 그래프 : 계산 과정을 그래프로 나타낸 것
- 복수의 노드와 에지로 표현
5.1.1 계산 그래프로 풀기¶
- 계산 그래프를 구성
- 그래프에서 계산을 왼쪽에서 오른쪽으로 진행 -> 순전파 (역전파 : 오른쪽에서 왼쪽으로)
5.1.2 국소적 계산¶
- 전체 계산이 아무리 복잡하더라도 각 단계에서 하는 일은 해당 노드의 국소적 계산
5.1.3 계산그래프로 푸는 이유¶
- 국소적 계산
- 중간 계산 결과를 모두 보관할 수 있음
- 역전파를 통해 미분을 효율적으로 계산할 수 있음
5.2 연쇄법칙¶
5.2.1 계산 그래프의 역전파¶
- 순방향과는 반대 방향으로 국소적 미분을 곱함
5.2.2 연쇄법칙¶
- 합성 함수 : 여러 함수로 구성된 함수
- 합성 함수의 미분은 합성 함수를 구성하는 각 함수의 미분의 곱으로 나타낼 수 있음
5.2.3 연쇄법칙과 계산 그래프¶
- 책 참고
5.3 역전파¶
5.3.1 덧셈 노드의 역전파¶
- 최종 출력으로 가는 계산의 중간에 덧셈 노드가 존재, 역전파에서는 국소적 미분이 가장 오른쪽의 출력에서 시작하여 노드를 타고 역방향으로 전파됨
- 덧셈노드 역전파는 입력 신호를 다음 노드로 출력할 뿐, 그대로 다음 노드로 전달함
5.3.2 곱셈 노드의 역전파¶
- 곱셈 노드의 역전파는 상류의 값에 순전파 때의 입력 신호들을 '서로 바꾼 값'을 곱해서 하류로 보냄
5.4 단순한 계층 구현하기¶
5.4.1 곱셈 계층¶
In [3]:
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
dy = dout * self.x
return dx, dy
In [7]:
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)
price
Out[7]:
In [11]:
# 역전파
dprice = 1
dapple_price,dtax = mul_tax_layer.backward(dprice)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)
print(dapple, dapple_num, dtax)
5.4.2 덧셈 계층¶
In [12]:
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
5.5 활성화 함수 계층 구현하기¶
5.5.1 ReLU 계층¶
- ReLU : >0 일때는 그대로 출력, <=0 일때는 0
In [17]:
import numpy as np
class ReLU:
def __init__(self):
self.mask = None
def forward(self,x):
self.mask = (x<=0) # mask : 조건에 대해 맞으면 True, 아니면 False
out = x.copy()
out[self.mask] = 0
return out
def backward(self, dout):
dout[self.mask] = 0
dx = dout
return dx
In [19]:
x = np.array([[1.0, -0.5], [-2.0,3.0]])
mask = (x<=0)
print(mask)
5.5.2 Sigmoid 계층¶
- y = 1/(1+exp(-x))
- 책 참고
- Sigmoid 계층의 역전파는 순전파의 출력만으로 계산할 수 있음
In [20]:
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
5.6 Affine/Softmax 구현¶
5.6.1 Affine 계층¶
- 책 참고
- 행렬 곱, 미분 참고!!
- 행렬의 차원에 대해 주의
5.6.2 배치용 Affine 계층¶
In [27]:
X_dot_W = np.array([[0,0,0],[10,10,10]])
B = np.array([1,2,3])
X_dot_W + B # 순전파 때의 편향 덧셈은 각 데이터에 더해짐
Out[27]:
In [29]:
dY = np.array([[1,2,3],[4,5,6]])
dB = np.sum(dY, axis=0)
dB # 편향의 역전파는 데이터에 대한 미분을 데이터마다 더해서 구함
Out[29]:
In [30]:
class Affine:
def __init__(self, W, b):
self.W = W
self.b = b
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)
self.dW = np.dot(self.x.T , dout)
self.db = np.sum(dout, axis=0)
return dx
5.6.3 Softmax-with-Loss 계층¶
- Softmax : 입력 값을 정규화하여 출력
- Softmax 계층의 역전파는 y_1-t_1, y_2-t_2 라는 결과를 주고 있음
- 이는 Softmax 계층의 출력과 정답 레이블의 차분, 신경망의 역전파에서 이 차이인 오차가 앞 계층에 전달 됨
In [31]:
class SoftmaxWithLoss:
def __init__(self):
self.loss = None
self.y = None
self.t = None
def forward(self, x, t):
self.t = t
self.y = softmax(x)
self.loss = cross_entropy_error(self.y, self.t)
return self.loss
def backward(self, dout=1):
batch_size = self.t.shape[0]
dx = (self.y - self.t) / batch_size
return dx
5.7 오차역전파법 구현¶
5.7.1 신경망 학습의 전체 그림¶
- 신경망에는 적응 가능한 가중치와 편향이 있고, 이 가중치와 편향을 훈련 데이터에 적응하도록 조정하는 과정을 학습이라고 함.
- 1단계 - 미니배치 : 훈련 데이터 중 일부를 무작위로 가져옴. 이렇게 선별된 데이터를 미니배치라 하며, 그 미니배치의 손실 함수 값을 줄이는 것을 목표로 함
- 2단계 - 기울기 산출 : 미니배치의 손실 함수 값을 줄이기 위해 각 가중치 매개변수의 기울기를 구함. 기울기는 손실 함수의 값을 가장 작게 하는 방향을 제시
- 3단계 - 매개변수 갱신 : 가중치 매개변수를 기울기 방향으로 아주 조금 갱신
- 4단계 - 반복
5.7.2 오차역전파법을 적용한 신경망 구현하기¶
In [36]:
import sys
import os
import numpy as np
from collections import OrderedDict
sys.path.append(os.pardir)
from common.layers import *
from common.gradient import numerical_gradient
from dataset.mnist import load_mnist
"""
TwoLayerNet 클래스로 구현
* 클래스의 인스턴스 변수
params : 신경망의 매개변수를 보관하는 딕셔너리 변수.
params['W1']은 1번째 층의 가중치, params['b1']은 1번째 층의 편향.
params['W2']은 2번째 층의 가중치, params['b2']은 2번째 층의 편향.
layers : 신경망의 계층을 보관하는 순서가 있는 딕셔너리 변수
layers['Affine1'], layers['Relu1'], layers['Affine2']와 같이
각 계층을 순서대로 유지
lastLayer : 신경망의 마지막 계층(여기서는 SoftmaxWithLoss)
* 클래스의 메서드
__init__(...) : 초기화 수행
predict(x) : 예측(추론)을 수행한다. x는 이미지 데이터
loss(x, t) : 손실함수의 값을 구한다. x는 이미지 데이터, t는 정답 레이블
accuracy(x, t) : 정확도를 구한다.
numerical_gradient(x, t) : 가중치 매개변수의 기울기를 수치 미분으로 구함(앞 장과 같음)
gradient(x, t) : 가중치 매개변수의 기울기를 오차역전파법으로 구함
"""
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
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
- 신경망의 계층을 순서가 있는 딕셔너리에서 보관,따라서 순전파때는 추가한 순서대로 각 계층의 forward()를 호출하기만 하면 된다.
- 역전파때는 계층을 반대 순서로 호출하기만 하면 된다.
- 신경망의 구성 요소를 모듈화하여 계층으로 구현했기 때문에 구축이 쉬워진다.
5.7.3 오차역전파법으로 구한 기울기 검증¶
- 기울기 확인 : 수치 미분과 오차역전파법으로 구한 기울기를 비교
In [38]:
if __name__ == '__main__':
# 데이터 읽기
(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))
In [ ]:
## 5.8 정리
- 계산 그래프를 이용하면 계산 과정을 시각적으로 파악할 수 있음
- 계산 그래프의 노드는 국소적 계산으로 구성됨. 국소적 계산을 조합해 전체 계산을 구성
- 계산 그래프의 순전파는 통상의 계산을 수행함. 한편, 계산 그래프의 역전파로는 각 노드의 미분을 구할 수 있음
- 신경망의 구성 요소를 계층으로 구현하여 기울기를 효율적으로 계산할 수 있음
- 수치 미분과 오차역전파법의 결과를 비교하면 오차역전파법의 구현에 잘못이 없는지 확인할 수 있음
'Study > 밑바닥부터 시작하는 딥러닝' 카테고리의 다른 글
| Ch6 학습 관련 기술들 (0) | 2021.01.25 |
|---|---|
| Ch4 신경망 학습 (0) | 2021.01.19 |
| Ch3 신경망 (0) | 2021.01.06 |
| Ch2 퍼셉트론 (0) | 2021.01.06 |