PyTorch 학습 루프

10장은 전체 훈련 데이터로 기울기를 한 번 구하고, 매개변수를 하나씩 손으로 갱신했다. 데이터가 수만 건, 매개변수가 수백만 개가 되면 이 방식은 느리고 코드가 길어진다. 이 장에서는 실제 딥러닝 코드에서 쓰는 틀을 익힌다. 데이터를 작은 묶음(미니배치)으로 나눠 주는 Dataset·DataLoader, 갱신을 맡는 옵티마이저(SGD·Adam), 훈련·검증 손실을 기록해 읽는 학습 곡선, 학습한 모델을 저장했다가 이어서 쓰는 체크포인트다. 12장 CNN부터 모든 장이 이 루프를 그대로 쓴다.

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

섹션 제목: “11-1. 이 장의 목표와 완료 기준”
목표 완료 기준
배치·에폭·스텝을 계산한다 데이터 수와 배치 크기로 에폭당 스텝 수와 마지막 배치 크기를 구하고, 미니배치 기울기가 전체 기울기의 추정값임을 말한다
데이터를 묶어 준다 Dataset(__len__·__getitem__)을 쓰고, DataLoader의 batch_size·shuffle·generator·drop_last가 하는 일을 말한다
기본 학습 루프를 쓴다 zero_grad → 순전파·손실 → backward → step 네 줄과 model.train()/model.eval()·torch.no_grad() 평가 함수를 쓴다
옵티마이저를 고른다 SGD·모멘텀·Adam의 갱신 규칙을 말하고, 같은 데이터에서 학습 곡선을 비교한다
학습 곡선을 읽는다 훈련·검증 손실 곡선에서 과소적합·과적합·학습률 과다를 구별하고, 검증 손실이 가장 낮은 에폭의 모델을 남긴다
체크포인트를 쓴다 모델·옵티마이저 state_dict를 저장·재로딩해 같은 예측을 내고, 이어서 학습해도 끊지 않은 학습과 같게 만든다
학습 보조 기법을 안다 초기화·배치 정규화·드롭아웃·학습률 스케줄이 무엇을 하는지, 훈련과 평가에서 동작이 다른 층이 무엇인지 말한다
선택 기준표에 줄을 더한다 옵티마이저·배치 크기·멈출 시점을 고르는 기준을 적는다
실습 노트북 11을 끝낸다 실습/문제/ch11_PyTorch_학습_루프.ipynb의 점검 셀이 모두 “통과”를 출력한다

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

11-2. 왜 학습 루프를 정리하나

섹션 제목: “11-2. 왜 학습 루프를 정리하나”

11-3. 배치·에폭·스텝

섹션 제목: “11-3. 배치·에폭·스텝”

세 단어의 관계

섹션 제목: “세 단어의 관계”
import math
import numpy as np
import torch
from torch import nn
N = 700
for B in [700, 32, 1]:
steps = math.ceil(N / B)
print(f"배치 {B:3d}: 에폭당 스텝 {steps:3d}, 마지막 배치 {N - (steps - 1) * B:3d}개, 30에폭 갱신 {30 * steps}번")
출력
배치 700: 에폭당 스텝 1, 마지막 배치 700개, 30에폭 갱신 30번
배치 32: 에폭당 스텝 22, 마지막 배치 28개, 30에폭 갱신 660번
배치 1: 에폭당 스텝 700, 마지막 배치 1개, 30에폭 갱신 21000번

미니배치 기울기는 전체 기울기의 추정값이다

섹션 제목: “미니배치 기울기는 전체 기울기의 추정값이다”

이 장의 데이터는 반달 두 개가 맞물린 make_moons(1000개, 잡음 0.3)다. 10장 실습보다 잡음이 커서 두 범주가 겹친다. 훈련 700개, 검증 300개로 나누고 05장 규칙대로 훈련 데이터로만 표준화한다.

from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = make_moons(n_samples=1000, noise=0.3, random_state=0)
X_tr, X_va, y_tr, y_va = train_test_split(X, y, test_size=0.3, stratify=y, random_state=0)
scaler = StandardScaler().fit(X_tr) # 훈련 데이터로만 맞춘다
Xt = torch.tensor(scaler.transform(X_tr), dtype=torch.float32)
Xv = torch.tensor(scaler.transform(X_va), dtype=torch.float32)
yt = torch.tensor(y_tr, dtype=torch.float32).reshape(-1, 1) # 모델 출력 (N, 1)과 같은 모양
yv = torch.tensor(y_va, dtype=torch.float32).reshape(-1, 1)
print(Xt.shape, yt.shape, Xv.shape, round(yt.mean().item(), 3))
def make_model(seed=0):
torch.manual_seed(seed) # 같은 seed면 같은 초기 가중치
return nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 16), nn.ReLU(), nn.Linear(16, 1))
loss_fn = nn.BCEWithLogitsLoss() # 시그모이드 + 로그 손실(11-5절)
출력
torch.Size([700, 2]) torch.Size([700, 1]) torch.Size([300, 2]) 0.5

make_model은 은닉층 2개(각 16유닛, ReLU)인 MLP를 만든다. 출력은 시그모이드 전 점수(로짓)다.

