신경망과 역전파

3부(딥러닝)를 시작한다. 06장 로지스틱 회귀는 원 모양 경계를 풀려면 제곱 특성을 사람이 직접 만들어야 했다. 신경망은 그 특성을 스스로 배운다. 이 장은 먼저 PyTorch의 배열인 텐서(tensor)와 자동 미분을 최소한으로 익히고, 퍼셉트론 하나로는 못 푸는 문제를 층을 쌓은 다층 퍼셉트론(MLP, Multi-Layer Perceptron)으로 푼다. 그다음 신경망 학습의 핵심 계산인 역전파(backpropagation)를 NumPy로 직접 구현하고, 수치 미분과 PyTorch 자동 미분(autograd)으로 같은 값이 나오는지 확인한다. 학습 루프를 PyTorch 도구(옵티마이저·DataLoader)로 정리하는 일은 11장에서 한다.

10-1. 이 장의 목표와 완료 기준

섹션 제목: “10-1. 이 장의 목표와 완료 기준”
목표 완료 기준
텐서를 다룬다 텐서를 만들고 shape·dtype을 읽으며, NumPy 배열과 오가는 두 방법(복사·메모리 공유)의 차이를 말한다
자동 미분을 쓴다 requires_grad·backward·.grad로 기울기를 구하고, 기울기가 쌓이는 것과 torch.no_grad()가 필요한 이유를 말한다
층이 필요한 이유를 말한다 퍼셉트론이 XOR을 못 푸는 이유와, 은닉층이 입력을 새 특성으로 바꿔 푸는 과정을 보인다
활성화 함수를 고른다 시그모이드·tanh·ReLU의 값과 미분을 계산하고, 활성화 함수가 없으면 층을 쌓아도 선형임을 보인다
역전파를 구현한다 은닉층 1개 MLP의 기울기를 NumPy로 계산해 수치 미분·autograd와 맞춘다
직접 학습한다 경사하강법으로 MLP를 학습해 로지스틱 회귀가 못 푼 원 데이터를 풀고, 초기화가 결과를 바꾸는 경우를 말한다
nn 모듈로 옮긴다 nn.Sequential의 가중치 모양을 읽고, 직접 만든 MLP와 같은 출력을 내게 한다
선택 기준표에 줄을 더한다 신경망(MLP)을 언제 고르고 학습이 안 될 때 무엇부터 보는지 적는다
실습 노트북 10을 끝낸다 실습/문제/ch10_신경망과_역전파.ipynb의 점검 셀이 모두 “통과”를 출력한다

예상 시간: 원고 2시간, 실습 1시간 30분.

10-2. 왜 신경망인가

섹션 제목: “10-2. 왜 신경망인가”

10-3. PyTorch 텐서 최소 입문

섹션 제목: “10-3. PyTorch 텐서 최소 입문”

텐서는 NumPy 배열과 거의 같다

섹션 제목: “텐서는 NumPy 배열과 거의 같다”

텐서는 PyTorch의 다차원 배열이다. shape·축·브로드캐스팅·행렬곱 규칙이 02장 NumPy와 같고, 축을 axis= 대신 dim=으로 적는다.

import numpy as np
import torch
t = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
print(t.shape, t.ndim, t.dtype)
print(t.sum(dim=0), t.mean(dim=1)) # NumPy의 axis= 자리에 dim=
print((t @ t.T).shape, (t + torch.tensor([10.0, 20.0, 30.0])).tolist()) # 행렬곱, 브로드캐스팅
print(torch.zeros(2, 3).dtype, torch.tensor([1, 2]).dtype, np.array([1.0]).dtype)
출력
torch.Size([2, 3]) 2 torch.float32
tensor([5., 7., 9.]) tensor([2., 5.])
torch.Size([2, 2]) [[11.0, 22.0, 33.0], [14.0, 25.0, 36.0]]
torch.float32 torch.int64 float64

NumPy와 오가기

섹션 제목: “NumPy와 오가기”
a = np.array([1.0, 2.0, 3.0])
shared = torch.from_numpy(a) # 메모리 공유, dtype 유지(float64)
copied = torch.tensor(a, dtype=torch.float32) # 복사 + float32로
a[0] = 100.0
print(shared)
print(copied)
back = copied.numpy()
print(type(back).__name__, back.dtype, copied[1].item(), type(copied[1].item()).__name__)
출력
tensor([100., 2., 3.], dtype=torch.float64)
tensor([1., 2., 3.])
ndarray float32 2.0 float

requires_grad와 backward: 자동 미분

섹션 제목: “requires_grad와 backward: 자동 미분”

