오차역전법

deep learning
공개

2025년 8월 1일

계산 그래프

특징

  • 국소적 계산: 자신과 관계된 정보만 결과로 출력
  • 중간 결과를 모두 저장할 수 있다.
  • 역전파를 통해 특정 단계에서의 최정 결과에 대한 미분을 효율적으로 계산할 수 있다.

예시 - 순전파

  • 철수는 슈퍼에서 사과를 2개 귤을 3개 샀다. 사과는 1개 100원, 귤은 1개 150원이다. 소비세가 10%일 때 지불 금액은?

flowchart LR
    apple_num((사과 갯수)) -- 2 --> apple_x
    apple_price((사과 가격)) -- 100 --> apple_x
    orange_num((귤 갯수)) -- 3 --> orange_x
    orange_price((귤 가격)) -- 150 --> orange_x
    tax((소비세)) -- 1.1 --> total_x
    apple_x[x] -- 200 --> fruit_plus
    orange_x[x] -- 450 --> fruit_plus
    fruit_plus(+) -- 650 --> total_x
    total_x[x] -- 715 --> output((지불 금액))

오차역전법

  • 연쇄법칙을 생각하면 됨.

덧셈 노드 역전파

  • 덧셈 노드의 역전파는 입력값을 그대로 전달한다.

곱셈 노드 역전파

  • 곱셈 노드의 역전파는 입력값을 그대로 전달하되, 다른 입력값을 곱해준다.

예시 - 역전파

  • 철수는 슈퍼에서 사과를 2개 귤을 3개 샀다. 사과는 1개 100원, 귤은 1개 150원이다. 소비세가 10%일 때 지불 금액은?

flowchart LR
    apple_num((사과 갯수)) -- 2 --> apple_x
    apple_price((사과 가격)) -- 100 --> apple_x
    tax((소비세)) -- 1.1 --> total_x
    apple_x[x] -- 200 --> total_x
    total_x[x] -- 220 --> output((지불 금액))

    apple_x -. 110 .-> apple_num
    apple_x -. 2.2 .-> apple_price
    total_x -. 200 .-> tax
    total_x -. 1.1 .-> apple_x
    output -. 1 .-> total_x

python 구현

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
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

활성화 함수 계층

ReLU

  • 입력이 0보다 크면 그대로, 작으면 0
class Relu:
    def __init__(self):
        self.mask = None

    def forward(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0
        return out

    def backward(self, dout):
        dx = dout.copy()
        dx[self.mask] = 0
        return dx

Sigmoid

  • \(\frac{hL}{hy}y^2exp(-x) = \frac{hL}{hy}y(1-y)\) (계산 생략)
import numpy as np

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 - self.out) * self.out
        return dx

Affine

  • WX + B 계산 node
  • \(\frac{dL}{dX} = \frac{dL}{dY} ⋅ W^T\)
  • \(\frac{dL}{dW} = X^T ⋅ \frac{dL}{dY}\)
  • \(\frac{dL}{dB} = \sum \frac{dL}{dY}\)
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

Softmax

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

오차역전법 신경망

from dl_common.layers import *
from dl_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['b1'] = 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.last_layer = SoftmaxWithLoss()

    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        return x

    def loss(self, x , t):
        y = self.predict(x)
        return self.last_layer.forward(y, t)

    def auuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1:
            t = np.argmax(t, axis=1)
        acc = np.mean(y == t)

        return acc

    def gradient(self, x, t):
        self.loss(x, t)

        dout = 1
        dout = self.last_layer.backward(dout)
        
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)
        
        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
from dl_dataset.mnist import load_mnist

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

train_loss_list = []
train_acc_list = []
test_acc_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)
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]
    grads = network.gradient(x_batch, t_batch)
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grads[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)
맨 위로