학습 전 모델에서 첫 층 가중치의 기울기를 전체 700개로 한 번 구하고, 무작위로 뽑은 배치 200개로도 구해 비교한다.

def first_layer_grad(model, xb, yb):
model.zero_grad()
loss_fn(model(xb), yb).backward()
return model[0].weight.grad.clone() # clone: 다음 계산이 덮어쓰지 않게
model = make_model()
g_full = first_layer_grad(model, Xt, yt)
gen = torch.Generator().manual_seed(0)
for B in [8, 32, 128]:
gs = []
for _ in range(200):
idx = torch.randperm(len(Xt), generator=gen)[:B] # 겹치지 않게 B개를 뽑는다
gs.append(first_layer_grad(model, Xt[idx], yt[idx]))
gs = torch.stack(gs)
mean_gap = ((gs.mean(dim=0) - g_full).norm() / g_full.norm()).item()
spread = ((gs - g_full).flatten(1).norm(dim=1) / g_full.norm()).mean().item()
print(f"배치 {B:3d}: 200개 평균과 전체 기울기 차이 {mean_gap:.3f}, 배치 하나의 평균 오차 {spread:.3f}")
출력
배치 8: 200개 평균과 전체 기울기 차이 0.052, 배치 하나의 평균 오차 0.639
배치 32: 200개 평균과 전체 기울기 차이 0.021, 배치 하나의 평균 오차 0.328
배치 128: 200개 평균과 전체 기울기 차이 0.019, 배치 하나의 평균 오차 0.152

11-4. Dataset과 DataLoader

섹션 제목: “11-4. Dataset과 DataLoader”

Dataset: 표본 하나를 꺼내는 규칙

섹션 제목: “Dataset: 표본 하나를 꺼내는 규칙”

클래스(class)는 데이터와 그 데이터를 다루는 함수(메서드)를 한 덩어리로 묶는 틀이다. 아래 class ArrayDataset(Dataset):은 Dataset의 규칙을 물려받는(상속) 새 클래스를 만든다. __init__은 ArrayDataset(X, y)로 만들 때 한 번 실행되고, self는 만들어진 그 객체 자신을 가리킨다(self.X는 객체에 붙여 둔 값이다). 밑줄 두 개로 둘러싼 메서드는 파이썬 문법과 이어진다. len(ds)를 부르면 __len__이, ds[i]를 부르면 __getitem__이 실행된다.

torch.utils.data.Dataset은 “몇 개인가(__len__)“와 “i번째 표본은 무엇인가(__getitem__)” 두 가지만 정하는 클래스다. 이미지 파일을 읽거나 문장을 토큰으로 바꾸는 일도 __getitem__ 안에서 한다(12·13장).

from torch.utils.data import Dataset, TensorDataset, DataLoader
class ArrayDataset(Dataset):
def __init__(self, X, y):
self.X = torch.tensor(X, dtype=torch.float32)
self.y = torch.tensor(y, dtype=torch.float32).reshape(-1, 1)
def __len__(self):
return len(self.X)
def __getitem__(self, i):
return self.X[i], self.y[i] # 표본 하나: (특성 (2,), 정답 (1,))
ds = ArrayDataset(scaler.transform(X_tr), y_tr)
x0, y0 = ds[0]
print(len(ds), x0.shape, y0.shape, x0.dtype)
same = TensorDataset(Xt, yt) # 이미 텐서면 이 한 줄로 같은 일
print(len(same), torch.equal(same[0][0], x0), torch.equal(same[0][1], y0))
출력
700 torch.Size([2]) torch.Size([1]) torch.float32
700 True True

DataLoader: 섞고, 묶고, 한 바퀴 돈다

섹션 제목: “DataLoader: 섞고, 묶고, 한 바퀴 돈다”

DataLoader는 Dataset에서 표본을 batch_size개씩 꺼내 쌓아(stack) 배치 텐서로 준다. shuffle=True면 에폭마다 순서를 새로 섞는다. 순서를 보기 쉽게 0~9 정수를 데이터로 쓴다.

g = torch.Generator().manual_seed(0)
toy = DataLoader(list(range(10)), batch_size=4, shuffle=True, generator=g)
for epoch in range(2):
print(f"에폭 {epoch + 1}:", [b.tolist() for b in toy])
print("섞지 않음:", [b.tolist() for b in DataLoader(list(range(10)), batch_size=4)])
print("drop_last:", [b.tolist() for b in DataLoader(list(range(10)), batch_size=4, drop_last=True)])
출력
에폭 1: [[3, 7, 5, 2], [0, 8, 1, 6], [9, 4]]
에폭 2: [[1, 3, 2, 7], [5, 9, 0, 6], [4, 8]]
섞지 않음: [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]]
drop_last: [[0, 1, 2, 3], [4, 5, 6, 7]]

실제 데이터로 만든 배치의 모양을 본다.

train_loader = DataLoader(TensorDataset(Xt, yt), batch_size=32, shuffle=True,
generator=torch.Generator().manual_seed(0))
xb, yb = next(iter(train_loader))
print(len(train_loader), xb.shape, yb.shape, [len(xb) for xb, _ in train_loader][-1])
출력
22 torch.Size([32, 2]) torch.Size([32, 1]) 28