텐서를 requires_grad=True로 만들면 PyTorch가 그 텐서로 한 계산을 그래프로 기록한다. 결과(스칼라)에서 backward()를 부르면 기록을 거꾸로 따라가며 미분해, 사용자가 직접 requires_grad=True로 만든 텐서(아래 잎 텐서, 이 예에서는 x)의 .grad에 기울기를 더한다. 계산 도중 생긴 중간 텐서의 .grad는 따로 요청(retain_grad())하지 않으면 채워지지 않는다. 이것이 자동 미분(autograd)이다. 04장에서 식으로 유도하고 수치 미분으로 검산하던 일을 대신 해 준다.

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 2 * x # dy/dx = 2x + 2 = 8
print(y.item(), type(y.grad_fn).__name__)
y.backward()
print(x.grad)
y = x ** 2 + 2 * x
y.backward()
print(x.grad) # 비우지 않으면 더해진다: 8 + 8
x.grad.zero_()
print(x.grad)
출력
15.0 AddBackward0
tensor(8.)
tensor(16.)
tensor(0.)

갱신은 기록 밖에서

섹션 제목: “갱신은 기록 밖에서”
w = torch.tensor([1.0, 2.0], requires_grad=True)
try:
w -= 0.1 # 기록 중인 텐서를 제자리에서 수정
except RuntimeError as e:
print("오류:", e)
with torch.no_grad(): # 이 안의 계산은 기록하지 않는다
w -= 0.1
z = w * 2
print(w, z.requires_grad)
try:
w.numpy()
except RuntimeError as e:
print("오류:", e)
print(w.detach().numpy())
출력
오류: a leaf Variable that requires grad is being used in an in-place operation.
tensor([0.9000, 1.9000], requires_grad=True) False
오류: Can't call numpy() on Tensor that requires grad. Use tensor.detach().numpy() instead.
[0.9 1.9]

10-4. 퍼셉트론에서 다층 퍼셉트론으로

섹션 제목: “10-4. 퍼셉트론에서 다층 퍼셉트론으로”

퍼셉트론과 XOR

섹션 제목: “퍼셉트론과 XOR”

퍼셉트론(perceptron, 1958년)은 선형 점수 z=w⋅x+bz = w \cdot x + b가 0 이상이면 1, 아니면 0을 내는 모델이다. 06장 로지스틱 회귀의 시그모이드 자리에 계단 함수(step function)가 있는 셈이다. 틀린 표본을 만날 때마다 w←w+(y−y^) xw \leftarrow w + (y - \hat{y})\,x로 고치는 단순한 규칙으로 학습한다.

def step(z):
return (np.asarray(z) >= 0).astype(int)
def perceptron(X, y, epochs=8):
w, b, errors = np.zeros(X.shape[1]), 0.0, []
for _ in range(epochs):
n_err = 0
for xi, yi in zip(X, y):
diff = yi - step(xi @ w + b) # 맞으면 0, 틀리면 +1 또는 -1
w, b = w + diff * xi, b + diff
n_err += int(diff != 0)
errors.append(n_err)
return w, b, errors
X4 = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
for name, y4 in [("AND", [0, 0, 0, 1]), ("OR", [0, 1, 1, 1]), ("XOR", [0, 1, 1, 0])]:
w, b, errors = perceptron(X4, np.array(y4))
print(f"{name}: 에폭별 틀린 수 {errors}, 최종 예측 {step(X4 @ w + b)}")
출력
AND: 에폭별 틀린 수 [2, 3, 3, 2, 1, 0, 0, 0], 최종 예측 [0 0 0 1]
OR: 에폭별 틀린 수 [2, 2, 1, 0, 0, 0, 0, 0], 최종 예측 [0 1 1 1]
XOR: 에폭별 틀린 수 [3, 3, 4, 4, 4, 4, 4, 4], 최종 예측 [1 1 0 0]

층을 하나 더하면 풀린다

섹션 제목: “층을 하나 더하면 풀린다”

퍼셉트론 두 개(OR, AND)의 출력을 새 특성으로 삼고, 그 위에 퍼셉트론 하나를 더 얹는다. 가중치는 손으로 정한다.

W1 = np.array([[1.0, 1.0], [1.0, 1.0]]) # 열 하나가 은닉 유닛 하나
b1 = np.array([-0.5, -1.5]) # 유닛 1: OR, 유닛 2: AND
w2, b2 = np.array([1.0, -1.0]), -0.5 # OR이고 AND가 아니면 1
H4 = step(X4 @ W1 + b1)
print(H4.tolist(), step(H4 @ w2 + b2))
출력
[[0, 0], [1, 0], [1, 0], [1, 1]] [0 1 1 0]

10-5. 활성화 함수

섹션 제목: “10-5. 활성화 함수”

활성화 함수가 없으면 층을 쌓아도 선형이다

