역전파를 직접 구현하며 이해하기

덧셈, 곱셈, tanh만 아는 40줄짜리 자동 미분 엔진을 직접 만들고, 계산 그래프를 거꾸로 따라가며 기울기가 흐르는 과정을 확인해요. 이어서 numpy로 은닉층 신경망의 순전파와 역전파를 행렬로 구현하고, 수치 미분과 PyTorch로 기울기를 이중 검증한 뒤 반달 데이터를 직접 학습시켜요. 깊은 시그모이드 신경망에서 기울기가 사라지는 현상도 숫자로 확인해요.

고급강의 2 / 6약 13분

신경망 강의에서 은닉 뉴런 100개짜리 신경망은 가중치가 7,510개였어요. 학습이란 이 7,510개를 손실이 줄어드는 방향으로 조금씩 고치는 일이고, 그러려면 손실을 각 가중치로 미분한 값(기울기)이 7,510개 필요해요. GPT 같은 모델은 이게 수천억 개예요. 이걸 효율적으로 구하는 방법이 역전파이고, 미적분 트랙의 연쇄 법칙 강의에서 원리를 봤어요. 이번에는 직접 만들어 봐요. 만들어 보면 딥러닝 라이브러리가 마법이 아니라는 걸 알게 돼요.

계산 그래프와 연쇄 법칙

y=tanh⁡(x1w1+x2w2+b)y = \tanh(x_1 w_1 + x_2 w_2 + b)를 계산하는 과정을 작은 계산들의 연결로 그려 볼게요.

x1 ─┐
    (×) ─┐
w1 ─┘    │
         (+) ─┐
x2 ─┐    │    │
    (×) ─┘    (+) ── (tanh) ── y
w2 ─┘         │
b ────────────┘

순전파는 왼쪽에서 오른쪽으로 값을 계산하는 거예요. 역전파는 오른쪽 끝에서 시작해 왼쪽으로, "이 값이 조금 바뀌면 yy가 얼마나 바뀌나"를 전달하는 거예요. 각 계산은 자기 국소 기울기만 알면 돼요.

계산국소 기울기
c=a+bc = a + b∂c∂a=1\frac{\partial c}{\partial a} = 1, ∂c∂b=1\frac{\partial c}{\partial b} = 1 (기울기를 그대로 나눠 줘요)
c=a×bc = a \times b∂c∂a=b\frac{\partial c}{\partial a} = b, ∂c∂b=a\frac{\partial c}{\partial b} = a (상대 값을 곱해 줘요)
c=tanh⁡ac = \tanh a∂c∂a=1−c2\frac{\partial c}{\partial a} = 1 - c^2

연쇄 법칙에 따라, 어떤 값의 기울기는 뒤에서 들어온 기울기 × 자기 국소 기울기예요. 이게 역전파의 전부예요.

40줄짜리 자동 미분 엔진

숫자 하나를 감싸서, 계산할 때마다 "누구에게서 어떻게 만들어졌는지"를 기억하는 Value를 만들어요. 안드레이 카르파티의 교육용 프로젝트 micrograd와 같은 아이디어예요.

import math

class Value:
    def __init__(self, data, parents=()):
        self.data = data
        self.grad = 0.0                    # 최종 출력을 이 값으로 미분한 값
        self._parents = parents
        self._backward = lambda: None      # 내 기울기를 부모에게 나눠 주는 방법

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other))
        def _backward():
            self.grad += out.grad          # 덧셈은 기울기를 그대로 전달
            other.grad += out.grad
        out._backward = _backward
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other))
        def _backward():
            self.grad += other.data * out.grad    # 곱셈은 상대 값을 곱해 전달
            other.grad += self.data * out.grad
        out._backward = _backward
        return out

    def tanh(self):
        t = math.tanh(self.data)
        out = Value(t, (self,))
        def _backward():
            self.grad += (1 - t * t) * out.grad
        out._backward = _backward
        return out

    def backward(self):
        order, seen = [], set()
        def visit(v):                      # 부모가 먼저 오도록 줄 세우기 (위상 정렬)
            if v not in seen:
                seen.add(v)
                for p in v._parents:
                    visit(p)
                order.append(v)
        visit(self)
        self.grad = 1.0                    # dy/dy = 1에서 출발
        for v in reversed(order):          # 출력에서 입력 쪽으로
            v._backward()

뉴런 하나를 계산하고 거꾸로 미분해 볼게요.

x1, x2, w1, w2, b = Value(2.0), Value(-1.0), Value(0.5), Value(-1.5), Value(0.3)
y = (x1 * w1 + x2 * w2 + b).tanh()
y.backward()
print(round(y.data, 4), round(w1.grad, 4), round(w2.grad, 4), round(b.grad, 4))   # 0.9926 0.0294 -0.0147 0.0147