len(train_loader)는 에폭당 스텝 수(⌈700/32⌉=22\lceil 700 / 32 \rceil = 22)다. 배치 텐서는 (32, 2)와 (32, 1), 마지막 배치는 28개다.

11-5. 기본 학습 루프

섹션 제목: “11-5. 기본 학습 루프”

네 줄과 두 함수

섹션 제목: “네 줄과 두 함수”

모든 PyTorch 학습 루프의 중심은 네 줄이다.

def train_one_epoch(model, loader, optimizer):
model.train() # 훈련 모드(11-9절 드롭아웃·배치 정규화)
total, n = 0.0, 0
for xb, yb in loader:
optimizer.zero_grad() # 1. 지난 기울기를 비운다
loss = loss_fn(model(xb), yb) # 2. 순전파와 손실
loss.backward() # 3. 역전파: 모든 매개변수의 .grad
optimizer.step() # 4. 갱신
total += loss.item() * len(xb) # 배치 평균 × 배치 크기 = 배치 합
n += len(xb)
return total / n # 에폭 동안의 평균 훈련 손실
def evaluate(model, X, y):
model.eval() # 평가 모드
with torch.no_grad(): # 기록하지 않는다
z = model(X)
return loss_fn(z, y).item(), ((z > 0).float() == y).float().mean().item()

옵티마이저가 하는 일

섹션 제목: “옵티마이저가 하는 일”

torch.optim.SGD(model.parameters(), lr=0.1)의 step()이 10장의 손 갱신과 같은지 확인한다.

model = make_model()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
before = [p.detach().clone() for p in model.parameters()]
optimizer.zero_grad()
loss_fn(model(Xt), yt).backward()
by_hand = [p.detach() - 0.1 * p.grad for p in model.parameters()] # 10장 방식: w ← w − η·∂L/∂w
optimizer.step()
print(all(torch.allclose(p, h) for p, h in zip(model.parameters(), by_hand)),
any(not torch.equal(p, b) for p, b in zip(model.parameters(), before)))
출력
True True

optimizer.step()이 모든 매개변수에서 w←w−η ∂L/∂ww \leftarrow w - \eta \, \partial L / \partial w를 했다. model.parameters()는 층마다 흩어진 가중치·절편을 모두 모아 주므로, 층을 바꿔도 옵티마이저 코드는 그대로다.

BCEWithLogitsLoss: 점수를 넘기는 이유

섹션 제목: “BCEWithLogitsLoss: 점수를 넘기는 이유”

10장은 시그모이드로 확률을 만든 뒤 로그 손실을 계산했다. PyTorch는 모델이 점수 zz를 내고 nn.BCEWithLogitsLoss가 시그모이드와 로그 손실을 한 번에 계산하게 한다. 값은 같지만 ∣z∣\lvert z \rvert가 클 때 차이가 난다.

z = torch.tensor([[-200.0], [0.0], [3.0]])
target = torch.tensor([[1.0], [1.0], [0.0]])
p = torch.sigmoid(z)
manual = -(target * torch.log(p) + (1 - target) * torch.log(1 - p))
def show(name, v):
print(f"{name:14s}", [round(x, 4) for x in v.flatten().tolist()])
show("시그모이드 값", p)
show("직접 계산", manual)
show("BCEWithLogits", nn.BCEWithLogitsLoss(reduction="none")(z, target))
show("BCELoss", nn.BCELoss(reduction="none")(p, target))
출력
시그모이드 값 [0.0, 0.5, 0.9526]
직접 계산 [inf, 0.6931, 3.0486]
BCEWithLogits [200.0, 0.6931, 3.0486]
BCELoss [100.0, 0.6931, 3.0486]

처음으로 끝까지 학습하기

섹션 제목: “처음으로 끝까지 학습하기”
model = make_model()
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
for epoch in range(1, 31):
tr_loss = train_one_epoch(model, train_loader, optimizer)
if epoch in (1, 10, 20, 30):
va_loss, va_acc = evaluate(model, Xv, yv)
print(f"에폭 {epoch:2d}: 훈련 손실(에폭 평균) {tr_loss:.3f}, 검증 손실 {va_loss:.3f}, 검증 정확도 {va_acc:.3f}")
출력
에폭 1: 훈련 손실(에폭 평균) 0.665, 검증 손실 0.628, 검증 정확도 0.860
에폭 10: 훈련 손실(에폭 평균) 0.314, 검증 손실 0.324, 검증 정확도 0.870
에폭 20: 훈련 손실(에폭 평균) 0.290, 검증 손실 0.307, 검증 정확도 0.873
에폭 30: 훈련 손실(에폭 평균) 0.260, 검증 손실 0.265, 검증 정확도 0.900

11-6. 옵티마이저: SGD·모멘텀·Adam

섹션 제목: “11-6. 옵티마이저: SGD·모멘텀·Adam”

세 가지 갱신 규칙