섹션 제목: “활성화 함수가 없으면 층을 쌓아도 선형이다”

선형 층 두 개를 이어 붙이면 (XA1)A2=X(A1A2)(XA_1)A_2 = X(A_1A_2)라서 선형 층 하나와 같다. 층을 몇 개 쌓아도 직선 경계밖에 못 만든다. 그래서 층 사이에 비선형 함수를 넣는다.

rng = np.random.default_rng(0)
A1, A2, Xr = rng.normal(size=(2, 8)), rng.normal(size=(8, 1)), rng.normal(size=(5, 2))
print(np.allclose((Xr @ A1) @ A2, Xr @ (A1 @ A2)), (A1 @ A2).shape)
출력
True (2, 1)

절편을 더해도 마찬가지다(선형식에 선형식을 넣으면 선형식). 활성화 함수는 층마다 이 “합쳐짐”을 끊는다.

세 가지 활성화 함수

섹션 제목: “세 가지 활성화 함수”
이름 식 미분 출력 범위
시그모이드(sigmoid) σ(z)=11+e−z\sigma(z) = \dfrac{1}{1 + e^{-z}} σ(z) (1−σ(z))\sigma(z)\,(1 - \sigma(z)), 최대 0.25 0 ~ 1
쌍곡탄젠트(tanh) tanh⁡z=ez−e−zez+e−z\tanh z = \dfrac{e^{z} - e^{-z}}{e^{z} + e^{-z}} 1−tanh⁡2z1 - \tanh^2 z, 최대 1 −1 ~ 1
정류 선형 함수(ReLU, Rectified Linear Unit) max⁡(0,z)\max(0, z) z>0z > 0이면 1, z<0z < 0이면 0 0 ~ ∞

식으로 쓴 미분을 autograd와 맞춰 본다.

zn = np.linspace(-4, 4, 5)
s = 1 / (1 + np.exp(-zn))
by_hand = {"sigmoid": s * (1 - s), "tanh": 1 - np.tanh(zn) ** 2, "relu": (zn > 0).astype(float)}
z = torch.tensor(zn, requires_grad=True) # float64 그대로
for name, f in [("sigmoid", torch.sigmoid), ("tanh", torch.tanh), ("relu", torch.relu)]:
z.grad = None # 앞 함수의 기울기를 지운다
out = f(z)
out.sum().backward() # 원소마다 따로 미분한 값이 된다
same = np.allclose(z.grad.numpy(), by_hand[name])
print(f"{name:7s} 값 {out.detach().numpy().round(3)} 미분 {z.grad.numpy().round(3)} 식과 같음 {same}")
출력
sigmoid 값 [0.018 0.119 0.5 0.881 0.982] 미분 [0.018 0.105 0.25 0.105 0.018] 식과 같음 True
tanh 값 [-0.999 -0.964 0. 0.964 0.999] 미분 [0.001 0.071 1. 0.071 0.001] 식과 같음 True
relu 값 [0. 0. 0. 2. 4.] 미분 [0. 0. 0. 1. 1.] 식과 같음 True
시그모이드·tanh·ReLU의 값과 미분. 시그모이드 미분은 최대 0.25, tanh와 ReLU는 최대 1이다시그모이드·tanh·ReLU의 값과 미분. 시그모이드 미분은 최대 0.25, tanh와 ReLU는 최대 1이다

그림 설명. 두 그림 모두 가로축은 zz(−5~5)다. 왼쪽은 함숫값이다. 시그모이드(파랑)는 0에서 1로 완만하게 오르고, tanh(초록)는 −1에서 1로 더 가파르게 오르며, ReLU(빨강)는 0 이하에서 0, 그 위에서 기울기 1인 직선이다. 오른쪽은 미분이다. 시그모이드 미분은 z=0z = 0에서 가장 큰 0.25이고(점선 표시) 양쪽으로 0에 가까워진다. tanh 미분은 z=0z = 0에서 1로 솟았다가 양쪽에서 0에 가까워진다. ReLU 미분은 0 이하에서 0, 0 위에서 1인 계단이다.

10-6. 순전파: MLP가 예측을 만드는 과정

섹션 제목: “10-6. 순전파: MLP가 예측을 만드는 과정”

06장에서 로지스틱 회귀가 정확도 0.433에 그친 원 데이터를 쓴다. 특성은 원래 좌표 2개뿐이고, 제곱 특성은 만들지 않는다. 두 좌표의 크기가 이미 비슷하므로(대략 −1.2 ~ 1.2) 표준화는 생략한다. 표 데이터처럼 단위가 다르면 04장처럼 먼저 표준화한다.

은닉 유닛 h개, ReLU, 출력 시그모이드인 MLP의 계산 순서는 다음과 같다. 입력에서 손실까지 앞으로 계산하는 것을 순전파(forward pass)라 한다.