# 검산: w1만 아주 조금 움직여 보는 수치 미분
f = lambda v: math.tanh(2.0 * v + (-1.0) * (-1.5) + 0.3)
print(round((f(0.5 + 1e-6) - f(0.5 - 1e-6)) / 2e-6, 4))                         # 0.0294

w1w_1의 기울기 0.0294가 수치 미분과 정확히 같아요. 손으로 따라가 보면, tanh의 국소 기울기 1−0.99262≈0.01471 - 0.9926^2 \approx 0.0147이 덧셈을 지나 그대로 내려오고(그래서 bb의 기울기가 0.0147), 곱셈에서 상대 값 x1=2x_1 = 2가 곱해져 w1w_1의 기울기는 0.02940.0294가 돼요.

기울기를 왜 더할까 (+=)

같은 값이 여러 곳에 쓰이면 기울기가 여러 길로 돌아와요. 그래서 덮어쓰지 않고 더해야 해요.

a = Value(3.0)
c = a * a          # a가 두 번 쓰여요
c.backward()
print(a.grad)      # 6.0 (= 2a)

=로 덮어썼다면 3.0이 나왔을 거예요. 이 += 때문에, PyTorch에서 학습할 때마다 optimizer.zero_grad()로 기울기를 0으로 지워야 해요. 다음 강의에서 다시 만나요.

행렬로 하는 역전파

실제 신경망은 숫자 하나하나가 아니라 행렬 단위로 계산해요. 은닉층 하나(ReLU 32개)와 소프트맥스 출력층을 가진 신경망을 numpy로 만들어 볼게요. 배치 크기를 nn이라고 할 때 순전파는 이래요.

Z1=XW1+b1,H=ReLU(Z1),Z2=HW2+b2,P=softmax(Z2)Z_1 = X W_1 + \mathbf{b}_1, \quad H = \text{ReLU}(Z_1), \quad Z_2 = H W_2 + \mathbf{b}_2, \quad P = \text{softmax}(Z_2)

역전파는 끝에서부터 각 단계의 국소 기울기를 곱해 내려와요.

단계기울기모양
소프트맥스 + 교차 엔트로피dZ2=(P−Y)/ndZ_2 = (P - Y)/nn×2n \times 2
출력층 가중치dW2=HTdZ2dW_2 = H^T dZ_2, db2=∑dZ2d\mathbf{b}_2 = \sum dZ_232×232 \times 2
은닉층 출력dH=dZ2W2TdH = dZ_2 W_2^Tn×32n \times 32
ReLUdZ1=dH⊙[Z1>0]dZ_1 = dH \odot [Z_1 > 0]n×32n \times 32
은닉층 가중치dW1=XTdZ1dW_1 = X^T dZ_1, db1=∑dZ1d\mathbf{b}_1 = \sum dZ_12×322 \times 32

첫 줄 P−YP - Y는 정보 이론 강의의 "예측 빼기 정답"이에요. ReLU는 0보다 컸던 곳만 기울기를 통과시키는 문(마스크)이에요. 그리고 기울기의 모양은 항상 원래 값의 모양과 같아요. 헷갈리면 모양을 맞추는 식으로 행렬 곱의 순서와 전치를 정하면 돼요.

import numpy as np
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=1000, noise=0.2, random_state=0)
Y = np.eye(2)[y]                                   # 정답을 원핫으로
rng = np.random.default_rng(0)
W1 = rng.normal(0, np.sqrt(2 / 2), (2, 32)); b1 = np.zeros(32)
W2 = rng.normal(0, np.sqrt(2 / 32), (32, 2)); b2 = np.zeros(2)

def forward(X, W1, b1, W2, b2):
    Z1 = X @ W1 + b1
    H = np.maximum(0, Z1)
    Z2 = H @ W2 + b2
    Z2 = Z2 - Z2.max(1, keepdims=True)             # 넘치지 않게
    P = np.exp(Z2) / np.exp(Z2).sum(1, keepdims=True)
    return Z1, H, P

def loss_fn(P, Y):
    return -np.mean(np.sum(Y * np.log(P + 1e-12), 1))

def backward(X, Y, Z1, H, P, W2):
    n = len(X)
    dZ2 = (P - Y) / n
    dW2, db2 = H.T @ dZ2, dZ2.sum(0)
    dH = dZ2 @ W2.T
    dZ1 = dH * (Z1 > 0)
    dW1, db1 = X.T @ dZ1, dZ1.sum(0)
    return dW1, db1, dW2, db2

기울기 검사: 구현이 맞는지 확인하는 습관

역전파 구현에 실수가 있어도 학습은 그럭저럭 되는 것처럼 보일 수 있어요. 그래서 수치 미분과 비교하는 기울기 검사를 꼭 해요.