섹션 제목: “세 가지 갱신 규칙”
옵티마이저 갱신 규칙(gg는 이번 배치의 기울기) 특징
SGD w←w−ηgw \leftarrow w - \eta g 가장 단순. 학습률 η\eta 하나에 민감하다
모멘텀(momentum) v←μv+gv \leftarrow \mu v + g, w←w−ηvw \leftarrow w - \eta v 지난 방향을 이어 가 흔들림이 줄고, 같은 방향이 이어지면 빨라진다. μ\mu는 보통 0.9
Adam 기울기의 이동 평균 mm과 제곱의 이동 평균 vv를 두고, 매개변수마다 w←w−η m^/(v^+ϵ)w \leftarrow w - \eta\, \hat{m} / (\sqrt{\hat{v}} + \epsilon) 매개변수마다 갱신 크기를 스스로 맞춘다. 기본 η=0.001\eta = 0.001, 이 장은 0.01

같은 데이터, 같은 시작점에서 비교

섹션 제목: “같은 데이터, 같은 시작점에서 비교”

모델 초깃값과 배치 순서를 모두 같게 두고 옵티마이저만 바꾼다. 매 에폭 끝에 훈련 데이터 전체와 검증 데이터의 손실을 같은 시점에 잰다.

def fit(make_opt, epochs=30, seed=0):
model = make_model(seed)
optimizer = make_opt(model.parameters())
loader = DataLoader(TensorDataset(Xt, yt), batch_size=32, shuffle=True,
generator=torch.Generator().manual_seed(seed))
history = []
for _ in range(epochs):
train_one_epoch(model, loader, optimizer)
history.append((evaluate(model, Xt, yt)[0], *evaluate(model, Xv, yv)))
return model, history
settings = {"SGD lr=0.01": lambda p: torch.optim.SGD(p, lr=0.01),
"SGD lr=0.1": lambda p: torch.optim.SGD(p, lr=0.1),
"모멘텀 lr=0.1": lambda p: torch.optim.SGD(p, lr=0.1, momentum=0.9),
"Adam lr=0.01": lambda p: torch.optim.Adam(p, lr=0.01),
"Adam lr=0.1": lambda p: torch.optim.Adam(p, lr=0.1)}
from sklearn.linear_model import LogisticRegression
print("로지스틱 회귀 검증 정확도", round(LogisticRegression().fit(Xt.numpy(), y_tr).score(Xv.numpy(), y_va), 3))
histories = {}
for name, make_opt in settings.items():
_, h = fit(make_opt)
histories[name] = h
print(f"{name}: 훈련 손실 1·5·30에폭 {h[0][0]:.3f} {h[4][0]:.3f} {h[-1][0]:.3f}, 검증 손실 {h[-1][1]:.3f}, 검증 정확도 {h[-1][2]:.3f}")
출력
로지스틱 회귀 검증 정확도 0.84
SGD lr=0.01: 훈련 손실 1·5·30에폭 0.690 0.664 0.396, 검증 손실 0.409, 검증 정확도 0.860
SGD lr=0.1: 훈련 손실 1·5·30에폭 0.626 0.326 0.256, 검증 손실 0.266, 검증 정확도 0.893
모멘텀 lr=0.1: 훈련 손실 1·5·30에폭 0.330 0.253 0.218, 검증 손실 0.237, 검증 정확도 0.927
Adam lr=0.01: 훈련 손실 1·5·30에폭 0.368 0.258 0.204, 검증 손실 0.235, 검증 정확도 0.927
Adam lr=0.1: 훈련 손실 1·5·30에폭 0.295 0.234 0.221, 검증 손실 0.263, 검증 정확도 0.920
SGD lr 0.01은 검증 손실이 천천히 줄고, 모멘텀·Adam은 빨리 줄지만 흔들리며, 작은 데이터의 큰 MLP는 9에폭 뒤로 검증 손실이 전반적으로 오른다SGD lr 0.01은 검증 손실이 천천히 줄고, 모멘텀·Adam은 빨리 줄지만 흔들리며, 작은 데이터의 큰 MLP는 9에폭 뒤로 검증 손실이 전반적으로 오른다

그림 설명. 왼쪽은 같은 초깃값·배치 순서에서 옵티마이저·학습률만 바꾼 다섯 설정의 검증 로그 손실(세로 약 0.2~0.7)을 에폭(가로 1~30)마다 그린 것이다. SGD lr=0.01(회색)은 약 0.69에서 시작해 30에폭에 약 0.41까지 천천히 내려간다. SGD lr=0.1(초록)은 5에폭쯤 약 0.34로 내려온 뒤 매끈하게 줄어 약 0.27이 된다. 모멘텀 lr=0.1, Adam lr=0.01(파랑), Adam lr=0.1(빨강)은 첫 에폭부터 0.3~0.4 근처로 낮지만, 그 뒤 0.22~0.35 사이를 오르내린다. 오른쪽은 훈련 데이터 60개로 은닉 64유닛 MLP를 200에폭 학습한 로그 손실이다. 훈련 손실(파랑)은 오르내리면서 전반적으로 0에 가깝게 내려가고, 검증 손실(빨강)은 9에폭에서 약 0.34로 가장 낮았다가(세로 점선) 오르내리면서 전반적으로 올라 200에폭에 약 2.4가 된다.

11-7. 학습 곡선 읽기와 멈출 시점