단계 식 모양 (N개 표본, 특성 d, 은닉 h)
은닉 점수 A=XW1+b1A = XW_1 + b_1 (N, d) @ (d, h) + (h,) → (N, h)
은닉 출력 H=ReLU(A)H = \mathrm{ReLU}(A) (N, h)
출력 점수 z=Hw2+b2z = Hw_2 + b_2 (N, h) @ (h,) + 스칼라 → (N,)
확률 p=σ(z)p = \sigma(z) (N,)
손실 LL = 평균 로그 손실(y,p)(y, p) 스칼라
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
Xc, yc = make_circles(n_samples=300, factor=0.5, noise=0.1, random_state=0)
c_tr, c_va, yc_tr, yc_va = train_test_split(Xc, yc, test_size=0.3, stratify=yc, random_state=0)
def sigmoid(z):
return 1 / (1 + np.exp(-z))
def bce(y, p):
return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
def init_params(d, h, seed):
rng = np.random.default_rng(seed)
return {"W1": rng.normal(0, 1 / np.sqrt(d), (d, h)), "b1": np.zeros(h),
"w2": rng.normal(0, 1 / np.sqrt(h), h), "b2": 0.0}
def forward(X, P):
A = X @ P["W1"] + P["b1"] # (N, h) 은닉 점수
H = np.maximum(A, 0) # (N, h) ReLU
z = H @ P["w2"] + P["b2"] # (N,) 06장 로지스틱 회귀의 z
return {"A": A, "H": H, "z": z, "p": sigmoid(z)}
P = init_params(2, 8, seed=0)
cache = forward(c_tr, P)
print({k: v.shape for k, v in cache.items()})
print("매개변수 수", sum(np.size(v) for v in P.values()), "/ 학습 전 손실", round(bce(yc_tr, cache["p"]), 4))
출력
{'A': (210, 8), 'H': (210, 8), 'z': (210,), 'p': (210,)}
매개변수 수 33 / 학습 전 손실 0.6846

10-7. 역전파를 NumPy로

섹션 제목: “10-7. 역전파를 NumPy로”

계산 그래프와 연쇄 법칙

섹션 제목: “계산 그래프와 연쇄 법칙”

역전파는 연쇄 법칙(chain rule)을 계산 순서의 반대로 적용하는 방법이다. 작은 식 L=(wx+b−y)2L = (wx + b - y)^2으로 먼저 해 본다. 계산을 한 단계씩 나누면 u=wx+bu = wx + b, e=u−ye = u - y, L=e2L = e^2이다.

w, x, b, y = 2.0, 3.0, 1.0, 5.0
u = w * x + b # 순전파: 값을 계산해 둔다
e = u - y
L = e ** 2
dL_de = 2 * e # 역전파: 끝에서부터 국소 미분을 곱한다
dL_du = dL_de * 1
dL_dw, dL_db = dL_du * x, dL_du * 1
print(L, dL_dw, dL_db)
wt, bt = torch.tensor(w, requires_grad=True), torch.tensor(b, requires_grad=True)
Lt = (wt * x + bt - y) ** 2
Lt.backward()
print(Lt.item(), wt.grad.item(), bt.grad.item())
출력
4.0 12.0 4.0
4.0 12.0 4.0

MLP의 역전파

섹션 제목: “MLP의 역전파”

10-6절 표를 아래에서 위로 거슬러 올라간다. 손실이 평균이라 1/N1/N이 붙는다.

단계 (순전파) 역전파로 구하는 것
p=σ(z)p = \sigma(z), LL = 평균 로그 손실 dz=∂L/∂z=(p−y)/Ndz = \partial L / \partial z = (p - y) / N (06장, 시그모이드 미분이 약분됨)
z=Hw2+b2z = Hw_2 + b_2 ∂L/∂w2=H⊤dz\partial L / \partial w_2 = H^\top dz, ∂L/∂b2=∑dz\partial L / \partial b_2 = \sum dz, dH=∂L/∂H=dz w2⊤dH = \partial L / \partial H = dz\, w_2^\top(외적, dHij=dzi w2,jdH_{ij} = dz_i\, w_{2,j})
H=ReLU(A)H = \mathrm{ReLU}(A) dA=dH⊙[A>0]dA = dH \odot [A > 0] (⊙\odot는 원소별 곱)
A=XW1+b1A = XW_1 + b_1 ∂L/∂W1=X⊤dA\partial L / \partial W_1 = X^\top dA, ∂L/∂b1\partial L / \partial b_1 = dAdA를 표본 축으로 합
def backward(X, y, P, c):
N = len(y)
dz = (c["p"] - y) / N # (N,)
g = {"w2": c["H"].T @ dz, "b2": dz.sum()}
dH = np.outer(dz, P["w2"]) # (N, h) 외적: dH[i, j] = dz[i] * w2[j]
dA = dH * (c["A"] > 0) # ReLU: 켜진 유닛으로만 기울기가 지나간다
g["W1"] = X.T @ dA # (d, h)
g["b1"] = dA.sum(axis=0) # (h,)
return g
grads = backward(c_tr, yc_tr, P, cache)
print({k: np.shape(v) for k, v in grads.items()})
출력
{'w2': (8,), 'b2': (), 'W1': (2, 8), 'b1': (8,)}