Z1, H, P = forward(X[:50], W1, b1, W2, b2)
dW1 = backward(X[:50], Y[:50], Z1, H, P, W2)[0]

eps = 1e-6
num = np.zeros_like(W1)
for i in range(W1.shape[0]):
    for j in range(W1.shape[1]):
        Wp, Wm = W1.copy(), W1.copy()
        Wp[i, j] += eps
        Wm[i, j] -= eps
        num[i, j] = (loss_fn(forward(X[:50], Wp, b1, W2, b2)[2], Y[:50])
                     - loss_fn(forward(X[:50], Wm, b1, W2, b2)[2], Y[:50])) / (2 * eps)
print(f"{np.abs(num - dW1).max() / (np.abs(num).max() + np.abs(dW1).max()):.1e}")   # 6.2e-10

상대 오차가 10−1010^{-10} 수준이면 구현이 맞다는 뜻이에요. 보통 10−710^{-7}보다 작으면 통과, 10−310^{-3}보다 크면 어딘가 틀렸어요.

여기서 역전파가 왜 위대한지도 보여요. 수치 미분은 가중치 하나마다 순전파를 두 번 해야 해요. 가중치 64개짜리 W1W_1에 순전파 128번이 들었어요. 가중치가 수천억 개면 불가능하죠. 역전파는 순전파 한 번과 비슷한 비용으로 모든 가중치의 기울기를 한꺼번에 구해요.

직접 학습시키기

미니배치 100개씩, 학습률 0.5로 300에포크 학습해 볼게요.

lr = 0.5
for epoch in range(1, 301):
    idx = rng.permutation(len(X))                  # 에포크마다 섞어서
    for s in range(0, len(X), 100):                # 100개씩 미니배치
        bi = idx[s:s + 100]
        Z1, H, P = forward(X[bi], W1, b1, W2, b2)
        dW1, db1, dW2, db2 = backward(X[bi], Y[bi], Z1, H, P, W2)
        W1 -= lr * dW1; b1 -= lr * db1; W2 -= lr * dW2; b2 -= lr * db2
    if epoch in (1, 10, 50, 100, 300):
        P = forward(X, W1, b1, W2, b2)[2]
        print(epoch, round(loss_fn(P, Y), 4), round((P.argmax(1) == y).mean(), 3))
에포크손실학습 데이터 정확도
10.3190.864
100.2250.912
500.0900.966
1000.0860.964
3000.0810.972

라이브러리 없이 numpy만으로 반달 모양을 배웠어요. scikit-learn의 MLPClassifier가 안에서 하는 일이 정확히 이거예요.

PyTorch의 자동 미분과 비교하기

PyTorch는 우리 Value를 행렬로 확장하고 GPU에서 빠르게 돌게 만든 거라고 생각하면 돼요. 같은 가중치로 기울기를 구해 비교해 볼게요.

import torch

Xt = torch.tensor(X[:50], dtype=torch.float64)
W1t, b1t = torch.tensor(W1, requires_grad=True), torch.tensor(b1, requires_grad=True)
W2t, b2t = torch.tensor(W2, requires_grad=True), torch.tensor(b2, requires_grad=True)
logits = torch.relu(Xt @ W1t + b1t) @ W2t + b2t
torch.nn.functional.cross_entropy(logits, torch.tensor(y[:50])).backward()   # 역전파 한 줄

Z1, H, P = forward(X[:50], W1, b1, W2, b2)
dW1, db1, dW2, db2 = backward(X[:50], Y[:50], Z1, H, P, W2)
print(f"{np.abs(W1t.grad.numpy() - dW1).max():.1e}", f"{np.abs(W2t.grad.numpy() - dW2).max():.1e}")   # 7.6e-17 3.5e-17

차이가 10−1710^{-17}, 컴퓨터가 표현할 수 있는 가장 작은 오차 수준이에요. 우리가 손으로 유도한 표의 공식이 PyTorch가 자동으로 하는 계산과 같다는 뜻이에요. 앞으로는 .backward() 한 줄에 맡기지만, 그 안에서 무슨 일이 일어나는지 이제 알아요.

깊어지면 기울기가 사라진다

층을 10개 쌓은 신경망에서 층마다 기울기의 크기를 재 볼게요. 시그모이드와 ReLU를 비교해요.

def grad_norms(act, depth=10, width=64, seed=0):
    r = np.random.default_rng(seed)
    Xv = r.normal(size=(256, width))
    Ws = [r.normal(0, np.sqrt((1 if act == "sigmoid" else 2) / width), (width, width)) for _ in range(depth)]
    hs, zs = [Xv], []
    for W in Ws:                                       # 순전파
        z = hs[-1] @ W
        zs.append(z)
        hs.append(1 / (1 + np.exp(-z)) if act == "sigmoid" else np.maximum(0, z))
    g = np.ones_like(hs[-1]) / len(Xv)
    norms = []
    for k in reversed(range(depth)):                   # 역전파
        s = hs[k + 1]
        dz = g * (s * (1 - s) if act == "sigmoid" else (zs[k] > 0))
        norms.append(np.linalg.norm(hs[k].T @ dz))
        g = dz @ Ws[k].T
    return norms[::-1]

