4강 / 20강

역전파 — 연쇄법칙 하나가 전부다

손으로 스무 줄이면 끝난다

가중치가 수천 개인데, 각각을 어느 쪽으로 얼마나 움직여야 할까요?

답은 미적분 첫 학기에 나오는 것 하나입니다 — 연쇄법칙.

∂L/∂w = (∂L/∂a) · (∂a/∂z) · (∂z/∂w)

출력 쪽에서 시작해 한 층씩 거꾸로 곱해 나가면 모든 가중치의 기울기가 나옵니다. 그것이 역전파의 전부예요.

고등학생연쇄법칙 하나가 전부다

역전파는 이름이 무서운 것 중 하나입니다. 실제로는 고등학교 미분이에요.

알아야 할 것 — 합성함수의 미분(연쇄법칙) 하나

연쇄법칙이 뭔가

y 가 u 에 의존하고 u 가 x 에 의존하면 —

dy/dx = (dy/du) × (du/dx)

즉 영향을 곱해서 이어 갑니다.

비유 — 톱니바퀴

바퀴 A 가 B 를 돌리고 B 가 C 를 돌립니다.

관계	배수
A → B	2배
B → C	3배
A → C	6배 (2×3)

중간을 거쳐 가는 영향은 곱해진다

신경망에서는

손실이 맨 앞 가중치에 얼마나 영향받는지 알려면?

단계	영향
손실 ← 출력	×
출력 ← 3층	×
3층 ← 2층	×
2층 ← 가중치	=

뒤에서 앞으로 곱해 가며 온다 — 그래서 '역'전파

그리고 이 곱셈이 쌓이는 것이 6강의 기울기 소실·폭발의 정체입니다.

손으로 짠 기울기가 수치미분과 <b>아홉 자리까지</b> 맞습니다. 이 확인이 직접 짤 때의 안전장치예요.

Python 브라우저에서 실행

# 역전파를 손으로 - 수치미분과 맞는지 확인한다
import numpy as np
rng = np.random.default_rng(31)

def sigmoid(z): return 1/(1+np.exp(-np.clip(z, -30, 30)))

n, h = 20, 5
X = rng.normal(0, 1, (n, 2))
y = rng.integers(0, 2, n).astype(float)
W1 = rng.normal(0, .5, (2, h)); b1 = np.zeros(h)
W2 = rng.normal(0, .5, (h, 1)); b2 = np.zeros(1)

def forward(W1, b1, W2, b2):
    Z1 = X @ W1 + b1
    A1 = np.maximum(Z1, 0)
    p = sigmoid(A1 @ W2 + b2).ravel()
    p = np.clip(p, 1e-9, 1-1e-9)
    loss = -np.mean(y*np.log(p) + (1-y)*np.log(1-p))
    return Z1, A1, p, loss

# --- 순전파 ---
Z1, A1, p, loss = forward(W1, b1, W2, b2)

# --- 역전파: 출력에서 시작해 한 층씩 거꾸로 ---
d2 = ((p - y) / n)[:, None]          # 손실 -> 출력 z 까지 한 번에
gW2 = A1.T @ d2                      # z2 = A1 W2 + b2  ->  dW2 = A1ᵀ d2
gb2 = d2.sum(0)
d1 = (d2 @ W2.T) * (Z1 > 0)          # 뒤로 넘기고 ReLU 의 미분(0 또는 1)을 곱한다
gW1 = X.T @ d1
gb1 = d1.sum(0)

# --- 맞는지 확인: 수치미분과 견준다 ---
def numeric(param, idx, eps=1e-6):
    P = [W1, b1, W2, b2]
    orig = P[param].flat[idx]
    P[param].flat[idx] = orig + eps; lp = forward(*P)[3]
    P[param].flat[idx] = orig - eps; lm = forward(*P)[3]
    P[param].flat[idx] = orig
    return (lp - lm) / (2*eps)