수치 미분으로 검산

섹션 제목: “수치 미분으로 검산”

04장처럼 매개변수 하나를 ±h\pm h만큼 움직여 손실 차이로 기울기를 잰다. 매개변수 33개마다 손실을 두 번씩 계산한다.

def numerical_grad(X, y, P, name, h=1e-6):
out = np.zeros(np.shape(P[name]))
for idx in np.ndindex(out.shape): # b2처럼 0차원이면 idx = ()
Q = {k: np.array(v, dtype=float) for k, v in P.items()} # 복사본에서만 움직인다
Q[name][idx] += h
up = bce(y, forward(X, Q)["p"])
Q[name][idx] -= 2 * h
down = bce(y, forward(X, Q)["p"])
out[idx] = (up - down) / (2 * h)
return out
for name in P:
print(name, np.allclose(grads[name], numerical_grad(c_tr, yc_tr, P, name), rtol=1e-5, atol=1e-8))
출력
W1 True
b1 True
w2 True
b2 True

역전파 코드가 맞다. 새 층이나 손실을 직접 구현하면 이렇게 작은 데이터에서 수치 미분과 비교한다. ReLU처럼 꺾인 점이 있는 함수는 AA가 정확히 0 근처인 표본에서 수치 미분이 어긋날 수 있다. 그런 표본이 있으면 hh를 바꿔 다시 본다.

10-8. 직접 학습하기

섹션 제목: “10-8. 직접 학습하기”

경사하강법 루프

섹션 제목: “경사하강법 루프”

04·06장과 같은 루프다. 순전파 → 손실 기록 → 역전파 → 모든 매개변수 갱신을 되풀이한다. 전체 훈련 데이터를 한 번에 쓰므로 스텝 하나가 에폭 하나다(미니배치는 11장).

from sklearn.linear_model import LogisticRegression
def train(X, y, P, lr=0.5, steps=2000):
P = {k: np.array(v, dtype=float) for k, v in P.items()} # 원본은 두고 복사본을 학습
history = []
for _ in range(steps):
c = forward(X, P)
history.append(bce(y, c["p"]))
g = backward(X, y, P, c)
for k in P:
P[k] = P[k] - lr * g[k]
return P, history
def accuracy(P, X, y):
return np.mean((forward(X, P)["p"] >= 0.5) == y)
print("로지스틱 회귀(06장):", round(LogisticRegression().fit(c_tr, yc_tr).score(c_va, yc_va), 3))
for h in [2, 8]:
for seed in [0, 1, 2]:
P_h, hist = train(c_tr, yc_tr, init_params(2, h, seed))
print(f"은닉 {h}, seed {seed}: 훈련 손실 {hist[0]:.3f} → {hist[-1]:.3f}, 검증 정확도 {accuracy(P_h, c_va, yc_va):.3f}")
출력
로지스틱 회귀(06장): 0.433
은닉 2, seed 0: 훈련 손실 0.689 → 0.510, 검증 정확도 0.689
은닉 2, seed 1: 훈련 손실 0.719 → 0.523, 검증 정확도 0.689
은닉 2, seed 2: 훈련 손실 0.845 → 0.601, 검증 정확도 0.556
은닉 8, seed 0: 훈련 손실 0.685 → 0.023, 검증 정확도 0.989
은닉 8, seed 1: 훈련 손실 0.702 → 0.019, 검증 정확도 0.989
은닉 8, seed 2: 훈련 손실 0.705 → 0.018, 검증 정확도 0.989
로지스틱 회귀는 직선, 은닉 2개 MLP는 직선 두 개 사이의 띠, 은닉 8개 MLP는 안쪽 원을 둘러싸는 경계를 만든다로지스틱 회귀는 직선, 은닉 2개 MLP는 직선 두 개 사이의 띠, 은닉 8개 MLP는 안쪽 원을 둘러싸는 경계를 만든다

