WorldModels:Tutorial:04-DeepLearningBasics
lastmod 2026-11-18created 2026-11-172 edits
딥러닝과 PyTorch 기초는 World Model 튜토리얼의 4장이다. World Model 은 "상태와 행동을 넣으면 다음 상태가 나오는 함수"를 신경망으로 만든 것이므로, 이 장은 그 신경망을 학습시키는 도구인 미분, 경사 하강법, 역전파를 정의에서부터 유도한다. 2층 신경망의 역전파를 숫자로 손계산해 PyTorch autograd 와 같은 값이 나오는 것을 확인하고, Adam, 과적합과 정규화, 텐서와 학습 고리, 합성곱 신경망(CNN)까지 다룬 뒤 진자 그림에서 각도를 읽는 CNN 을 학습시킨다. 6장 이후의 모든 모델이 이 장의 학습 고리를 그대로 쓴다.
- 원문: 04. 딥러닝과 PyTorch 기초
- 실습 코드:
code/ch04_basics.py(wm_envs.py와 같은 폴더에서python ch04_basics.py. 노트북 CPU 4스레드에서 전체 약 3~6분이고 대부분 마지막 CNN 학습이다.--quick은 약 10초. 그림은figures/에 저장된다.) - 이전: 03. 정보 이론과 KL 발산 / 다음: 05. 강화학습 기초
신경망은 매개변수를 가진 함수다
\(y = wx + b\) 에서 \(w\), \(b\) 처럼 함수의 모양을 정하는 값을 매개변수(parameter)라 한다. 신경망(neural network)은 매개변수가 수천 개에서 수십억 개인 함수이고, 매개변수를 모두 묶어 \(\theta\), 신경망이 나타내는 함수를 \(f_\theta\) 라 쓴다.
\(\hat{y} = f_\theta(x)\)
학습은 데이터 \(\{(x_i, y_i)\}\) 를 보고 \(f_\theta(x_i)\) 가 \(y_i\) 에 가까워지는 \(\theta\) 를 찾는 일이다. 입력마다 정답이 짝지어진 데이터로 배우는 것을 지도 학습(supervised learning)이라 한다. "얼마나 가까운가"를 숫자 하나로 잰 것이 손실 함수(loss function) \(L(\theta)\) 이고, 가장 흔한 것은 평균 제곱 오차(mean squared error, MSE)다.
\(L(\theta) = \frac{1}{N} \sum_{i=1}^{N} \big(f_\theta(x_i) - y_i\big)^2, \qquad \theta^\ast = \operatorname*{arg\,min}_\theta L(\theta)\)
제곱을 쓰는 이유는 2장의 가우시안 최대우도에서 나온다. 6장의 World Model 도 같은 틀이고, 입력 \(x\) 가 (상태, 행동), 정답 \(y\) 가 다음 상태일 뿐이다.
학습 고리(원문 그림 4-1)는 다음 네 단계를 수천 번 되풀이한다.
- 순전파: 데이터 \(x\) 를 모델 \(f_\theta\) 에 넣어 예측 \(\hat{y}\) 를 얻는다.
- 손실: \(\hat{y}\) 와 정답 \(y\) 를 비교해 \(L\) 을 계산한다.
- 역전파: 기울기 \(\nabla_\theta L\), 곧 각 매개변수를 어느 쪽으로 돌려야 \(L\) 이 줄어드는지를 구한다.
- 갱신: \(\theta \leftarrow \theta - \eta \nabla_\theta L\).
PyTorch 코드에서는 맨 앞에 "지난 스텝의 기울기 지우기"가 붙어 다섯 단계가 된다. 이 장은 3번과 4번이 왜 작동하는지를 설명한다.
미분
정의
미분(derivative) \(f'(x)\) 는 \(x\) 를 아주 조금 바꿨을 때 \(f\) 가 몇 배로 바뀌는가, 곧 그래프의 기울기다.
\(f'(x) = \frac{df}{dx} = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}\)
\(f(x) = x^2\) 의 \(x = 3\) 에서 평균 기울기는 \(h = 0.1,\ 0.01,\ 0.001\) 일 때 6.1, 6.01, 6.001 로 6 에 다가간다. 식으로는 다음과 같다.
\(\begin{align} \frac{(x+h)^2 - x^2}{h} &= \frac{x^2 + 2xh + h^2 - x^2}{h} = 2x + h \\ f'(x) &= \lim_{h \to 0} (2x + h) = 2x \end{align}\)
미분 규칙
신경망 학습에 필요한 규칙은 다섯 가지다.
| 규칙 | 식 | 유도의 뼈대 |
| 상수배, 합 | \((c\,f)' = c\,f'\), \((f + g)' = f' + g'\) | 정의식의 분자에서 \(c\) 를 밖으로 빼거나 \(f\), \(g\) 부분을 나눈다. 예: \((3x^2 + x)' = 6x + 1\). |
| 거듭제곱 | \((x^n)' = n x^{n-1}\) | 이항 정리로 \((x+h)^n = x^n + n x^{n-1} h + \binom{n}{2} x^{n-2} h^2 + \cdots + h^n\). \(x^n\) 을 빼고 \(h\) 로 나누면 첫 항 \(n x^{n-1}\) 외에는 모두 \(h\) 가 곱해져 있어 극한에서 사라진다. \(n\) 이 음수, 분수여도 성립한다(\((x^{-1})' = -x^{-2}\)). |
| 곱 | \((fg)' = f'g + fg'\) | 분자에 \(f(x)g(x+h)\) 를 빼고 더해 \(\big(f(x+h) - f(x)\big)g(x+h) + f(x)\big(g(x+h) - g(x)\big)\) 로 묶은 뒤 \(h\) 로 나누고 극한을 취한다. |
| 지수, 로그 | \((e^x)' = e^x\), \((\log x)' = 1/x\) | \(e \approx 2.71828\) 은 \(\lim_{h \to 0} \frac{e^h - 1}{h} = 1\) 이 되는 수다. \(\frac{e^{x+h} - e^x}{h} = e^x \cdot \frac{e^h - 1}{h} \to e^x\). 로그는 \(y = \log x \Leftrightarrow x = e^y\) 의 양변을 \(x\) 로 미분해 \(1 = e^y \frac{dy}{dx}\), 따라서 \(\frac{dy}{dx} = \frac{1}{e^y} = \frac{1}{x}\). |
| 연쇄 법칙 | \(\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}\) | 아래 참고. |
연쇄 법칙(chain rule)은 합성 함수(composite function) \(y = f(g(x))\) 의 미분이다. 신경망은 층을 겹겹이 쌓은 합성 함수이므로 이 규칙 하나가 곧 역전파다. 가운데 값을 \(u = g(x)\) 라 두고 \(\Delta u = g(x + h) - g(x)\), \(\Delta y = f(u + \Delta u) - f(u)\) 라 하면
\(\frac{\Delta y}{h} = \frac{\Delta y}{\Delta u} \cdot \frac{\Delta u}{h} \quad\Longrightarrow\quad \frac{dy}{dx} = f'(u) \cdot g'(x)\)
이다(\(\Delta u \ne 0\) 인 경우. 엄밀한 증명은 \(\Delta u = 0\) 인 경우를 따로 처리하지만 결과는 같다). 바깥 함수의 미분에 안쪽 함수의 미분을 곱한다. 맞물린 톱니바퀴에서 첫째가 1바퀴 돌 때 둘째가 3바퀴, 둘째가 1바퀴 돌 때 셋째가 2바퀴 돌면 셋째는 \(3 \times 2 = 6\) 바퀴 도는 것과 같이, 변화율은 곱해진다.
예: \(y = (3x + 1)^2\) 는 \(u = 3x + 1\), \(y = u^2\) 이므로 \(\frac{dy}{dx} = 2u \cdot 3 = 6(3x+1)\), \(x = 1\) 에서 24 다. 수치 검산은 \((4.003^2 - 16)/0.001 = 24.009\).
편미분과 기울기 벡터
매개변수가 여럿일 때 하나만 움직이고 나머지는 고정해서 미분하는 것이 편미분(partial derivative) \(\partial\) 이다. 데이터 한 점 \((x, y) = (2, 5)\) 에 대한 손실 \(L(w, b) = (2w + b - 5)^2\) 에서
\(\frac{\partial L}{\partial w} = 2(2w + b - 5) \cdot 2, \qquad \frac{\partial L}{\partial b} = 2(2w + b - 5) \cdot 1\)
\(\nabla L = \begin{pmatrix} \partial L / \partial w \\ \partial L / \partial b \end{pmatrix} = \begin{pmatrix} 4(2w + b - 5) \\ 2(2w + b - 5) \end{pmatrix} \;\overset{w=b=0}{=}\; \begin{pmatrix} -20 \\ -10 \end{pmatrix}\)
편미분을 모은 벡터가 기울기(gradient) \(\nabla L\) 이다. \(\nabla_\theta L\) 의 각 성분은 "그 매개변수를 아주 조금 키우면 손실이 얼마나 커지는가"이다. 양수면 그 매개변수를 줄여야 하고 음수면 키워야 한다. 기울기 벡터는 손실이 가장 가파르게 커지는 방향을 가리킨다.
경사 하강법
기울기 반대로 가면 손실이 준다
경사 하강법(Gradient descent)은 다음 한 줄을 되풀이한다. \(\eta\) 는 학습률(learning rate)로, 한 번에 얼마나 움직일지 정하는 작은 양수다.
\(\theta \leftarrow \theta - \eta \, \nabla_\theta L(\theta)\)
손실이 주는 이유는 1차 테일러 근사(first-order Taylor approximation)로 설명된다.
\(\begin{align} L(\theta + \Delta) &\approx L(\theta) + \sum_j \frac{\partial L}{\partial \theta_j}\Delta_j = L(\theta) + \nabla L \cdot \Delta \\ \Delta = -\eta \nabla L \;&\Longrightarrow\; L(\theta_{\text{new}}) \approx L(\theta) - \eta\, \lVert\nabla L\rVert^2 \;\le\; L(\theta) \end{align}\)
\(\lVert\nabla L\rVert^2\) 은 제곱의 합이라 0 이상이므로, 근사가 맞을 만큼 \(\eta\) 가 작으면 손실은 반드시 준다. 기울기가 0 이면 더 움직이지 않는다(최솟값 후보).
같은 거리 \(\lVert\Delta\rVert = c\) 를 움직일 때 손실을 가장 많이 줄이는 방향이 \(-\nabla L\) 이라는 것도 내적의 기하학적 뜻에서 나온다.
\(\nabla L \cdot \Delta = \lVert\nabla L\rVert\,\lVert\Delta\rVert \cos\alpha, \qquad \min_{\lVert\Delta\rVert = c} \nabla L \cdot \Delta = -\lVert\nabla L\rVert\, c \quad (\alpha = 180^\circ)\)
원문의 비유는 안개 낀 산에서 발밑 기울기만 느끼며 내려가는 것이다. 보폭(학습률)이 너무 작으면 내려가지 못하고, 너무 크면 골짜기를 건너뛰어 맞은편 비탈로 올라간다.
학습률의 상한
그릇 모양 손실 \(L(w) = \frac{a}{2}w^2\) (\(a \gt 0\))에서 \(a\) 는 곡률(curvature)이다. \(L'(w) = aw\) 이므로
\(w_{k+1} = (1 - \eta a)\, w_k \quad\Longrightarrow\quad w_k = (1 - \eta a)^k\, w_0\)
\(w_k \to 0 \iff \vert 1 - \eta a \vert \lt 1 \iff 0 \lt \eta \lt \frac{2}{a}\)
- \(\eta \gt 2/a\) 이면 \(w\) 가 부호를 바꾸며 커진다(발산).
- \(\eta = 1/a\) 이면 한 스텝에 최솟값에 도착한다.
- 매개변수가 여럿이면 방향마다 곡률이 다르고, 가장 가파른 방향이 학습률의 상한을 정한다.
선형 회귀 손계산
점 세 개 \((1, 3), (2, 5), (3, 7)\) 에 직선 \(\hat{y} = wx + b\) 를 MSE 로 맞춘다(정답은 \(y = 2x + 1\)). 잔차를 \(e_i = w x_i + b - y_i\) 라 두면 연쇄 법칙으로
\(\frac{\partial L}{\partial w} = \frac{2}{N}\sum_i e_i x_i, \qquad \frac{\partial L}{\partial b} = \frac{2}{N}\sum_i e_i\)
\(w = b = 0\) 에서 출발해 \(\eta = 0.05\) 로 간 결과는 다음과 같다.
| 스텝 | \(w\) | \(b\) | 잔차 \(e\) | 손실 | \(\partial L/\partial w\) | \(\partial L/\partial b\) |
| 0 | 0 | 0 | \((-3, -5, -7)\) | \(83/3 \approx 27.6667\) | \(\frac{2}{3}(-34) \approx -22.6667\) | \(\frac{2}{3}(-15) = -10\) |
| 1 | 1.1333 | 0.5 | \((-1.3667, -2.2333, -3.1)\) | 5.4885 | \(-10.0889\) | \(-4.4667\) |
| 2 | 1.6378 | 0.7233 | 1.0897 | \(-4.4874\) | \(-2.0022\) |
2000 스텝 뒤에는 \(w = 2.0000\), \(b = 1.0000\), 손실 \(1.43 \times 10^{-24}\) 이다. 같은 계산을 numpy 로 쓴 것이 아래 코드이고, 유도한 기울기 공식이 dw, db 두 줄이 된다.
def linreg_gradient_descent(x, y, lr=0.05, steps=2000, verbose_steps=3):
"""ŷ = w·x + b 를 MSE 로 맞춘다. 기울기는 손으로 유도한 식을 그대로 쓴다.
L = (1/N) Σ (w·x_i + b − y_i)²
∂L/∂w = (2/N) Σ (w·x_i + b − y_i)·x_i
∂L/∂b = (2/N) Σ (w·x_i + b − y_i)
"""
w, b = 0.0, 0.0 # 시작점: 아무것도 모르는 상태
n = len(x)
history = [] # (w, b, loss)
for step in range(steps + 1):
y_hat = w * x + b # 예측 (N,)
err = y_hat - y # 잔차 (N,)
loss = np.mean(err**2) # MSE
history.append((w, b, loss))
if step < verbose_steps:
dw = 2.0 / n * np.sum(err * x)
db = 2.0 / n * np.sum(err)
print(f" step {step}: w={w:.4f} b={b:.4f} loss={loss:.4f} dL/dw={dw:.4f} dL/db={db:.4f}")
if step == steps:
break
dw = 2.0 / n * np.sum(err * x) # ∂L/∂w
db = 2.0 / n * np.sum(err) # ∂L/∂b
w = w - lr * dw # 기울기 반대 방향으로 한 스텝
b = b - lr * db
return w, b, np.array(history)
학습률을 바꿔 200 스텝씩 돌린 손실은 다음과 같다.
| 학습률 | 200 스텝 뒤 손실 |
| 0.01 | 5.556e-04 (느리다) |
| 0.05 | 1.154e-05 |
| 0.17 | 8.211e-11 |
| 0.19 | 1.601e+19 (발산) |
경계가 0.18 인 이유는 헤세 행렬(두 번 미분한 값을 모은 표)의 고윳값에서 나온다. \(\frac{\partial^2 L}{\partial w^2} = \frac{2}{N}\sum x_i^2 = \frac{28}{3} \approx 9.333\), \(\frac{\partial^2 L}{\partial b^2} = 2\), \(\frac{\partial^2 L}{\partial w \partial b} = \frac{2}{N}\sum x_i = 4\) 이므로
\(H = \begin{pmatrix} 9.333 & 4 \\ 4 & 2 \end{pmatrix},\qquad \det(H - \lambda I) = \lambda^2 - 11.333\lambda + 2.667 = 0\)
\(\lambda = \frac{11.333 \pm 10.853}{2} \approx 11.093,\ 0.240\)
고유벡터 방향만 보면 손실은 \(\frac{\lambda}{2}w^2\) 꼴의 그릇이라 고윳값이 방향별 곡률이다. 가장 가파른 방향의 곡률이 11.093 이므로 \(\eta \lt 2/11.093 \approx 0.180\) 이어야 수렴한다. 0.17 은 안쪽, 0.19 는 바깥쪽이다. 가장 완만한 방향의 곡률이 0.240 으로 작아서 \(\eta = 0.01\) 에서는 그 방향으로 아주 느리게 움직인다.
활성 함수와 층 쌓기
선형 층과 비선형성
선형 층(linear layer, fully-connected layer)은 입력 \(x \in \mathbb{R}^{n}\) 을 가중치 행렬 \(W \in \mathbb{R}^{m \times n}\) 과 편향 \(b \in \mathbb{R}^m\) 으로 바꾼다.
\(z = W x + b, \qquad z_j = \sum_{i=1}^{n} W_{ji}\, x_i + b_j\)
선형 층만 쌓으면 몇 개를 쌓아도 선형 층 하나와 같다.
\(y = W_2 (W_1 x + b_1) + b_2 = W' x + b', \qquad W' = W_2 W_1,\ b' = W_2 b_1 + b_2\)
그래서 층 사이에 활성 함수(activation function)를 끼워 \(h = \sigma(Wx + b)\) 처럼 성분마다 적용한다. 은닉 뉴런이 충분히 많으면 유한한 구간 위의 어떤 연속 함수든 원하는 만큼 가깝게 근사할 수 있다는 것이 보편 근사 정리(universal approximation theorem)다.
시그모이드, tanh, ReLU
| 함수 | 식 | 치역 | 미분 | 쓰임 |
| 시그모이드 | \(\sigma(z) = \frac{1}{1 + e^{-z}}\) | 0~1 | \(\sigma(z)(1 - \sigma(z))\), 최댓값 0.25 (\(z = 0\)) | 확률이나 0~1 사이 밝기 출력. 마지막 층에만 쓴다. |
| tanh | \(\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}\) | -1~1 | \(1 - \tanh^2(z)\), 최댓값 1 (\(z = 0\)) | 출력 평균이 0 근처라 은닉층에 좋다. RNN(9장)에서 자주 쓴다. |
| ReLU | \(\max(0, z)\) | 0 이상 | \(z \gt 0\) 이면 1, \(z \lt 0\) 이면 0 (\(z = 0\) 에서는 보통 0 으로 둔다) | 계산이 가장 싸고 양수 쪽 미분이 줄지 않아 깊은 신경망의 기본이다. |
수치 예: \(\sigma(0) = 0.5\), \(\sigma(2) \approx 0.881\), \(\sigma(-2) \approx 0.119\), \(\sigma'(2) \approx 0.881 \times 0.119 \approx 0.105\). 시그모이드와 tanh 는 \(\vert z \vert\) 가 크면 미분이 0 에 가까워진다(포화).
시그모이드 미분의 유도는 \(\sigma(z) = (1 + e^{-z})^{-1}\) 에 연쇄 법칙을 쓴다.
\(\begin{align} \sigma'(z) &= -(1 + e^{-z})^{-2} \cdot (-e^{-z}) = \frac{1}{1 + e^{-z}} \cdot \frac{e^{-z}}{1 + e^{-z}} \\ \frac{e^{-z}}{1 + e^{-z}} &= \frac{(1 + e^{-z}) - 1}{1 + e^{-z}} = 1 - \sigma(z) \\ \sigma'(z) &= \sigma(z)\,\big(1 - \sigma(z)\big) \end{align}\)
순전파에서 이미 계산한 \(\sigma(z)\) 만 있으면 미분이 나온다. tanh 는 시그모이드를 늘이고 옮긴 것이다.
\(\begin{align} 2\sigma(2z) - 1 &= \frac{1 - e^{-2z}}{1 + e^{-2z}} = \frac{e^z - e^{-z}}{e^z + e^{-z}} = \tanh(z) \\ \tanh'(z) &= 2\,\sigma'(2z)\cdot 2 = 4s(1 - s), \qquad s = \sigma(2z) \\ 1 - \tanh^2 &= 1 - (2s - 1)^2 = 4s - 4s^2 = 4s(1-s) \end{align}\)
기울기 소실(vanishing gradient): 시그모이드의 미분은 최대 0.25 이므로 층을 10개 쌓으면 역전파 때 \(0.25^{10} \approx 10^{-6}\) 까지 줄 수 있고, 앞쪽 층에 기울기가 거의 전달되지 않는다. 그래서 은닉층에는 ReLU 를 주로 쓴다. RNN 에서 이 문제가 다시 나온다(9장).
역전파: 2층 신경망 손계산
역전파(Backpropagation)는 새로운 수학이 아니라 연쇄 법칙을 출력 쪽에서부터 차례로 적용하고 중간 결과를 재사용하는 것이다.
신경망과 숫자
| 부분 | 식 | 값 |
| 입력 | \(x = (x_1, x_2)\) | \((1.0,\ 0.5)\) |
| 1층(은닉 2개) | \(z = W_1 x + b_1\), \(h = \sigma(z)\) | \(W_1 = \begin{pmatrix} 0.5 & -0.4 \\ 0.3 & 0.8 \end{pmatrix}\), \(b_1 = (0.1,\ -0.2)\) |
| 2층(출력 1개) | \(\hat{y} = w_2 \cdot h + b_2\) (활성 함수 없음) | \(w_2 = (1.2,\ -0.7)\), \(b_2 = 0.05\) |
| 손실 | \(L = (\hat{y} - y)^2\) | 정답 \(y = 1.0\) |
순전파
\(\begin{align} z_1 &= 0.5 \cdot 1.0 + (-0.4)\cdot 0.5 + 0.1 = 0.4, \qquad z_2 = 0.3 \cdot 1.0 + 0.8 \cdot 0.5 - 0.2 = 0.5 \\ h_1 &= \sigma(0.4) = \frac{1}{1 + 0.670320} = 0.598688, \qquad h_2 = \sigma(0.5) = \frac{1}{1 + 0.606531} = 0.622459 \\ \hat{y} &= 1.2 \times 0.598688 - 0.7 \times 0.622459 + 0.05 = 0.332704 \\ L &= (0.332704 - 1)^2 = (-0.667296)^2 = 0.445284 \end{align}\)
역전파
매개변수는 9개(\(W_1\) 4개, \(b_1\) 2개, \(w_2\) 2개, \(b_2\))다. 출력 쪽부터 거꾸로 가며, 각 단계는 바로 오른쪽에서 구한 값에 국소 미분 하나를 곱한다.
| 순서 | 구하는 것 | 식(국소 미분) | 값 |
| 1 | \(\partial L/\partial \hat{y}\) | \(2(\hat{y} - y)\) | \(-1.334593\) |
| 2 | \(\partial L/\partial w_{2,j}\) | \(\frac{\partial L}{\partial \hat{y}} \cdot h_j\) | \((-0.799004,\ -0.830730)\) |
| 3 | \(\partial L/\partial b_2\) | \(\frac{\partial L}{\partial \hat{y}} \cdot 1\) | \(-1.334593\) |
| 4 | \(\partial L/\partial h_j\) | \(\frac{\partial L}{\partial \hat{y}} \cdot w_{2,j}\) | \((-1.601511,\ 0.934215)\) |
| 5 | \(\sigma'(z_j) = h_j(1 - h_j)\) | 순전파 값 재사용 | \((0.240261,\ 0.235004)\) |
| 6 | \(\partial L/\partial z_j\) | \(\frac{\partial L}{\partial h_j} \cdot h_j(1 - h_j)\) | \((-0.384780,\ 0.219544)\) |
| 7 | \(\partial L/\partial W_{1,ji}\) | \(\frac{\partial L}{\partial z_j} \cdot x_i\) (\(\partial L/\partial z\) 와 \(x\) 의 바깥곱) | \(\begin{pmatrix} -0.384780 & -0.192390 \\ 0.219544 & 0.109772 \end{pmatrix}\) |
| 8 | \(\partial L/\partial b_1\) | \(\frac{\partial L}{\partial z} \cdot 1\) | \((-0.384780,\ 0.219544)\) |
4번의 \(\partial L/\partial h_j\) 는 매개변수의 기울기가 아니지만 더 왼쪽으로 기울기를 전달하는 데 필요하다. 5번에서 시그모이드의 국소 기울기가 최대 0.25 라 기울기가 1/4 정도로 준다.
역전파의 구조는 세 가지로 정리된다.
- 각 노드가 하는 일은 하나다. (오른쪽에서 받은 기울기) × (이 노드의 국소 미분)을 왼쪽으로 넘긴다.
- 국소 미분에는 순전파에서 계산한 값(\(h_j\), \(x_i\))이 다시 쓰인다. 그래서 순전파 값을 메모리에 저장해 둔다.
- 출력 쪽에서 한 번 계산한 \(\partial L/\partial \hat{y}\) 가 모든 매개변수의 기울기에 재사용된다. 매개변수가 수십억 개여도 역전파 비용이 순전파의 2~3배 정도에 그치는 이유다.
한 스텝 갱신
\(\eta = 0.1\) 로 9개를 모두 갱신하면 예를 들어 \(w_{2,1} = 1.2 - 0.1 \times (-0.799004) = 1.279900\), \(W_{1,11} = 0.538478\), \(b_2 = 0.183459\) 가 된다. 다시 순전파하면 \(\hat{y} = 0.599293\), \(L = 0.160566\) 으로, 한 스텝에 손실이 0.4453 에서 0.1606 으로 준다.
autograd 로 확인
손계산을 numpy 로 옮긴 코드다.
# 본문의 손계산과 똑같은 숫자
x = np.array([1.0, 0.5]) # 입력 (2,)
W1 = np.array([[0.5, -0.4],
[0.3, 0.8]]) # 1층 가중치 (은닉 2, 입력 2)
b1 = np.array([0.1, -0.2]) # 1층 편향 (2,)
w2 = np.array([1.2, -0.7]) # 2층 가중치 (2,)
b2 = 0.05 # 2층 편향
y = 1.0 # 정답
# 순전파
z = W1 @ x + b1 # (2,) z_j = Σ_i W1[j,i]·x_i + b1[j]
h = sigmoid(z) # (2,)
y_hat = w2 @ h + b2 # 스칼라
L = (y_hat - y) ** 2
# 역전파 (연쇄 법칙을 뒤에서부터)
dL_dyhat = 2 * (y_hat - y)
dL_dw2 = dL_dyhat * h # ŷ = w2·h + b2 → ∂ŷ/∂w2 = h
dL_db2 = dL_dyhat
dL_dh = dL_dyhat * w2 # ∂ŷ/∂h = w2
dL_dz = dL_dh * h * (1 - h) # σ'(z) = σ(z)(1 − σ(z))
dL_dW1 = np.outer(dL_dz, x) # ∂z_j/∂W1[j,i] = x_i
dL_db1 = dL_dz
print(f" z={z}, h={np.round(h, 6)}, y_hat={y_hat:.6f}, L={L:.6f}")
print(" [손계산] dL/dw2 =", np.round(dL_dw2, 6), " dL/db2 =", round(dL_db2, 6))
print(" [손계산] dL/dW1 =", np.round(dL_dW1, 6).tolist(), " dL/db1 =", np.round(dL_db1, 6))
PyTorch 의 자동 미분(autograd)은 순전파 때 기록한 계산 그래프를 .backward() 에서 거꾸로 따라가며 같은 연쇄 법칙 계산을 한다. requires_grad=True 는 그 텐서에 대한 기울기를 구하라는 표시이고 결과는 .grad 에 들어간다.
tx = torch.tensor(x)
tW1 = torch.tensor(W1, requires_grad=True) # requires_grad=True: 이 값에 대한 기울기를 구해 줘
tb1 = torch.tensor(b1, requires_grad=True)
tw2 = torch.tensor(w2, requires_grad=True)
tb2 = torch.tensor(b2, requires_grad=True)
t_yhat = tw2 @ torch.sigmoid(tW1 @ tx + tb1) + tb2 # 순전파만 쓰면
t_L = (t_yhat - y) ** 2
t_L.backward() # 역전파는 PyTorch 가 알아서
print(" [autograd] dL/dw2 =", np.round(tw2.grad.numpy(), 6), " dL/db2 =", round(tb2.grad.item(), 6))
print(" [autograd] dL/dW1 =", np.round(tW1.grad.numpy(), 6).tolist(), " dL/db1 =", np.round(tb1.grad.numpy(), 6))
same = np.allclose(tW1.grad.numpy(), dL_dW1) and np.allclose(tw2.grad.numpy(), dL_dw2)
print(" 두 결과가 같은가?", same)
z=[0.4 0.5], h=[0.598688 0.622459], y_hat=0.332704, L=0.445284
[손계산] dL/dw2 = [-0.799004 -0.83073 ] dL/db2 = -1.334593
[손계산] dL/dW1 = [[-0.38478, -0.19239], [0.219544, 0.109772]] dL/db1 = [-0.38478 0.219544]
[autograd] dL/dw2 = [-0.799004 -0.83073 ] dL/db2 = -1.334593
[autograd] dL/dW1 = [[-0.38478, -0.19239], [0.219544, 0.109772]] dL/db1 = [-0.38478 0.219544]
두 결과가 같은가? True
9개의 숫자가 소수점 여섯째 자리까지 같다. 8장의 재매개변수화 트릭이나 12장의 "상상 속에서 기울기를 흘려보내기"는 모두 연쇄 법칙이 끊기지 않게 계산 그래프를 잇는 요령이다.
분류: 소프트맥스와 교차 엔트로피
분류에서는 신경망이 클래스마다 점수 \(z_k\)(로짓, logit)를 내고 소프트맥스(Softmax)로 확률로 바꾼다. 이 조합은 DreamerV2, V3 의 범주형 잠재 변수(12장)와 이산 행동 정책(5장)에 쓰인다.
\(p_k = \frac{e^{z_k}}{\sum_{j=1}^{K} e^{z_j}}\)
예: \(z = (2,\ 1,\ 0.1)\) 이면 \(e^z = (7.389,\ 2.718,\ 1.105)\), 합 11.213, \(p = (0.659,\ 0.242,\ 0.099)\).
정답이 클래스 \(c\) 일 때 손실은 정답 클래스 확률의 음의 로그인 교차 엔트로피(Cross entropy)다. 정답을 원-핫 벡터 \(y\) 로 쓰면 \(L = -\sum_k y_k \log p_k = -\log p_c\). 이 손실의 출처는 2장(최대우도)과 3장(정보 이론)에 있다. 기울기는 다음과 같이 유도된다.
\(\begin{align} L &= -\log \frac{e^{z_c}}{\sum_j e^{z_j}} = -z_c + \log\sum_j e^{z_j} \\ \frac{\partial}{\partial z_i}(-z_c) &= -\mathbf{1}[i = c] = -y_i \\ \frac{\partial}{\partial z_i}\log\sum_j e^{z_j} &= \frac{e^{z_i}}{\sum_j e^{z_j}} = p_i \\ \frac{\partial L}{\partial z_i} &= p_i - y_i \end{align}\)
"예측 확률 − 정답"이다. 정답 클래스의 로짓은 올리고(\(p_c - 1 \lt 0\)) 나머지는 자기 확률만큼 내린다. 위 예에서 정답이 0번이면 기울기는 \((-0.341,\ 0.242,\ 0.099)\) 이다.
import torch
import torch.nn.functional as F
z = torch.tensor([2.0, 1.0, 0.1], requires_grad=True) # 로짓
target = torch.tensor(0) # 정답 클래스 = 0번
loss = F.cross_entropy(z.unsqueeze(0), target.unsqueeze(0))
loss.backward()
print("p =", torch.softmax(z, dim=0).detach().numpy().round(4))
print("loss =", round(loss.item(), 4))
print("dL/dz =", z.grad.numpy().round(4)) # p − y 와 같은가?
MSE 의 기울기 \(\frac{\partial}{\partial\hat{y}}\frac{1}{2}(\hat{y} - y)^2 = \hat{y} - y\) 와 시그모이드 + 이진 교차 엔트로피의 기울기 \(\sigma(z) - y\) 도 같은 꼴이다. 세 손실 모두 어떤 확률 분포의 음의 로그 가능도이기 때문이다(2장).
미니배치, SGD, Adam
미니배치와 확률적 경사 하강
손실은 보통 데이터 \(N\) 개의 평균 \(L = \frac{1}{N}\sum_i \ell_i\) 이므로, 매번 무작위로 \(B\) 개(예: 64개)만 뽑아 그 평균 기울기로 한 스텝 간다. 이 묶음이 미니배치(minibatch), 이 방법이 확률적 경사 하강(Stochastic gradient descent, SGD)이다.
\(\begin{align} \hat{g} &= \frac{1}{B}\sum_{k=1}^{B} \nabla \ell_{I_k}, \qquad I_k \text{ 는 } \{1,\dots,N\} \text{ 에서 고르게 뽑은 번호} \\ \mathbb{E}[\nabla\ell_{I_k}] &= \sum_{i=1}^{N} \frac{1}{N}\,\nabla \ell_i = \nabla L \\ \mathbb{E}[\hat{g}] &= \frac{1}{B}\cdot B \cdot \nabla L = \nabla L \end{align}\)
미니배치 기울기는 편향 없는(unbiased) 추정이다. 잡음이 있지만 뽑기가 서로 독립이면 분산은 \(\operatorname{Var}\big(\frac{1}{B}\sum_k X_k\big) = \frac{\sigma^2}{B}\) 로 \(1/B\) 배가 된다. 미니배치 하나로 한 번 갱신하는 것이 스텝(step, iteration), 데이터 전체를 한 바퀴 도는 것이 에폭(epoch)이다.
지수 이동 평균
출렁이는 미니배치 기울기를 다듬는 데 지수 이동 평균(exponential moving average, EMA)을 쓴다.
\(m_t = \beta\, m_{t-1} + (1 - \beta)\, g_t, \quad m_0 = 0 \qquad\Longrightarrow\qquad m_t = (1-\beta)\sum_{k=1}^{t}\beta^{\,t-k}\, g_k\)
\(j\) 스텝 전 기울기의 가중치는 \((1-\beta)\beta^{j}\) 로 오래될수록 준다. \(\beta = 0.9\) 면 대략 최근 \(\frac{1}{1-\beta} = 10\) 스텝의 평균이다. 이 유효 길이는 5장의 할인율에서 "유효 지평"으로 다시 나온다.
Adam
Adam(adaptive moment estimation)은 기울기의 평균(1차 모멘트)과 기울기 제곱의 평균(2차 모멘트)을 매개변수마다 따로 들고 다닌다. 이 튜토리얼의 신경망 학습은 10장에서 컨트롤러를 CMA-ES 로 학습하는 것만 빼고 모두 Adam 을 쓴다.
\(\begin{align} m_t &= \beta_1 m_{t-1} + (1-\beta_1)\, g_t && \text{기울기의 이동 평균 (방향)} \\ v_t &= \beta_2 v_{t-1} + (1-\beta_2)\, g_t^2 && \text{기울기 제곱의 이동 평균 (크기)} \\ \hat{m}_t &= \frac{m_t}{1 - \beta_1^t},\quad \hat{v}_t = \frac{v_t}{1 - \beta_2^t} && \text{편향 보정} \\ \theta_t &= \theta_{t-1} - \eta\, \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon} && \text{갱신} \end{align}\)
기본값은 \(\beta_1 = 0.9\), \(\beta_2 = 0.999\), \(\epsilon = 10^{-8}\), \(\eta = 10^{-3}\) 이다.
- \(\hat{m}_t\): 최근 기울기의 평균 방향(모멘텀). 잡음을 걸러 낸다.
- \(\sqrt{\hat{v}_t}\): 최근 기울기 크기의 대푯값. 나누어 주면 매개변수마다 스텝 크기가 대략 \(\eta\) 로 맞춰진다. 기울기가 늘 같은 방향이면 \(\hat{m}/\sqrt{\hat{v}} \approx \pm 1\), 방향이 자주 바뀌면 \(\hat{m}\) 이 작아져 조금만 움직인다. 기울기 크기가 매개변수마다 수천 배 달라도 학습률 하나로 다룰 수 있는 이유다.
- \(\epsilon\): 0 으로 나누는 것을 막는다.
편향 보정은 \(m_0 = v_0 = 0\) 에서 시작해 생기는 치우침을 바로잡는다. 기울기들의 기댓값이 모두 \(\mathbb{E}[g]\) 로 같다고 가정하면
\(\begin{align} \mathbb{E}[m_t] &= (1-\beta_1)\sum_{k=1}^{t}\beta_1^{\,t-k}\,\mathbb{E}[g] = (1 - \beta_1^t)\,\mathbb{E}[g] \\ \mathbb{E}\!\left[\frac{m_t}{1-\beta_1^t}\right] &= \mathbb{E}[g] \end{align}\)
여기서 등비수열의 합 \((1-\beta)(1 + \beta + \cdots + \beta^{t-1}) = 1 - \beta^t\) 을 썼다. \(t = 1\) 이면 \(m_1 = 0.1\,g_1\) 이고 보정하면 \(\hat{m}_1 = g_1\) 이다. \(t = 50\) 이면 \(1 - 0.9^{50} \approx 0.995\) 라 보정이 거의 필요 없다. \(v_t\) 는 \(\beta_2 = 0.999\) 라 보정이 더 오래 중요하다.
과적합, 검증 데이터, 정규화
과적합
목표는 처음 보는 데이터에서도 잘 맞추는 일반화(generalization)다. 훈련 데이터의 손실은 계속 주는데 처음 보는 데이터의 손실은 커지는 현상이 과적합(overfitting)이다. 그래서 데이터를 나눈다.
- 훈련(train) 데이터
- 기울기를 계산해 매개변수를 고치는 데 쓴다.
- 검증(validation) 데이터
- 학습에는 쓰지 않고, 일반화를 지켜보며 학습률, 모델 크기 같은 설정을 고르는 데 쓴다.
- 시험(test) 데이터
- 모든 결정을 끝낸 뒤 마지막에 한 번만 성능을 잰다.
실험(ch04_basics.py 의 overfit 구간): 잡음 표준편차 0.3 인 점 12개에 매개변수 약 6.6만 개짜리 신경망(\(1 \to 256 \to 256 \to 1\), ReLU)을 Adam(lr 1e-3)으로 4000 스텝 학습시킨다. L2 벌점은 이름에 weight 가 든 매개변수의 제곱합에 \(\lambda\) 를 곱해 MSE 에 더한다.
| 설정 | 마지막 train | 마지막 val | val 최저 |
| 정규화 없음 | 0.0001 | 0.5977 | 0.1709 (step 33) |
| L2 벌점 \(\lambda = 10^{-2}\) | 0.0155 | 0.1793 | 0.1709 (step 35) |
정규화가 없으면 잡음까지 외워 곡선이 구불구불하고, 점이 없는 오른쪽 끝에서 엉뚱하게 치솟는다. 검증 손실은 처음 수십 스텝에 가장 낮았다가 다시 커진다. L2 정규화는 훈련 손실이 조금 높은 대신 검증 손실이 훨씬 낮다.
L2 정규화(가중치 감쇠)
과적합한 모델은 작은 입력 변화에도 출력이 크게 출렁이고, 그러려면 가중치가 커야 한다. 그래서 손실에 가중치 크기의 벌점을 더한다.
\(L_{\text{total}}(\theta) = L(\theta) + \lambda \sum_{w} w^2\)
\(w \leftarrow w - \eta\Big(\frac{\partial L}{\partial w} + 2\lambda w\Big) = (1 - 2\eta\lambda)\, w - \eta\,\frac{\partial L}{\partial w}\)
매 스텝 \(w\) 를 \((1 - 2\eta\lambda)\) 배로 줄이므로 가중치 감쇠(weight decay)라고도 한다. 데이터가 강하게 요구하지 않는 가중치는 0 쪽으로 준다.
다른 처방은 다음과 같다.
- 조기 종료(early stopping): 검증 손실이 가장 낮았던 시점의 매개변수를 쓴다. 위 실험에서는 약 30 스텝째다.
- 데이터 늘리기: 가장 확실한 처방이다. World Model 은 환경과 상호작용해 데이터를 계속 모을 수 있다(7장).
- 드롭아웃, 모델 줄이기 등. Adam 과 함께 쓸 때는 L2 벌점 대신 감쇠를 갱신식에 직접 넣는
AdamW가 흔히 쓰인다.
입력 표준화
입력 성분마다 크기가 크게 다르면(각도는 \(-\pi\)~\(\pi\), 속도는 \(-8\)~\(8\)) 학습이 느려진다. 표준화(standardization)는 성분마다 평균을 빼고 표준편차로 나눈다. 6장의 World Model 도 입력과 출력을 모두 표준화한다.
\(x' = \frac{x - \mu}{s}, \qquad \mu = \frac{1}{N}\sum_i x_i,\quad s = \sqrt{\frac{1}{N}\sum_i (x_i - \mu)^2}\)
표준화한 값은 평균 0, 분산 1 이다(\(\frac{1}{N}\sum_i x_i' = \frac{1}{s}(\mu - \mu) = 0\), \(\frac{1}{N}\sum_i x_i'^2 = \frac{s^2}{s^2} = 1\)).
효과는 앞의 선형 회귀로 확인된다. \(x = (1, 2, 3)\) 을 표준화하면 \(\mu = 2\), \(s \approx 0.8165\), \(x' \approx (-1.2247,\ 0,\ 1.2247)\) 이고 헤세 행렬은 \(\frac{\partial^2 L}{\partial w^2} = 2\), \(\frac{\partial^2 L}{\partial w\,\partial b} = 0\), \(\frac{\partial^2 L}{\partial b^2} = 2\) 가 되어 두 방향의 곡률이 모두 2 다(표준화 전에는 11.09 와 0.24 로 46배 차이). 그러면 \(\eta = 1/2 = 0.5\) 로 한 스텝에 최솟값에 도착한다. 표준화의 효과는 곡률을 고르게 만드는 것이다.
PyTorch 텐서와 모양
텐서(tensor)는 숫자를 여러 축으로 늘어놓은 배열이다. 숫자 하나는 0차원, 벡터는 1차원, 행렬은 2차원, 그림 묶음은 4차원이다. 가장 중요한 정보는 모양(shape), 곧 축마다의 길이다. 딥러닝 코드 오류의 대부분이 모양 불일치라서 튜토리얼 코드는 # (B, T, C) 처럼 모양을 주석으로 적는다.
a 가 (2, 3) 텐서 [[1, 2, 3], [4, 5, 6]], b 가 (3,) 텐서 [10, 20, 30], c 가 (2, 1) 텐서 [[100], [200]], W 가 (4, 3), x 가 (5, 3) 일 때의 결과다(tensors 구간).
| 식 | 결과 |
| | 6.0 (0부터 센다) |
| | [5.0, 7.0, 9.0], 모양 (3,) |
| | [2.0, 5.0], 모양 (2,) |
| | [[11, 22, 33], [14, 25, 36]] |
| | [[101, 102, 103], [204, 205, 206]] |
| | (5, 4) |
| | (15,) |
| | (1, 5, 3) |
-
dim: 어느 축을 따라 합치는지를 정한다.sum(dim=0)은 0번 축을 따라 더해 그 축이 사라지므로 (2, 3) → (3,). - 브로드캐스팅: 모양이 다른 텐서끼리 계산할 때 오른쪽 축부터 맞춰 보고, 길이가 같거나 한쪽이 1(또는 없음)이면 그 축으로 복사해 늘린다. (2, 3) + (3,) 은 (3,) 을 (1, 3) 으로 보고 2행으로 늘린다. (2, 3) + (2, 1) 은 (2, 1) 을 3열로 늘린다. (2, 3) + (2,) 는 오른쪽 축 3 과 2 가 달라 오류다.
- 행렬 곱
@: (5, 3) @ (3, 4) → (5, 4). 안쪽 길이가 같아야 하고 그 축이 사라진다.nn.Linear(3, 4)가 하는 일이 이것에 편향을 더한 것이다. - 관례: 맨 앞 축은 배치다. 벡터 데이터는 (B, D), 그림은 (B, C, H, W) = (배치, 채널, 높이, 너비), 시퀀스는 (B, T, D) 로 쓴다(9장부터).
nn.Module 과 학습 고리 5단계
신경망은 nn.Module 을 상속한 클래스로 만든다. __init__ 에서 층을 만들고 forward 에 순전파를 쓴다. 역전파는 autograd 가 한다.
class MLP(nn.Module):
"""입력 1개 → 은닉 64 → 은닉 64 → 출력 1개. 은닉층 활성 함수는 tanh."""
def __init__(self, in_dim=1, hidden=64, out_dim=1, act=nn.Tanh):
super().__init__()
self.net = nn.Sequential(
nn.Linear(in_dim, hidden), act(),
nn.Linear(hidden, hidden), act(),
nn.Linear(hidden, out_dim),
)
def forward(self, x): # x: (N, in_dim)
return self.net(x) # (N, out_dim)
nn.Linear(n, m) 은 가중치 \(m \times n\) 개와 편향 \(m\) 개를 가진다. 이 MLP(다층 퍼셉트론, multi-layer perceptron)의 매개변수는 \((1 \times 64 + 64) + (64 \times 64 + 64) + (64 \times 1 + 1) = 128 + 4160 + 65 = 4353\) 개다.
데이터는 \([-\pi, \pi]\) 에서 고르게 뽑은 \(x\) 256개에 \(\sin x + 0.05 \cdot \text{잡음}\) 을 붙인 것이고, 검증용으로 같은 방식의 256개를 따로 만든다(mlp_data 구간). 학습 고리는 다음과 같다.
model = MLP().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
loss_fn = nn.MSELoss()
train_curve, val_curve = [], []
for step in range(steps + 1):
# (기록) 지금 모델로 그린 곡선을 몇 번 저장해 둔다
if step in snapshots:
with torch.no_grad():
snapshots[step] = model(xs).cpu().numpy()
if step == steps:
break
optimizer.zero_grad() # ① 지난 스텝의 기울기를 지운다
y_hat = model(x_train) # ② 순전파: 예측
loss = loss_fn(y_hat, y_train) # ③ 손실 계산
loss.backward() # ④ 역전파: 모든 매개변수의 기울기
optimizer.step() # ⑤ 매개변수 갱신
with torch.no_grad(): # 검증 손실: 기울기는 필요 없다
val_loss = loss_fn(model(x_val), y_val)
train_curve.append(loss.item())
val_curve.append(val_loss.item())
if step % 500 == 0 or step == steps - 1:
print(f" step {step:4d} train {loss.item():.5f} val {val_loss.item():.5f}")
-
optimizer.zero_grad(): PyTorch 는.backward()를 부를 때마다 기울기를.grad에 더한다(덮어쓰지 않는다). 지우지 않으면 기울기가 쌓여 엉뚱한 방향으로 간다. - 순전파
model(x_train): 예측을 계산하며 역전파에 필요한 계산 그래프와 중간값을 기록한다. - 손실 계산:
nn.MSELoss()는 앞의 MSE 와 같다. -
loss.backward(): 역전파. 모든 매개변수의.grad가 채워진다. -
optimizer.step(): Adam 갱신식으로 매개변수를 고친다.
검증 손실은 torch.no_grad() 안에서 계산한다. 계산 그래프를 기록하지 않아 빠르고 메모리를 아낀다. .item() 은 숫자 하나짜리 텐서를 파이썬 숫자로 꺼낸다.
step 0 train 0.67709 val 0.33090
step 500 train 0.00282 val 0.00288
step 1000 train 0.00277 val 0.00285
step 1500 train 0.00274 val 0.00284
step 1999 train 0.00273 val 0.00286
매개변수 개수: 4353
손실은 약 0.0027 에서 멈춘다. 데이터에 섞은 잡음의 분산이 \(0.05^2 = 0.0025\) 이므로 이보다 낮아지면 잡음을 외우는 것이다. 훈련 손실과 검증 손실이 함께 움직여 과적합이 없다. 손실 곡선에 잠깐 \(10^{-2}\) 근처까지 튀는 봉우리가 있는데, 학습률 \(10^{-2}\) 이 큰 편이라 Adam 의 스텝이 가끔 지나치게 커지기 때문이다. 활성 함수를 nn.ReLU 로 바꾸면 적합 곡선이 꺾인 선분들을 이어 붙인 모양이 된다.
합성곱 신경망
8장부터 World Model 은 64×64 그림을 본다. 그림을 4096개 숫자로 펴서 선형 층에 넣으면 은닉 128개짜리 층 하나에 매개변수가 \(4096 \times 128 + 128 = 524{,}416\) 개 필요하고, 왼쪽 위의 막대와 오른쪽 아래의 막대를 따로 배워야 한다. 합성곱 신경망(convolutional neural network, CNN)은 두 가지 생각으로 이를 푼다.
- 국소성: 한 번에 작은 영역(예: 3×3 픽셀)만 본다. 선, 모서리 같은 무늬는 작은 영역에 있다.
- 가중치 공유: 같은 작은 필터(커널, kernel)를 그림 전체에 미끄러뜨리며 적용한다. 어디에 있든 같은 무늬는 같은 방식으로 찾는다.
합성곱 계산 예
4×4 입력에 세로 경계를 찾는 3×3 커널을 적용한다. 커널을 입력 위에 겹쳐 놓고 겹친 칸끼리 곱해 모두 더한 값이 출력 한 칸이다.
\(X = \begin{pmatrix} 1 & 2 & 0 & 1 \\ 0 & 1 & 3 & 1 \\ 2 & 1 & 0 & 0 \\ 1 & 0 & 1 & 2 \end{pmatrix},\qquad K = \begin{pmatrix} 1 & 0 & -1 \\ 1 & 0 & -1 \\ 1 & 0 & -1 \end{pmatrix}\)
\(\begin{align} Y_{11} &= (1 + 0 - 0) + (0 + 0 - 3) + (2 + 0 - 0) = 0 \\ Y_{12} &= (2 + 0 - 1) + (1 + 0 - 1) + (1 + 0 - 0) = 2 \\ Y_{21} &= (0 + 0 - 3) + (2 + 0 - 0) + (1 + 0 - 1) = -1 \\ Y_{22} &= (1 + 0 - 1) + (1 + 0 - 0) + (0 + 0 - 2) = -1 \end{align}\)
\(Y = \begin{pmatrix} 0 & 2 \\ -1 & -1 \end{pmatrix}\)
각 괄호는 한 행이고, 왼쪽 열 값에서 오른쪽 열 값을 뺀 꼴이다. 학습에서는 커널의 9개 숫자가 매개변수이고 어떤 무늬를 찾을지는 데이터가 정한다.
채널: 흑백 그림은 채널 1개, 컬러는 3개다. nn.Conv2d(C_in, C_out, K) 는 커널을 \(C_{\text{out}}\) 개 가지며 커널 하나의 크기는 \(C_{\text{in}} \times K \times K\) 다. 매개변수는 \(C_{\text{out}} \cdot C_{\text{in}} \cdot K \cdot K + C_{\text{out}}\) 개이고, 출력 채널 하나하나가 어떤 무늬가 어디에 있는지를 나타내는 지도(feature map)가 된다. PyTorch 의 "합성곱"은 커널을 뒤집지 않는다(엄밀히는 상호 상관). 커널을 학습으로 정하므로 차이가 없다.
출력 크기 공식
스트라이드(stride) \(S\) 는 커널을 한 번에 몇 칸씩 옮길지, 패딩(padding) \(P\) 는 입력 가장자리에 0 을 몇 줄 덧댈지다. 덧댄 길이는 \(W + 2P\) 이고, 커널의 \(n\) 번째 시작 위치 \(nS\) (\(n = 0, 1, 2, \dots\))는 \(nS + K \le W + 2P\) 를 만족해야 하므로 (Convolution arithmetic 참고)
\(W_{\text{out}} = \left\lfloor \frac{W - K + 2P}{S} \right\rfloor + 1\)
전치 합성곱
디코더(8장 VAE, 11장 RSSM)는 작은 잠재 벡터에서 그림을 다시 그려야 하고, 이때 전치 합성곱(transposed convolution, nn.ConvTranspose2d)을 쓴다. 입력의 각 값이 커널에 곱해진 "도장"을 출력에 찍고 겹치는 자리는 더한다. 1차원 예: 입력 \((1, 2)\), 커널 \((1, 2, 1)\), 스트라이드 2.
\(\begin{align} 1 \times (1, 2, 1) &\to (1,\ 2,\ 1,\ 0,\ 0) && \text{0번 위치에 도장} \\ 2 \times (1, 2, 1) &\to (0,\ 0,\ 2,\ 4,\ 2) && \text{2번 위치에 도장} \\ \text{합} &= (1,\ 2,\ 3,\ 4,\ 2) && \text{길이 2 → 5} \end{align}\)
출력 크기는 합성곱 공식을 거꾸로 푼 것이다(나누어떨어질 때).
\(W_{\text{big}} = (W_{\text{small}} - 1)S - 2P + K\)
| 층 | 계산 | 모양 변화(실행 결과) |
| | \(\lfloor 62/2 \rfloor + 1 = 32\) (절반) | (1, 1, 64, 64) → (1, 16, 32, 32) |
| | 64 (크기 유지) | (1, 1, 64, 64) → (1, 8, 64, 64) |
| | 60 | (1, 1, 64, 64) → (1, 8, 60, 60) |
| | \((4 - 1)\cdot 2 - 2 + 4 = 8\) (두 배) | (1, 64, 4, 4) → (1, 32, 8, 8) |
앞의 4×4 예는 \(\lfloor (4-3)/1 \rfloor + 1 = 2\), 1차원 전치 합성곱 예는 \((2-1)\cdot 2 - 0 + 3 = 5\) 다. \(K = 4, S = 2, P = 1\) 전치 합성곱은 크기를 정확히 두 배로 만들어 인코더의 64 → 32 → 16 → 8 → 4 를 거꾸로 되돌린다.
실습: 진자 그림에서 각도 읽기
PixelPendulum 의 64×64 흑백 그림만 보고 막대의 각도를 \((\cos\theta, \sin\theta)\) 로 맞히는 CNN 을 학습시킨다. 8장 VAE 인코더가 하는 일의 축소판이다.
- 데이터(
cnn_data구간): 무작위 행동(\([-2, 2]\) 균등)으로 진자를 돌리며 (그림, \([\cos\theta, \sin\theta]\)) 쌍을 모은다. 정답은env.state()[:2]로 꺼내 라벨로만 쓴다. 훈련 30 에피소드 6000장, 검증 10 에피소드 2000장이다. - 전처리: 0~255 정수를 255 로 나눠 0~1 로 맞추고,
unsqueeze(1)로 채널 축을 만들어 (N, 64, 64) 를 (N, 1, 64, 64) 로 바꾼다. - 모델: 스트라이드 2 합성곱 4개로 64 → 32 → 16 → 8 → 4 로 줄인 뒤 선형 층으로 숫자 2개를 낸다.
class AngleCNN(nn.Module):
"""64×64 흑백 그림 → [cos θ, sin θ]. 8장 VAE 인코더의 축소판이다."""
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 16, 4, stride=2, padding=1), nn.ReLU(), # (B, 16, 32, 32)
nn.Conv2d(16, 32, 4, stride=2, padding=1), nn.ReLU(), # (B, 32, 16, 16)
nn.Conv2d(32, 64, 4, stride=2, padding=1), nn.ReLU(), # (B, 64, 8, 8)
nn.Conv2d(64, 64, 4, stride=2, padding=1), nn.ReLU(), # (B, 64, 4, 4)
)
self.head = nn.Sequential(
nn.Flatten(), # (B, 1024)
nn.Linear(64 * 4 * 4, 128), nn.ReLU(),
nn.Linear(128, 2), # (B, 2)
)
def forward(self, img): # img: (B, 1, 64, 64)
return self.head(self.features(img))
매개변수는 합성곱 \(272 + 8{,}224 + 32{,}832 + 65{,}600\), 선형 층 \(131{,}200 + 258\) 로 모두 238,386 개다. 그림을 곧바로 선형 층(은닉 128)에 넣을 때의 절반이 안 된다. 학습(cnn_train 구간)은 Adam(lr 1e-3), MSE 손실, 매 스텝 무작위 64장 미니배치로 3000 스텝이다.
훈련 그림 6000장, 검증 그림 2000장 (모으는 데 2.9초)
step 0 train 0.51018 val 0.50112
step 500 train 0.00002 val 0.00003
step 1000 train 0.00003 val 0.00004
step 1500 train 0.00001 val 0.00002
step 2000 train 0.00005 val 0.00003
step 2500 train 0.00001 val 0.00001
step 3000 train 0.00003 val 0.00005
수집 + 학습 시간 200.7초 (장치: cpu)
검증 각도 오차: 평균 0.26°, 중앙값 0.21°, 최대 0.66°
산점도 구석의 점 하나는 오류가 아니라 \(+180^\circ\) 와 \(-180^\circ\) 가 같은 자세라서 생긴 표시상의 끝점이다. 각도를 \(\cos\), \(\sin\) 으로 맞히게 한 이유이기도 하다(6장).
이 CNN 은 각속도 \(\dot\theta\) 는 맞힐 수 없다. 그림 한 장에는 얼마나 빨리 도는지가 담겨 있지 않기 때문이다. 이 한계가 5장의 부분 관측 문제이고, 9장과 11장에서 기억(RNN)을 더해 해결한다.
정리
- 신경망은 매개변수 \(\theta\) 를 가진 함수 \(f_\theta\) 이고, 학습은 손실 \(L(\theta)\) 을 줄이는 \(\theta\) 를 찾는 것이다.
- 미분은 기울기이고 연쇄 법칙은 "변화율은 곱해진다"이다. 기울기 벡터 \(\nabla L\) 은 가장 가파른 오르막을 가리킨다.
- 경사 하강 \(\theta \leftarrow \theta - \eta\nabla L\) 은 1차 근사에서 손실을 \(\eta\lVert\nabla L\rVert^2\) 만큼 줄인다. 곡률 \(a\) 인 방향에서는 \(\eta \lt 2/a\) 여야 수렴한다.
- 역전파는 출력 쪽부터 (받은 기울기) × (국소 미분)을 넘기는 연쇄 법칙이다. autograd 가 같은 계산을 한다.
- 소프트맥스 + 교차 엔트로피의 기울기는 \(p - y\) 다. 미니배치 기울기는 편향 없는 추정이고, Adam 은 모멘트 두 개와 편향 보정 \(1/(1-\beta^t)\) 을 쓴다.
- 과적합은 검증 데이터로 알아채고 L2 정규화(가중치 감쇠), 조기 종료, 데이터 늘리기로 막는다. 표준화는 곡률을 고르게 한다.
- 학습 고리 5단계:
zero_grad→ 순전파 → 손실 →backward→step. - CNN 은 국소성과 가중치 공유로 그림을 읽는다. 출력 크기는 \(\lfloor (W - K + 2P)/S \rfloor + 1\), 전치 합성곱은 \((W-1)S - 2P + K\) 다.
확인 문제
- 1. \(f(x) = \log(1 + x^2)\) 의 미분과 \(x = 1\) 에서의 값
- 연쇄 법칙으로 \(f'(x) = \frac{2x}{1 + x^2}\), \(f'(1) = 1\).
- 2. \(L(w) = 2w^2\) 에서 경사 하강이 수렴하는 학습률 범위와 한 스텝에 도착하는 학습률
- \(a = 4\) 이므로 \(0 \lt \eta \lt 2/a = 0.5\). \(\eta = 1/a = 0.25\) 면 한 스텝에 0 에 도착한다.
- 3.
nn.Conv2d(3, 8, kernel_size=3, stride=2, padding=1)에 (1, 3, 32, 32) 를 넣은 출력 모양과 매개변수 개수 - \(\lfloor (32 - 3 + 2)/2 \rfloor + 1 = 16\) 이므로 (1, 8, 16, 16). 매개변수는 \(8 \times 3 \times 3 \times 3 + 8 = 224\) 개.
- 4. 로짓 \(z = (0, 0)\), 정답 클래스 0 일 때 교차 엔트로피 손실과 기울기
- \(p = (0.5, 0.5)\), \(L = \log 2 \approx 0.693\), \(\partial L/\partial z = p - y = (-0.5,\ 0.5)\).
- 5. Adam 에서 \(\beta_1 = 0.9\), 첫 두 스텝의 기울기가 모두 \(g\) 일 때 \(m_2\) 와 \(\hat{m}_2\)
- \(m_1 = 0.1g\), \(m_2 = 0.9 \times 0.1g + 0.1g = 0.19g\), \(\hat{m}_2 = \frac{0.19g}{1 - 0.9^2} = g\).
- 6. 학습 고리에서
optimizer.zero_grad()를 빼먹으면 -
.backward()가 기울기를.grad에 더하므로 \(t\) 번째 스텝의 기울기가 지금까지 모든 기울기의 합이 된다. 스텝이 점점 커지고 방향이 어긋나 학습이 불안정해지거나 발산한다.
See also
- World Models:Tutorial
- World Models
- Deep learning
- PyTorch
- Gradient descent
- Stochastic gradient descent
- Backpropagation
- Gradient Vanishing
- Softmax
- Cross entropy
- CNN
- Convolution
- Convolution arithmetic