print(f"손실 {loss:.6f}")
print()
print("  가중치        손으로 짠 기울기     수치미분        차이")
for name, g, pi in [("W1[0,0]", gW1.flat[0], 0), ("W1[1,2]", gW1.flat[3], 0),
                    ("W2[2,0]", gW2.flat[2], 2), ("b2[0]",   gb2.flat[0], 3)]:
    idx = {"W1[0,0]":0, "W1[1,2]":3, "W2[2,0]":2, "b2[0]":0}[name]
    num = numeric(pi, idx)
    print(f"  {name:10}  {g:+16.9f}  {num:+14.9f}  {abs(g-num):.2e}")
print()
print("소수점 아홉 자리까지 맞는다. 역전파가 제대로 짜였다는 뜻이다.")
print("이 확인(gradient check)은 직접 짤 때 반드시 한 번은 해야 한다.")

고등학생왜 앞에서 뒤로 하지 않나

궁금할 수 있습니다 — 앞에서부터 계산하면 안 될까요?

계산량이 어마어마하게 달라진다

비교해 보면

방향	계산 횟수
앞 → 뒤 (전진 미분)	파라미터 개수만큼 반복 ⚠
뒤 → 앞 (역전파)	한 번에 전부 ✔

파라미터가 백만 개면 백만 배 차이다

왜 이렇게 다른가

출력은 하나(손실)인데 입력(파라미터)은 많습니다.

방향	공유되는 것
앞 → 뒤	각 파라미터마다 따로 계산
뒤 → 앞	뒤쪽 계산을 모두가 공유 ✔

"많은 것 → 하나" 구조에서는 뒤에서 오는 것이 압도적으로 싸다

비유 — 소문의 출처 추적

방법	일의 양
사람마다 "네 말이 퍼졌나" 확인	사람 수만큼
소문에서 거꾸로 타고 올라간다	한 번 ✔

끝에서 시작하면 경로가 합쳐진다

이 아이디어가 딥러닝을 실용적으로 만들었습니다. 없었다면 학습이 백만 배 느렸을 거예요.

고등학생역전파의 세 줄

note 가 세 줄로 정리합니다. 실제로 코드도 그 정도예요.

단계	하는 일
순전파	입력 → 출력, 중간값을 저장
손실	정답과 얼마나 다른가
역전파	뒤에서 앞으로 기울기를 곱해 간다

중간값을 저장하는 것이 핵심이다 — 메모리를 쓰는 이유

왜 저장해야 하나

기울기를 계산하려면 순전파 때의 값이 필요합니다.

예	기울기
z = wx	∂z/∂w = x — x 값이 필요

그래서 큰 모형은 GPU 메모리가 부족해진다 — 배치 크기 제한

이게 7강과 이어집니다

배치 크기	메모리
작다	적게 쓴다 ✔
크다	중간값이 배치만큼 쌓인다 ⚠

"메모리 부족" 오류를 만나면 배치를 줄인다 — 가장 흔한 처방

비유 — 계산 과정 적어 두기

긴 계산의 중간 과정을 적어 두면 나중에 어디서 틀렸는지 찾을 수 있습니다.

방식	—
과정을 안 적는다	다시 처음부터
적어 둔다	거꾸로 따라간다 ✔ — 대신 종이가 든다

시간을 아끼고 메모리를 쓴다 — 전형적인 맞바꿈

왜 ReLU 가 편한가

③에서 곱하는 값을 보세요.

활성함수	미분	기울기가 뒤로 갈 때
ReLU	0 또는 1	1 이면 그대로 통과한다
로지스틱	최대 0.25	층마다 4분의 1 이하로 줄어든다

로지스틱을 은닉층에 쓰면 층 열 개를 지나며 기울기가 0.25¹⁰ ≈ 0.000001 배가 됩니다. 앞쪽 층은 사실상 학습이 안 돼요.

이것이 기울기 소실이고, 깊은 신경망이 오랫동안 안 되던 이유입니다 — 6강에서 봅니다.

🤔 확인 문제

역전파에서 ReLU 층을 지날 때 곱하는 값은?