그림 설명. 앞 세 칸은 원 데이터의 훈련 210개(회색 점이 바깥 고리 0, 빨간 삼각형이 안쪽 원 1)와 각 모델이 1로 예측하는 붉은 영역이다. 가로·세로축은 −1.5~1.5다. 로지스틱 회귀는 비스듬한 직선 하나로 평면을 반으로 가른다. 은닉 2개 MLP는 거의 평행한 직선 두 개 사이의 가로 띠를 1로 예측해, 띠 밖 위아래의 바깥 고리 점만 0으로 맞힌다. 은닉 8개 MLP는 안쪽 원을 둘러싸는 여러각형 모양의 경계를 만든다. 넷째 칸은 시드 0의 학습 곡선이다. 가로축 스텝(0~2000), 세로축 훈련 로그 손실(0~0.8)이고 점선이 log⁡2\log 2다. 은닉 2개(초록)는 약 0.69에서 300스텝 무렵 약 0.51로 내려와 평평해지고, 은닉 8개(파랑)는 계속 내려가 2000스텝에서 약 0.02가 된다.

0으로 시작하면 안 되는 이유

섹션 제목: “0으로 시작하면 안 되는 이유”
zeros = {"W1": np.zeros((2, 8)), "b1": np.zeros(8), "w2": np.zeros(8), "b2": 0.0}
same = {"W1": np.full((2, 8), 0.5), "b1": np.zeros(8), "w2": np.full(8, 0.5), "b2": 0.0}
for name, P_init in [("모두 0", zeros), ("모두 같은 값 0.5", same)]:
P_s, hist = train(c_tr, yc_tr, P_init)
cols_same = np.allclose(P_s["W1"], P_s["W1"][:, :1]) # 은닉 유닛 8개의 가중치가 모두 같은가
print(f"{name}: 훈련 손실 {hist[-1]:.3f}, 검증 정확도 {accuracy(P_s, c_va, yc_va):.3f}, 유닛 가중치 모두 같음 {cols_same}")
출력
모두 0: 훈련 손실 0.693, 검증 정확도 0.500, 유닛 가중치 모두 같음 True
모두 같은 값 0.5: 훈련 손실 0.603, 검증 정확도 0.689, 유닛 가중치 모두 같음 True

10-9. autograd로 확인하고 학습하기

섹션 제목: “10-9. autograd로 확인하고 학습하기”

같은 기울기가 나오는가

섹션 제목: “같은 기울기가 나오는가”

10-7절의 NumPy 역전파를 PyTorch 자동 미분과 맞춘다. NumPy와 정밀도를 맞추려고 float64로 계산한다.

T = {k: torch.tensor(v, dtype=torch.float64, requires_grad=True) for k, v in P.items()}
Xt, yt = torch.tensor(c_tr), torch.tensor(yc_tr, dtype=torch.float64)
def forward_t(X, T):
H = torch.relu(X @ T["W1"] + T["b1"])
return torch.sigmoid(H @ T["w2"] + T["b2"])
def bce_t(y, p):
return -torch.mean(y * torch.log(p) + (1 - y) * torch.log(1 - p))
loss = bce_t(yt, forward_t(Xt, T))
loss.backward()
print(round(loss.item(), 4), {k: np.allclose(T[k].grad.numpy(), grads[k]) for k in P})
출력
0.6846 {'W1': True, 'b1': True, 'w2': True, 'b2': True}

backward() 한 줄이 10-7절 backward 함수 전체와 같은 값을 냈다. 우리는 순전파만 쓰고, 역전파는 PyTorch가 기록한 그래프에서 자동으로 만든다. 층을 바꾸거나 더해도 역전파 코드를 다시 쓸 필요가 없다. 그래서 실제 딥러닝은 autograd로 하고, 손으로 쓴 역전파는 원리를 이해하고 검산하는 데 쓴다.

여기서 직접 쓴 bce_t는 원리 확인용이다. 시그모이드 출력이 부동소수점에서 정확히 0이나 1이 되면 log⁡0\log 0 때문에 inf·nan이 생긴다(06장 6-5절). 실무에서는 로짓을 받아 안정하게 계산하는 nn.BCEWithLogitsLoss를 쓴다(11장).

autograd로 학습 루프

섹션 제목: “autograd로 학습 루프”
def train_torch(X, y, P, lr=0.5, steps=2000, zero_grad=True):
T = {k: torch.tensor(v, dtype=torch.float64, requires_grad=True) for k, v in P.items()}
for _ in range(steps):
loss = bce_t(y, forward_t(X, T))
loss.backward() # 모든 T[k].grad 계산(더해짐)
with torch.no_grad():
for t in T.values():
t -= lr * t.grad # 갱신은 기록하지 않는다
if zero_grad:
t.grad.zero_() # 다음 스텝 전에 비운다
return T, loss.item()
P0 = init_params(2, 8, seed=0)
P_np, hist_np = train(c_tr, yc_tr, P0)
T_ok, loss_ok = train_torch(Xt, yt, P0)
print("NumPy와 같은 매개변수:", all(np.allclose(T_ok[k].detach().numpy(), P_np[k]) for k in P0), round(loss_ok, 4))
T_bad, loss_bad = train_torch(Xt, yt, P0, zero_grad=False)
print("기울기를 안 비우면 마지막 손실:", round(loss_bad, 4))
출력
NumPy와 같은 매개변수: True 0.0233
기울기를 안 비우면 마지막 손실: nan