섹션 제목: “11-7. 학습 곡선 읽기와 멈출 시점”

과적합 곡선

섹션 제목: “과적합 곡선”

훈련 데이터를 60개로 줄이고 은닉 유닛을 64개로 키워 과적합을 일부러 만든다. 200에폭 동안 매 에폭 훈련·검증 손실을 기록하고, 검증 손실이 가장 낮았던 에폭의 매개변수를 따로 저장한다.

import copy
def make_big(seed=0):
torch.manual_seed(seed)
return nn.Sequential(nn.Linear(2, 64), nn.ReLU(), nn.Linear(64, 64), nn.ReLU(), nn.Linear(64, 1))
Xs, ys = Xt[:60], yt[:60]
big = make_big()
opt = torch.optim.Adam(big.parameters(), lr=0.01)
small_loader = DataLoader(TensorDataset(Xs, ys), batch_size=16, shuffle=True,
generator=torch.Generator().manual_seed(0))
curve, best = [], {"loss": float("inf")}
for epoch in range(1, 201):
train_one_epoch(big, small_loader, opt)
tr, va = evaluate(big, Xs, ys)[0], evaluate(big, Xv, yv)
curve.append((tr, *va))
if va[0] < best["loss"]: # 검증 손실이 새로 가장 낮으면
best = {"loss": va[0], "epoch": epoch, "state": copy.deepcopy(big.state_dict())}
for e in (best["epoch"], 50, 200):
print(f"에폭 {e:3d}: 훈련 손실 {curve[e - 1][0]:.3f}, 검증 손실 {curve[e - 1][1]:.3f}, 검증 정확도 {curve[e - 1][2]:.3f}")
출력
에폭 9: 훈련 손실 0.160, 검증 손실 0.343, 검증 정확도 0.877
에폭 50: 훈련 손실 0.060, 검증 손실 0.797, 검증 정확도 0.887
에폭 200: 훈련 손실 0.009, 검증 손실 2.418, 검증 정확도 0.890
ref = big.state_dict() # 복사하지 않은 것
print(ref["0.weight"].data_ptr() == big[0].weight.data_ptr()) # 같은 메모리를 가리킨다
big.load_state_dict(best["state"]) # 가장 좋았던 에폭으로 되돌린다
print(round(evaluate(big, Xv, yv)[0], 3) == round(best["loss"], 3))
출력
True
True

곡선 모양별 진단

섹션 제목: “곡선 모양별 진단”
곡선 모양 뜻 먼저 할 일
훈련·검증 손실이 둘 다 높고 천천히 내려간다 과소적합, 학습률이 작거나 에폭이 부족 학습률 키우기, 에폭 늘리기, Adam 시도, 모델 키우기
훈련 손실은 계속 내려가고 검증 손실은 바닥을 찍고 오른다 과적합 가장 낮았던 에폭 쓰기(조기 종료), 데이터 늘리기, 모델 줄이기, 드롭아웃·가중치 감쇠
손실이 크게 들쭉날쭉하거나 커지다 nan 학습률 과다, 기울기 비우기 누락, 입력 스케일 문제 zero_grad 확인, 학습률 낮추기, 입력 표준화 확인
처음부터 손실이 log⁡2≈0.693\log 2 \approx 0.693에서 움직이지 않는다 기울기가 흐르지 않거나 갱신이 안 됨(초기화·모양, 학습률 0, 옵티마이저에 매개변수 누락) 10장 진단 순서(초기화·(N, 1)/(N,) 모양), .grad 값·학습률·옵티마이저에 넣은 매개변수 확인
검증 손실이 훈련 손실보다 처음부터 훨씬 낮다 드롭아웃 같은 훈련 전용 동작, 또는 분할·누수 문제 같은 시점·같은 모드로 쟀는지, 분할을 확인

11-8. 체크포인트 저장과 재로딩

섹션 제목: “11-8. 체크포인트 저장과 재로딩”

state_dict 저장·재로딩

섹션 제목: “state_dict 저장·재로딩”

모델의 상태는 model.state_dict()(이름 → 텐서 딕셔너리)로 꺼낸다. 학습하는 매개변수와, 배치 정규화의 누적 평균·분산처럼 학습하지 않지만 저장해야 하는 값(버퍼)이 함께 들어 있다. 옵티마이저도 state_dict()가 있다. Adam의 이동 평균 mm·vv처럼 옵티마이저가 들고 있는 값이 여기 들어 있다. 이어서 학습하려면 둘 다 저장한다.

import os
import tempfile
model, _ = fit(lambda p: torch.optim.Adam(p, lr=0.01), epochs=5)
path = os.path.join(tempfile.mkdtemp(), "moons.pt")
torch.save({"model": model.state_dict(), "epoch": 5,
"scaler_mean": scaler.mean_.tolist(), "scaler_scale": scaler.scale_.tolist()}, path)
ckpt = torch.load(path, weights_only=True) # 텐서·숫자·리스트·딕셔너리만 읽는다
restored = make_model(seed=123) # 다른 난수로 만든 새 모델
restored.load_state_dict(ckpt["model"])
print(sorted(ckpt), ckpt["epoch"])
x_new = np.array([[0.5, 0.0], [1.5, -0.5]]) # 원래 단위의 새 표본
x_std = (x_new - np.array(ckpt["scaler_mean"])) / np.array(ckpt["scaler_scale"])
restored.eval(); model.eval()
with torch.no_grad():
a = torch.sigmoid(model(torch.tensor(x_std, dtype=torch.float32)))
b = torch.sigmoid(restored(torch.tensor(x_std, dtype=torch.float32)))
print(torch.equal(a, b), [round(v, 3) for v in a.flatten().tolist()])
출력
['epoch', 'model', 'scaler_mean', 'scaler_scale'] 5
True [0.781, 0.967]

