수치 미분을 사용해 가중치 매개변수에 대한 손실 함수의 기울기를 구하는 방법은 계산 시간이 오래 걸린다는 단점
-> 오차역전파법 : 효율적으로 계산 가능
5.1 계산 그래프
5.1.1 계산 그래프로 풀다
문제 : 슈퍼에서 사과 2개, 귤을 3개 구매. 사과는 1개에 100원, 귤은 1개 150원. 소비세가 10%일 때 지불 금액 구하기
문제 풀이:
- 계산 그래프를 구성한다.
- 그래프에서 계산을 왼쪽에서 오른쪽으로 진행한다. : 순전파
5.1.2 국소적 계산
- 계산 그래프의 특징: 국소적 계산을 전파함으로써 최종 결과를 얻음
- 전체에서 어떤 일이 벌어지든 상관없이 자신과 관계된 정보만으로 결과 출력 가능
5.1.3 왜 계산 그래프로 푸는가?
- 국소적 계산 가능
- 중간 계산 결과 모두 보관 가능
- 역전파를 통해 미분을 효율적으로 계산 가능 (가장 큰 이유)
5.2 연쇄법칙
역전파 : 순전파와 반대로 국소적인 미분을 오른쪽에서 왼쪽으로 전달
원리 : 연쇄법칙(chain rule)
5.2.1 계산 그래프의 역전파
- 신호 E에 노드의 국소적 미분(*E)을 곱한 후 다음 노드로 전달
- 국소적 미분 : 입력 x에 대한 y의 미분
- 목표로 하는 미분 값을 효율적으로 구할 수 있음
5.2.2 연쇄법칙이란?
: 합성 함수의 미분은 합성 함수를 구성하는 각 함수의 미분의 곱으로 나타낼 수 있다.
예) z = t**2
t = x+y
5.3 역전파
5.3.1 덧셈 노드의 역전파
x + y = z 일 경우 z에 대한 x와 y의 미분 값은 모두 1 -> 덧셈 노드의 역전파 : 입력된 값을 그대로 다음 노드로 보냄
5.3.2 곱셈 노드의 역전파
xy = z 일 경우 x와 y에 대한 z의 미분 값은 각각 y와 x -> 곱셈 노드의 역전파 :
상류의 값에 순전파 때의 입력 신호들을 서로 바꾼 값을 곱해서 하류로 보냄
예)
- 순방향 입력 신호의 값이 필요 -> 순전파의 입력 신호를 변수에 저장
5.3.3 사과 쇼핑의 예
- 사과 가격에 대한 지불 금액의 미분 : 2.2
- 사과 개수에 대한 지불 금액의 미분 : 110
- 소비세에 대한 지불 금액의 미분 : 200
5.4 단순한 계층 구현하기
5.4.1 곱셈 계층
#곱셈 계층
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 #상류에서 넘어온 미분(dout)에 순전파 때의 값을 서로 바꿔 곱함
dy = dout*self.x
return dx, dy#사과 쇼핑 예 적용
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)220.00000000000003
2.2, 110.00000000000001, 200
5.4.2 덧셈 계층
#덧셈 계층
class AddLayer:
def __init__(self):
pass #초기화 필요 x
def forward(self, x, y):
out = x+y
return out
def backward(self, dout):
dx = dout*1
dy = dout*1
return dx, dy#사과와 귤 쇼핑 예 적용
apple = 100
apple_num = 2
orange = 150
orange_num = 3
tax = 1.1
#계층들
mul_apple_layer = MulLayer()
mul_tax_layer = MulLayer()
mul_orange_layer = MulLayer()
add_apple_orange_layer = AddLayer()
#순전파
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, orange_price)
price = mul_tax_layer.forward(all_price, tax)
print(price)
#역전파
dprice = 1
dall_price, dtax = mul_tax_layer.backward(dprice)
dapple_price, dorange_price = add_apple_orange_layer.backward(dall_price)
dorange, dorange_num = mul_orange_layer.backward(dorange_price)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)
print(dapple, dapple_num, dorange, dorange_num, dtax)715.0000000000001
2.2, 110.00000000000001, 3.3000000000000003, 165.0, 650
5.5 활성화 함수 계층 구현하기
5.5.1 ReLU 계층
- 순전파 때 x가 0 이하면 역전파 때는 하류로 신호를 보내지 않음 (0)
#relu 계층
class Relu:
def __init__(self):
self.mask = None
def forward(self, x):
self.mask = (x<=0)
out = x.copy()
out[self.mask] = 0
def backward(self, dout):
dout[self.mask] = 0
dx = dout
return dx
5.5.2 Sigmoid 계층
-> 역전파의 흐름
1단계 :
'/'노드, 즉 y = 1/x (x: 1+exp(-x)) 을 미분
- 상류에서 흘러온 값에 순전파의 출력(y)을 제곱한 후 마이너스를 붙인 값을 곱해서 하류로 전달
2단계 :
+노드, 여과 없이 하류로 내보냄
3단계 :
exp 노드, y = exp(x) 연산을 수행
- 상류의 값에 순전파 때의 출력을 곱함
4단계 :
x노드, 순전파 때의 값을 서로 바꿔 곱함
=> 순전파의 입력 x와 출력 y만으로 계산 가능 => 단순한 sigmoid 노드 하나로 대체
- 중간 계산을 생략해 더 효율적인 계산
- 노드를 그룹화하여 입력과 출력에만 집중하게 할 수 있음
- 또한 다음처럼 정리해서 쓸 수 있음
-> 시그모이드 계층의 역전파는 순전파의 출력(y)만으로 계산할 수 있음
#sigmoid 계층
class Sigmoid:
def __init__(self):
self.out = None
def forward(self, x):
out = 1/(1+np.exp(-x))
self.out = out
def backward(self, dout):
dx = dout * (1.0-self.out)*self.out
return dx5.6 Affine/Softmax 계층 구현하기
5.6.1 Affine 계층
- 어파인 변환(affine transformation)은 신경망 순전파 때 수행하는 행렬의 곱을 기하학에서 부르는 이름
- 어파인 변환을 수행하는 처리를 'Affine'계층 이라는 이름으로 구현
- 행렬 곱('dot' 노드)의 역전파: 행렬의 대응하는 차원의 원소 수가 일치하도록 곱을 조립해야 함.
-> W와 X를 전치(T) - 편향 주의 : 역전파 때는 각 데이터의 역전파 값이 편향의 원소에 모여야함
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) #dout*다른입력값W의 전치행렬 (대응하는 차원의 원소 수가 일치하도록 하기 위해 전치)
self.dW = np.dot(self.x.T, dout)
self.db = np.sum(dout, axis=0) #각 데이터에 대한 미분을 데이터마다 더해서 구해야 함, 데이터 단위의 0번째 축에 대한 총합
return dx5.6.3 Softmax-with-Loss 계층
역전파의 결과 : Softmax 계층의 출력과 정답 레이블의 차분 (,
- 신경망의 역전파에서는 오차가 앞 계층에 전해지는 것
-> 신경망 학습의 중요한 성질 - 오차를 전달함으로써 신경망의 출력이 정답 레이블과 가까워지도록 가중치 매개변수의 값 조정
#softmaxwithloss
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)
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 dx5.7 오차역전파법 구현하기
5.7.2 오차역전파법을 적용한 신경망 구현하기
- 계층을 사용함으로써 계층의 전파만으로 동작이 이루어짐 (predict(), 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) #0으로 초기화
self.params['W2'] = weight_init_std * \
np.random.randn(hidden_size, output_size)
self.params['b2'] = np.zeros(output_size)
#계층 생성
self.layers = OrderedDict() #순서가 있는 딕셔너리{Affine1, Relu1, Affine2}
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(): #{Affine1, Relu1, Affine2}순서대로 처리
x = layer.forward()
return x
# 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
def gradient(self, x, t): #오차역전파법으로 기울기 구하기
#순전파
self.loss(x, t)
#역전파
dout = 1
dout = self.lastlayer.backward(dout)
layers = list(self.layer.values())
layers.reverse() #{Affine1, Relu1, Affine2}역순으로
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'].dW
return grads
5.7.3 오차역전파법으로 구한 기울기 검증하기
- MNIST 데이터셋 읽기
- 훈련 데이터 일부를 수치 미분으로 구한 기우리과 오차역전파법으로 구한 기울기의 오차 확인
- 오차 : 각 가중치 매개변수의 차이의 절댓값을 구하고, 이를 평균한 값
#기울기 검증
#데이터 읽기
(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))W1:1.9386396841126322e-10
b1:1.1386369347913964e-09
W2:6.790742339489453e-08
b2:1.361732661936399e-07
-> 매우 작은 값 (0이 되는 일은 드뭄) => 오차역전파법 기울기도 올바름
5.7.4 오차역전파법을 사용한 학습 구현
ch4와 동일
5.8 정리
- 계산 그래프의 노드는 국소적 계산으로 구성. 국소적 계산을 조합해 전체 계산을 구성.
- 계산 그래프의 순전파는 통상의 계산을 수행. 한편, 역전파로는 각 노드의 미분을 구할 수 있음.
- 신경망의 구성 요소를 계층으로 구현하여 기울기를 효율적으로 계산할 수 있음. (오차역전파법)
- 수치 미분과 오차역전파법의 결과를 비교하면 오차역전파법의 구현에 잘못이 없는지 확인할 수 있다(기울기 확인)
책 참고 : 밑바닥부터 시작하는 딥러닝 (한빛미디어)
'딥러닝 > 밑바닥부터 시작하는 딥러닝' 카테고리의 다른 글
| 7장 : 합성곱 신경망(CNN) (0) | 2023.09.17 |
|---|---|
| 6장 : 학습 관련 기술들 (0) | 2023.09.15 |
| 4장 : 신경망 학습 (0) | 2023.09.06 |
| 3장 : 신경망 (0) | 2023.09.05 |
| 2장 : 퍼셉트론 (0) | 2023.09.04 |