10-10. nn 모듈로 같은 모델 만들기

섹션 제목: “10-10. nn 모듈로 같은 모델 만들기”

PyTorch는 층을 torch.nn에 미리 만들어 두었다. nn.Linear(입력 수, 출력 수)는 가중치와 절편을 가진 선형 층이고, nn.Sequential은 층을 순서대로 잇는다.

from torch import nn
torch.manual_seed(0)
model = nn.Sequential(nn.Linear(2, 8), nn.ReLU(), nn.Linear(8, 1))
for name, prm in model.named_parameters():
print(name, tuple(prm.shape), prm.dtype, prm.requires_grad)
print("매개변수 수", sum(prm.numel() for prm in model.parameters()))
출력
0.weight (8, 2) torch.float32 True
0.bias (8,) torch.float32 True
2.weight (1, 8) torch.float32 True
2.bias (1,) torch.float32 True
매개변수 수 33

10-8절에서 NumPy로 학습한 매개변수를 넣으면 같은 확률이 나와야 한다.

with torch.no_grad():
model[0].weight.copy_(torch.tensor(P_np["W1"].T)) # (2, 8) → (8, 2)
model[0].bias.copy_(torch.tensor(P_np["b1"]))
model[2].weight.copy_(torch.tensor(P_np["w2"]).reshape(1, 8))
model[2].bias.fill_(float(P_np["b2"]))
Xv = torch.tensor(c_va, dtype=torch.float32)
p_nn = torch.sigmoid(model(Xv))
print(p_nn.shape, np.allclose(p_nn.squeeze(1).numpy(), forward(c_va, P_np)["p"], atol=1e-5))
try:
model(torch.from_numpy(c_va)) # float64를 float32 모델에
except RuntimeError as e:
print("오류:", e)
print("(N, 1) − (N,) 모양:", tuple((p_nn - torch.tensor(yc_va)).shape))
출력
torch.Size([90, 1]) True
오류: mat1 and mat2 must have the same dtype, but got Double and Float
(N, 1) − (N,) 모양: (90, 90)

10-11. 깊어지면 생기는 일: 기울기 소실

섹션 제목: “10-11. 깊어지면 생기는 일: 기울기 소실”

수학 상자: 연쇄 법칙과 행렬 미분

섹션 제목: “수학 상자: 연쇄 법칙과 행렬 미분”

연쇄 법칙. y=f(u)y = f(u), u=g(x)u = g(x)이면 dydx=dydu⋅dudx\dfrac{dy}{dx} = \dfrac{dy}{du} \cdot \dfrac{du}{dx}이다. 단계가 여러 개면 국소 미분을 모두 곱하고, 한 변수에서 여러 길로 갈라지면 길마다의 곱을 더한다. 역전파는 이 곱을 출력 쪽부터 계산해 앞 층으로 넘기는 순서일 뿐이다.

행렬 미분. 스칼라 손실 LL과 선형 층 Z=XWZ = XW에서 ∂L/∂W=X⊤(∂L/∂Z)\partial L / \partial W = X^\top (\partial L / \partial Z), ∂L/∂X=(∂L/∂Z) W⊤\partial L / \partial X = (\partial L / \partial Z)\, W^\top이다. 기울기 모양은 늘 그 변수의 모양과 같다. 원소별 함수 H=f(A)H = f(A)는 ∂L/∂A=∂L/∂H⊙f′(A)\partial L / \partial A = \partial L / \partial H \odot f'(A)다.

기울기 소실(vanishing gradient). 앞쪽 층의 기울기는 뒤쪽 층들의 국소 미분을 모두 곱한 것이다. 시그모이드의 미분은 최대 0.25라서, 층마다 0.25 이하가 곱해지면 10층만 지나도 0.2510≈10−60.25^{10} \approx 10^{-6} 수준까지 작아질 수 있다(가중치 크기도 함께 곱해진다). 그러면 앞쪽 층은 거의 학습되지 않는다. 같은 구조의 10층 신경망에서 층별 가중치 기울기의 크기(노름)를 비교한다.