이어서 학습하기

섹션 제목: “이어서 학습하기”

10에폭을 한 번에 학습한 결과와, 5에폭 학습 → 저장 → 새 객체로 불러오기 → 5에폭 더 학습한 결과를 비교한다. 이어서 학습할 때 옵티마이저 상태가 없으면 어떻게 되는지도 본다.

def run(model, optimizer, gen, epochs):
loader = DataLoader(TensorDataset(Xt, yt), batch_size=32, shuffle=True, generator=gen)
for _ in range(epochs):
train_one_epoch(model, loader, optimizer)
def adam(model):
return torch.optim.Adam(model.parameters(), lr=0.01)
m_full = make_model(); g_full = torch.Generator().manual_seed(0)
run(m_full, adam(m_full), g_full, 10) # 끊지 않고 10에폭
m_a = make_model(); o_a = adam(m_a); g_a = torch.Generator().manual_seed(0)
run(m_a, o_a, g_a, 5)
torch.save({"model": m_a.state_dict(), "optimizer": o_a.state_dict(), "gen": g_a.get_state(), "epoch": 5}, path)
ck = torch.load(path, weights_only=True)
for keep_opt in [True, False]:
m_b = make_model(seed=99); o_b = adam(m_b) # 새 객체로 다시 시작하는 상황
m_b.load_state_dict(ck["model"])
if keep_opt:
o_b.load_state_dict(ck["optimizer"]) # Adam의 m·v와 스텝 수를 되살린다
g_b = torch.Generator(); g_b.set_state(ck["gen"]) # 섞는 순서도 이어서
run(m_b, o_b, g_b, 5)
same = all(torch.equal(p, q) for p, q in zip(m_full.parameters(), m_b.parameters()))
print(f"옵티마이저 상태 {'복원' if keep_opt else '없음'}: 끊지 않은 학습과 같음 {same}, 검증 손실 {evaluate(m_b, Xv, yv)[0]:.4f}")
print(f"끊지 않은 학습 검증 손실 {evaluate(m_full, Xv, yv)[0]:.4f}")
출력
옵티마이저 상태 복원: 끊지 않은 학습과 같음 True, 검증 손실 0.2922
옵티마이저 상태 없음: 끊지 않은 학습과 같음 False, 검증 손실 0.2891
끊지 않은 학습 검증 손실 0.2922

11-9. 학습을 돕는 기법 미리 보기

섹션 제목: “11-9. 학습을 돕는 기법 미리 보기”

이 절의 기법은 12장 이후에 실제로 쓴다. 여기서는 무엇을 하는지와, 훈련과 평가에서 동작이 다른 층이 있다는 점만 확인한다.

초기화

섹션 제목: “초기화”

10장에서 가중치를 0이나 같은 값으로 시작하면 안 되고, 표준편차 1/입력 수1/\sqrt{\text{입력 수}} 정도의 난수로 시작한다고 했다. 활성화 함수에 맞춰 크기를 정하는 대표 방법이 Xavier(Glorot) 초기화(시그모이드·tanh)와 He(Kaiming) 초기화(ReLU)이고, torch.nn.init에 있다. nn.Linear는 만들 때 이미 입력 수에 맞춘 균등분포 난수로 초기화하므로, 작은 MLP는 기본값으로 충분하다.

lin = nn.Linear(256, 64)
print(round(lin.weight.abs().max().item(), 4), round(1 / 256 ** 0.5, 4)) # 기본: (−1/√256, 1/√256) 범위
nn.init.kaiming_normal_(lin.weight, nonlinearity="relu") # He 초기화로 바꾸기
print(round(lin.weight.std().item(), 3), round((2 / 256) ** 0.5, 3)) # 표준편차 √(2/입력 수) 근처
출력
0.0625 0.0625
0.088 0.088

드롭아웃과 배치 정규화: 훈련과 평가가 다르다

섹션 제목: “드롭아웃과 배치 정규화: 훈련과 평가가 다르다”

드롭아웃(dropout)은 훈련 중 유닛을 확률 pp로 무작위로 꺼서(0으로) 특정 유닛에 기대지 못하게 하는 과적합 억제 기법이다. 배치 정규화(batch normalization)는 층의 출력을 특성마다 배치의 평균·표준편차로 표준화한 뒤, 학습하는 계수 γ\gamma와 절편 β\beta로 크기와 위치를 다시 맞춰 깊은 신경망의 학습을 안정시킨다(아래 출력은 처음 값 γ=1\gamma = 1, β=0\beta = 0일 때다). 둘 다 훈련과 평가에서 동작이 다르다.