for act in ["sigmoid", "relu"]:
    nm = grad_norms(act)
    print(act, f"{nm[0]:.2e}", f"{nm[-1]:.2e}")   # sigmoid 1.56e-06 7.65e+00 / relu 7.17e+00 2.24e+01
활성화첫 층의 기울기 크기마지막 층의 기울기 크기
시그모이드0.00000167.65
ReLU7.1722.4

시그모이드 신경망은 첫 층의 기울기가 마지막 층의 500만분의 1이에요. 시그모이드의 국소 기울기 s(1−s)s(1-s)는 최대 0.25라서, 층을 지날 때마다 기울기가 4분의 1 이하로 줄어들어요. 10층이면 0.2510≈10−60.25^{10} \approx 10^{-6}이죠. 앞쪽 층은 사실상 배우지 못해요. 이것이 기울기 소실 문제이고, 2000년대 중반까지 깊은 신경망이 잘 학습되지 않던 큰 이유였어요.

ReLU는 0보다 큰 곳에서 국소 기울기가 정확히 1이라 기울기가 줄지 않고 흘러가요. 여기에 알맞은 초기화(코드의 2/너비\sqrt{2/\text{너비}}, 학습 기술 강의에서 다뤄요)가 더해져, 첫 층과 마지막 층의 기울기 크기가 세 배 차이 안쪽으로 유지돼요. 깊은 신경망이 학습되기 시작한 결정적인 이유 중 하나예요.

실습

  1. Value에 뺄셈(__sub__), 거듭제곱(__pow__), ReLU를 추가하고, 수치 미분으로 검사해 보세요.
  2. Value로 뉴런 3개짜리 작은 신경망을 만들어 XOR 데이터 4개를 학습시켜 보세요.
  3. numpy 신경망의 backward에서 ReLU 마스크(* (Z1 > 0))를 일부러 빼고 기울기 검사를 해 보세요. 상대 오차가 어떻게 되나요?
  4. 기울기 소실 실험의 층 수를 5, 20, 50으로 바꿔 시그모이드 첫 층의 기울기 크기가 어떻게 변하는지 그려 보세요.

자주 하는 실수

  • 기울기를 덮어쓰기(=). 여러 길로 돌아오는 기울기는 더해야 해요.
  • 기울기 검사 없이 역전파 구현을 믿기. 학습이 "그럭저럭" 되는 버그가 제일 무서워요.
  • 행렬 모양을 확인하지 않기. 기울기의 모양은 원래 값의 모양과 같아야 해요.
  • 손실의 평균과 합을 섞기. dZ2dZ_2에서 nn으로 나눌지는 손실을 평균으로 정의했는지에 달려 있어요.

점검 문제

  1. c=a×bc = a \times b에서 a=3a = 3, b=−2b = -2이고, 뒤에서 들어온 기울기가 5예요. aa와 bb의 기울기는?
  2. 같은 변수가 계산에 두 번 쓰이면 기울기를 어떻게 처리하나요?
  3. 소프트맥스와 교차 엔트로피를 함께 쓸 때 출력층의 dZdZ는?
  4. 가중치가 100만 개일 때, 수치 미분과 역전파는 각각 순전파를 대략 몇 번 해야 하나요?
  5. 시그모이드 신경망에서 기울기 소실이 일어나는 이유는?

정답

  1. aa의 기울기는 5×b=−105 \times b = -10, bb의 기울기는 5×a=155 \times a = 15예요.
  2. 각 길에서 돌아온 기울기를 모두 더해요.
  3. (P−Y)/n(P - Y)/n, 즉 예측 확률 빼기 정답(평균 손실이면 배치 크기로 나눠요)이에요.
  4. 수치 미분은 가중치마다 두 번이라 약 200만 번, 역전파는 순전파 한 번과 역전파 한 번이면 돼요.
  5. 시그모이드의 국소 기울기가 최대 0.25라서, 층을 지날 때마다 기울기가 곱해져 계속 작아지기 때문이에요.

다음 강의

원리를 알았으니, 이제 실전 도구로 넘어가요. 다음 강의에서는 PyTorch로 텐서를 다루고, nn.Module로 모델을 정의하고, 데이터 로더와 학습 루프를 쓰는 표준적인 방법을 익혀요. 오늘 손으로 쓴 코드가 몇 줄로 줄어드는 걸 보게 될 거예요.