def layer_grad_norms(act, init):
torch.manual_seed(0)
layers = []
for _ in range(10):
lin = nn.Linear(32, 32)
init(lin.weight)
nn.init.zeros_(lin.bias)
layers += [lin, act()]
net = nn.Sequential(*layers)
net(torch.randn(256, 32)).pow(2).mean().backward()
return [m.weight.grad.norm().item() for m in net if isinstance(m, nn.Linear)]
for name, act, init in [("sigmoid", nn.Sigmoid, nn.init.xavier_normal_),
("tanh", nn.Tanh, nn.init.xavier_normal_),
("relu", nn.ReLU, lambda w: nn.init.kaiming_normal_(w, nonlinearity="relu"))]:
g = layer_grad_norms(act, init)
print(f"{name:7s} 1층 {g[0]:.1e}, 5층 {g[4]:.1e}, 10층 {g[-1]:.1e}, 1층/10층 {g[0] / g[-1]:.1e}")
출력
sigmoid 1층 3.6e-08, 5층 8.3e-05, 10층 1.2e-01, 1층/10층 2.9e-07
tanh 1층 2.5e-02, 5층 4.4e-02, 10층 5.4e-02, 1층/10층 4.6e-01
relu 1층 5.6e-01, 5층 2.5e+00, 10층 2.0e+00, 1층/10층 2.8e-01

10-12. 신경망을 언제 쓰나

섹션 제목: “10-12. 신경망을 언제 쓰나”
상황 신경망(MLP) 다른 선택
표 데이터, 특성마다 뜻이 있다 비교 후보로만. 입력 스케일을 맞추고(표준화 등), 시드·은닉 수에 따라 흔들린다 트리 앙상블이 먼저(07·09장)
이미지·소리·문장 원본 신경망이 기본. 구조는 데이터에 맞춘다 CNN(12장), 트랜스포머(14장), 사전학습 모델(15장)
경계가 휘었고 특성이 몇 개뿐 작은 MLP로 풀린다 제곱·곱 특성 + 로지스틱(06장), 트리(07장)
데이터가 수백 건, 이유를 설명해야 한다 맞지 않는다 로지스틱 회귀(06장), 트리 하나(07장)
사전학습 모델이 뽑은 특성 위에 분류기를 얹는다 작은 MLP 헤드 또는 로지스틱 헤드 15장

sklearn에도 MLPClassifier가 있어 작은 표 데이터 실험에는 쓸 수 있다. 이 자료는 이미지·문장으로 이어지도록 PyTorch로 간다.

10-13. 선택 기준표에 추가

섹션 제목: “10-13. 선택 기준표에 추가”
상황 고를 것 이유 장
경계가 휘었는데 어떤 특성을 만들지 모른다 은닉층 1~2개 MLP(ReLU, 출력은 문제에 맞게), 입력 표준화. 표 데이터면 트리 앙상블과 교차검증으로 비교 은닉층이 특성을 배운다. 표 데이터에서는 트리가 대체로 먼저다 10
은닉층 활성화를 고른다 ReLU 기본, 출력층은 시그모이드(이진)·소프트맥스(다중)·없음(회귀) 시그모이드 은닉층은 깊어지면 기울기가 사라진다 10
기울기·층을 직접 구현했다 작은 데이터에서 수치 미분·autograd와 비교 모양이 맞아도 식이 틀릴 수 있다 10
신경망 손실이 안 줄거나 이상하다 기울기 비우기 → 초기화(0·같은 값 금지) → 출력·정답 모양 (N, 1)/(N,) → dtype float32 → 학습률·스케일 순으로 확인 대부분 오류 없이 조용히 틀린다 10
신경망 결과를 비교한다 시드 고정, 중요한 비교는 시드 여러 개로 손실이 볼록이 아니라 시작점에 따라 결과가 달라진다 10

확인 문제

섹션 제목: “확인 문제”

10-14. 실습과 문제

섹션 제목: “10-14. 실습과 문제”

실습/문제/ch10_신경망과_역전파.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안에 끝난다. 다 푼 뒤 해설 노트북과 비교한다. 실습은 원고와 다른 반달 모양 데이터(make_moons)로 같은 과정을 밟는다.

번호 유형 내용
1 개념 텐서·autograd 참/거짓
2 코드 NumPy 데이터를 모델 입력 텐서로 바꾸기
3 코드 활성화 함수의 미분을 식으로 쓰고 autograd와 비교
4 코드 tanh 은닉층 MLP의 순전파
5 코드 같은 MLP의 역전파(수치 미분·autograd로 점검)
6 코드 경사하강법 학습 루프
7 코드 직접 학습한 매개변수를 nn.Sequential로 옮겨 확률 예측
8 개념 신경망·역전파 참/거짓
9 사례 손실이 0.693에서 멈춘 신경망 진단
10 사례 상황별 모델·설정 고르기

10-15. 공식 문서와 참고 자료

섹션 제목: “10-15. 공식 문서와 참고 자료”