torch.manual_seed(0)
drop = nn.Dropout(p=0.5)
x = torch.ones(1, 8)
drop.train(); print("드롭아웃 훈련:", drop(x).tolist())
drop.eval(); print("드롭아웃 평가:", drop(x).tolist())
bn = nn.BatchNorm1d(1)
batch = torch.tensor([[1.0], [2.0], [3.0], [6.0]])
r3 = lambda v: [round(x, 3) for x in v.flatten().tolist()]
bn.train(); print("배치 정규화 훈련:", r3(bn(batch)))
bn.eval(); print("배치 정규화 평가:", r3(bn(batch)), "/ 누적 평균", round(bn.running_mean.item(), 3),
"누적 분산", round(bn.running_var.item(), 3))
출력
드롭아웃 훈련: [[0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0, 2.0]]
드롭아웃 평가: [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]]
배치 정규화 훈련: [-1.069, -0.535, 0.0, 1.604]
배치 정규화 평가: [0.599, 1.454, 2.31, 4.876] / 누적 평균 0.3 누적 분산 1.367

학습률 스케줄

섹션 제목: “학습률 스케줄”

학습 초반에는 크게, 후반에는 작게 움직이면 빠르면서도 안정하게 수렴하는 경우가 많다. 에폭에 따라 학습률을 바꾸는 것을 학습률 스케줄(learning rate schedule)이라 하고 torch.optim.lr_scheduler에 있다.

opt = torch.optim.SGD(make_model().parameters(), lr=0.1)
sched = torch.optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.5) # 10에폭마다 절반
lrs = []
for epoch in range(30):
lrs.append(opt.param_groups[0]["lr"])
opt.step() # 학습 자리(기울기가 없어 그대로)
sched.step() # 에폭이 끝날 때 한 번
print(lrs[0], lrs[9], lrs[10], lrs[20], lrs[29])
출력
0.1 0.1 0.05 0.025 0.025

StepLR(opt, step_size=s, gamma=γ)는 scheduler.step()이 s번 불릴 때마다 학습률에 γ를 곱한다. scheduler.step()은 optimizer.step() 뒤, 보통 에폭 끝에 부른다. 코사인 모양으로 줄이는 CosineAnnealingLR, 검증 손실이 멈추면 줄이는 ReduceLROnPlateau 등이 있다. 어떤 스케줄이 좋은지는 문제마다 달라 검증 점수로 고른다.

11-10. 수학 상자: 모멘텀·Adam과 수치 정밀도

섹션 제목: “11-10. 수학 상자: 모멘텀·Adam과 수치 정밀도”

모멘텀과 Adam의 식

섹션 제목: “모멘텀과 Adam의 식”

스텝 tt에서 기울기를 gtg_t라 하면(η\eta는 학습률, 곱·나눗셈·제곱근은 매개변수마다 원소별로 한다):

식을 직접 계산해 torch.optim과 맞춘다.

w0 = torch.tensor([1.0, -2.0, 3.0])
grads = [torch.tensor([0.5, -0.1, 2.0]), torch.tensor([0.3, 0.2, -1.0]), torch.tensor([0.4, -0.3, 0.5])]
def by_torch(make_opt, n_steps=3):
w = w0.clone().requires_grad_()
opt = make_opt([w])
for g in grads[:n_steps]:
w.grad = g.clone() # backward 대신 기울기를 직접 넣는다
opt.step()
return w.detach()
w, v = w0.clone(), torch.zeros(3) # 모멘텀
for g in grads:
v = 0.9 * v + g
w = w - 0.1 * v
print("모멘텀:", torch.allclose(w, by_torch(lambda p: torch.optim.SGD(p, lr=0.1, momentum=0.9))), [round(x, 4) for x in w.tolist()])
w, m, v = w0.clone(), torch.zeros(3), torch.zeros(3) # Adam
b1, b2, eps = 0.9, 0.999, 1e-8
for t, g in enumerate(grads, start=1):
m = b1 * m + (1 - b1) * g
v = b2 * v + (1 - b2) * g ** 2
w = w - 0.1 * (m / (1 - b1 ** t)) / ((v / (1 - b2 ** t)).sqrt() + eps)
print("Adam :", torch.allclose(w, by_torch(lambda p: torch.optim.Adam(p, lr=0.1))), [round(x, 4) for x in w.tolist()])
first = by_torch(lambda p: torch.optim.Adam(p, lr=0.1), n_steps=1)
print("Adam 첫 스텝 이동:", [round(x, 4) for x in (first - w0).tolist()], "/ 첫 기울기", [round(x, 4) for x in grads[0].tolist()])
출력
모멘텀: True [0.7675, -1.9809, 2.598]
Adam : True [0.7071, -1.9023, 2.8393]
Adam 첫 스텝 이동: [-0.1, 0.1, -0.1] / 첫 기울기 [0.5, -0.1, 2.0]

Adam의 첫 스텝에서는 기울기가 −0.1이든 2.0이든 모든 매개변수가 0.1(= η\eta)씩, 기울기 반대 방향으로 움직였다. 이동이 −η g1/(∣g1∣+ϵ)-\eta\, g_1 / (\lvert g_1 \rvert + \epsilon)이고, 여기서는 ∣g1∣\lvert g_1 \rvert이 ϵ=10−8\epsilon = 10^{-8}보다 훨씬 커서 −η g1/∣g1∣-\eta\, g_1 / \lvert g_1 \rvert와 같기 때문이다(기울기가 ϵ\epsilon 정도로 아주 작으면 이동도 η\eta보다 작다). 그 뒤로는 기울기 부호가 자주 바뀐 매개변수일수록 mm이 상쇄되어 덜 움직인다. Adam은 기울기를 최근 크기로 나눠 쓰므로, 갱신 폭이 기울기의 절대 크기보다 방향이 얼마나 일관된가에 따라 정해지는 셈이다.

수치 정밀도

섹션 제목: “수치 정밀도”

컴퓨터의 실수는 유한한 자릿수로 저장되어 계산마다 반올림이 생긴다. float32는 유효숫자 약 7자리, float64는 약 16자리다.

f32 = torch.finfo(torch.float32)
print(f32.eps, f32.max, f32.tiny)
one = torch.tensor(1.0)
print((one + 1e-8 == one).item(), (torch.tensor(1.0, dtype=torch.float64) + 1e-8 == 1.0).item())
print(torch.exp(torch.tensor([88.0, 89.0])).tolist())
z = torch.tensor(-200.0)
print(torch.log(torch.sigmoid(z)).item(), nn.functional.logsigmoid(z).item())
출력
1.1920928955078125e-07 3.4028234663852886e+38 1.1754943508222875e-38
True False
[1.6516362661361307e+38, inf]
-inf -200.0

11-11. 이 장의 루프를 언제 쓰나

섹션 제목: “11-11. 이 장의 루프를 언제 쓰나”
상황 이 장의 방법 다른 선택
데이터가 메모리에 들어가는 작은 표·2차원 데이터 TensorDataset + DataLoader, Adam으로 시작 전체 배치(10장)도 가능. 표 데이터는 트리 앙상블이 먼저(07·09장)
이미지·문장처럼 파일에서 하나씩 읽는다 직접 만든 Dataset의 __getitem__에서 읽고 변환 12·13장
학습이 몇 시간 걸린다 에폭마다 체크포인트(모델·옵티마이저·에폭·전처리 값) –
사전학습 모델을 미세조정한다 같은 루프, 작은 학습률, 일부 층 동결 Hugging Face Trainer(15장)는 이 루프를 감싼 도구

11-12. 선택 기준표에 추가

섹션 제목: “11-12. 선택 기준표에 추가”
상황 고를 것 이유 장
신경망 옵티마이저를 처음 고른다 Adam(lr = 0.001~0.01). 잘 되면 SGD+모멘텀(0.9)과 학습률 몇 개를 검증 점수로 비교 Adam은 학습률에 덜 민감하다. 어느 쪽이 늘 낫다는 규칙은 없다 11
배치 크기를 정한다 32~128에서 시작, 메모리·속도를 보며 조정. 훈련 데이터만 shuffle=True 작을수록 기울기가 흔들리고, 클수록 스텝이 비싸다 11
언제 멈출지 정한다 매 에폭 검증 손실을 재고 가장 낮은 에폭의 state_dict를 deepcopy로 보관, 인내 에폭 동안 나아지지 않으면 종료 훈련 손실만으로는 과적합을 못 본다 11
학습 곡선이 이상하다 11-7절 표: 둘 다 높음 → 학습률·에폭, 검증만 오름 → 조기 종료·정규화, 흔들림·nan → zero_grad·학습률·입력 스케일 곡선 모양이 원인을 가리킨다 11
학습한 신경망을 저장한다 모델·옵티마이저 state_dict + 에폭 + 전처리 값, torch.load(weights_only=True). 재로딩 뒤 같은 예측 확인 이어서 학습하려면 옵티마이저 상태가 필요하다 11
이진 분류 손실을 고른다 마지막 층은 점수(로짓), 손실은 BCEWithLogitsLoss 시그모이드 후 log는 float32에서 inf가 될 수 있다 11

확인 문제

섹션 제목: “확인 문제”

11-13. 실습과 문제

섹션 제목: “11-13. 실습과 문제”

실습/문제/ch11_PyTorch_학습_루프.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안에 끝난다. 다 푼 뒤 해설 노트북과 비교한다. 실습은 sklearn에 들어 있는 유방암 진단 데이터(load_breast_cancer, 569건, 특성 30개)로 같은 과정을 밟는다.

번호 유형 내용
1 개념 배치·에폭·스텝, DataLoader 참/거짓
2 코드 표 데이터를 꺼내 주는 Dataset 클래스
3 코드 훈련·검증 DataLoader 만들기(섞기·재현)
4 코드 한 에폭 학습 함수
5 코드 평가 함수(eval·no_grad, 손실·정확도)
6 코드 검증 손실로 가장 좋은 에폭 보관(조기 종료)
7 코드 체크포인트 저장·재로딩과 이어서 학습
8 개념 옵티마이저·학습 보조 기법 참/거짓
9 사례 학습 곡선 진단
10 사례 상황별 설정 고르기

11-14. 공식 문서와 참고 자료

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