AI 기초 › 11장
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. 왜 학습 루프를 정리하나”- 전체 배치는 비싸다. 10장은 스텝마다 훈련 데이터 전부로 기울기를 구했다. 표본이 100만 개면 한 번 갱신하려고 100만 개를 모두 계산해야 한다. 일부만 뽑아 구한 기울기도 방향은 거의 맞으므로, 작은 묶음으로 자주 갱신하는 편이 같은 시간에 더 많이 배운다.
- 반복되는 코드는 도구에 맡긴다. 섞기·나누기·묶기는
DataLoader가, 갱신과 기울기 비우기는 옵티마이저가 한다. 모델이 바뀌어도 루프는 거의 그대로다. - 언제 멈출지 알아야 한다. 손실이 줄기만 하면 끝이 아니다. 검증 손실을 함께 기록해야 과적합을 보고 멈출 때를 정한다(05장).
- 학습은 길고 끊긴다. 몇 시간짜리 학습은 중간에 저장하고 이어서 해야 한다. 09장에서 전처리 포함 모델을 저장했듯, 신경망도 저장·재로딩해 같은 예측이 나오는지 확인한다.
11-3. 배치·에폭·스텝
섹션 제목: “11-3. 배치·에폭·스텝”세 단어의 관계
섹션 제목: “세 단어의 관계”- 배치 크기(batch size) : 기울기 한 번을 계산하는 데 쓰는 표본 수.
- 스텝(step): 매개변수를 한 번 갱신하는 것. 배치 하나 → 기울기 하나 → 스텝 하나.
- 에폭(epoch): 훈련 데이터를 한 바퀴 다 보는 것. 마지막의 덜 찬 배치까지 쓰면 에폭당 스텝 수는 (올림)이고, 그 배치를 버리면(
drop_last=True) (내림)이다.
import mathimport numpy as npimport torchfrom torch import nn
N = 700for 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번- 이면 전체 배치(full batch) 경사하강법이다(10장). 에폭과 스텝이 같다.
- 이면 미니배치(mini-batch) 경사하강법이다. 딥러닝의 기본이고 는 보통 16~512 사이에서 고른다.
- 이면 표본 하나로 갱신한다. 좁은 뜻의 확률적 경사하강법(SGD, stochastic gradient descent)이다. 넓게는 미니배치 방식도 SGD라 부르고, PyTorch의
torch.optim.SGD도 배치 크기와 상관없이 이 이름을 쓴다. - 700 = 32 × 21 + 28이라 마지막 배치는 28개다. 크기가 다른 마지막 배치를 버리려면
drop_last=True를 쓴다(11-4절).
미니배치 기울기는 전체 기울기의 추정값이다
섹션 제목: “미니배치 기울기는 전체 기울기의 추정값이다”이 장의 데이터는 반달 두 개가 맞물린 make_moons(1000개, 잡음 0.3)다. 10장 실습보다 잡음이 커서 두 범주가 겹친다. 훈련 700개, 검증 300개로 나누고 05장 규칙대로 훈련 데이터로만 표준화한다.
from sklearn.datasets import make_moonsfrom sklearn.model_selection import train_test_splitfrom 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.5make_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- 배치 기울기 하나는 전체 기울기와 꽤 다르다(오차가 큼). 그러나 평균을 내면 전체 기울기에 가까워진다. 미니배치 기울기는 전체 기울기를 중심으로 흔들리는 추정값이다.
- 배치를 4배로 키우면 오차는 대략 절반이 된다(). 배치가 크면 기울기가 정확하지만 스텝 하나가 비싸고, 배치가 작으면 부정확하지만 같은 계산으로 더 자주 갱신한다.
- 작은 배치의 흔들림은 단점만은 아니다. 손실 곡면의 얕은 웅덩이에서 빠져나오게 돕는 경우가 있다고 알려져 있다. 다만 너무 작으면 학습 곡선이 심하게 흔들리고 CPU·GPU를 놀린다. 처음에는 32~128로 시작해 메모리와 속도를 보며 조정한다.
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.float32700 True True- 표본 하나는
(2,), 정답은(1,)이다. 배치 축은DataLoader가 붙인다. - 데이터가 이미 텐서로 메모리에 다 있으면
TensorDataset으로 충분하다. 직접 만든Dataset은 파일에서 하나씩 읽거나 꺼낼 때 변환해야 할 때 쓴다.
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]]- 에폭마다 순서가 다르다. 데이터가 정렬되어 있으면 비슷한 표본이 연달아 들어와 갱신 방향이 한쪽으로 치우치므로, 서로 독립인 표본을 미니배치로 학습할 때는 훈련 데이터를 섞는다. (시계열처럼 순서 자체를 지켜야 하는 학습은 13장에서 따로 다룬다.) 검증·테스트 데이터는 섞을 이유가 없다. 순서를 그대로 둬야 예측을 원래 행과 맞추기 쉽다(09장 제출 행 대응).
generator에 시드를 준torch.Generator를 넘기면 섞는 순서가 재현된다. 넘기지 않으면 PyTorch 전역 난수(torch.manual_seed)를 쓴다.- 10개를 4개씩 묶으면 마지막 배치는 2개다.
drop_last=True는 그 배치를 버린다. 배치 정규화(11-9절)처럼 배치가 너무 작으면 불안정한 층을 쓸 때 켠다.
실제 데이터로 만든 배치의 모양을 본다.
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]) 28len(train_loader)는 에폭당 스텝 수()다. 배치 텐서는 (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()- 1~4는 10장 10-9절 루프의
t.grad.zero_(), 순전파,backward(),t -= lr * t.grad와 같은 일이다. 옵티마이저가 매개변수 목록을 들고 있다가 한 번에 처리한다. loss.item() * len(xb): 손실은 배치 평균이다. 마지막 배치처럼 크기가 다른 배치가 있으므로 배치 크기를 곱해 더한 뒤 전체 수로 나눠야 정확한 평균이 된다.- 평가는
model.eval()과torch.no_grad()를 함께 쓴다.eval()은 층의 동작을 평가용으로 바꾸고(11-9절),no_grad()는 기록을 끈다. 하는 일이 달라서 둘 다 필요하다.
- 점수 은 확률 와 같다. 정확도를 구할 때 시그모이드를 따로 계산하지 않아도 된다.
옵티마이저가 하는 일
섹션 제목: “옵티마이저가 하는 일”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/∂woptimizer.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 Trueoptimizer.step()이 모든 매개변수에서 를 했다. model.parameters()는 층마다 흩어진 가중치·절편을 모두 모아 주므로, 층을 바꿔도 옵티마이저 코드는 그대로다.
BCEWithLogitsLoss: 점수를 넘기는 이유
섹션 제목: “BCEWithLogitsLoss: 점수를 넘기는 이유”10장은 시그모이드로 확률을 만든 뒤 로그 손실을 계산했다. PyTorch는 모델이 점수 를 내고 nn.BCEWithLogitsLoss가 시그모이드와 로그 손실을 한 번에 계산하게 한다. 값은 같지만 가 클 때 차이가 난다.
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]- 인데 정답이 1인 표본은 “아주 틀린” 예측이고 손실은 200이어야 한다. 그런데 float32에서 은 0으로 반올림되고, 라 직접 계산은
inf가 된다. 손실이inf면 기울기가nan이 되어 학습이 망가진다. BCEWithLogitsLoss는 확률을 거치지 않고 를 로 바로 계산해(수학 상자 11-10절) 200을 정확히 낸다.nn.BCELoss(확률을 받는 손실)는 log 값을 −100에서 잘라inf를 막지만, 손실 100은 실제 값 200과 다르다.- 그래서 모델 마지막 층은 시그모이드 없이 점수를 내고, 손실은
BCEWithLogitsLoss를 쓴다. 확률이 필요할 때만 예측 단계에서torch.sigmoid를 붙인다. 다중 분류의nn.CrossEntropyLoss도 같은 이유로 소프트맥스 전 점수를 받는다.
처음으로 끝까지 학습하기
섹션 제목: “처음으로 끝까지 학습하기”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- 에폭당 22스텝, 30에폭이면 660번 갱신했다. 전체 배치와 미니배치 중 어느 쪽이 효율적인지는 같은 데이터·같은 모델에서 목표 성능에 닿는 시간으로 비교해야 한다(10장과는 데이터와 모델이 달라 직접 비교할 수 없다).
- 훈련 손실은 에폭 도중 매개변수가 바뀌는 동안 배치마다 잰 값의 평균이다. 에폭이 끝난 뒤 모델로 훈련 데이터 전체를 다시 재면 조금 다르다. 정확히 비교하려면
evaluate(model, Xt, yt)로 같은 시점에 잰다(11-7절).
11-6. 옵티마이저: SGD·모멘텀·Adam
섹션 제목: “11-6. 옵티마이저: SGD·모멘텀·Adam”세 가지 갱신 규칙
섹션 제목: “세 가지 갱신 규칙”| 옵티마이저 | 갱신 규칙(는 이번 배치의 기울기) | 특징 |
|---|---|---|
| SGD | 가장 단순. 학습률 하나에 민감하다 | |
| 모멘텀(momentum) | , | 지난 방향을 이어 가 흔들림이 줄고, 같은 방향이 이어지면 빨라진다. 는 보통 0.9 |
| Adam | 기울기의 이동 평균 과 제곱의 이동 평균 를 두고, 매개변수마다 | 매개변수마다 갱신 크기를 스스로 맞춘다. 기본 , 이 장은 0.01 |
- 모멘텀은 굴러가는 공처럼 이전 속도 를 기억한다. 기울기 방향이 바뀌며 지그재그로 흔들리는 축에서는 서로 상쇄되고, 꾸준한 방향으로는 쌓여서 빨라진다.
- Adam(Adaptive Moment Estimation)은 모멘텀()에 더해, 갱신을 최근 기울기 크기()로 나눠 크기를 맞춘다. 그래서 기울기가 큰 매개변수와 작은 매개변수가 비슷한 폭으로 움직인다. 학습률을 덜 세밀하게 골라도 잘 되는 편이라 처음 시도하는 기본값으로 많이 쓴다. ·의 모자(^)는 처음 몇 스텝에서 0으로 시작한 평균이 작게 치우치는 것을 고치는 편향 보정이다(11-10절).
같은 데이터, 같은 시작점에서 비교
섹션 제목: “같은 데이터, 같은 시작점에서 비교”모델 초깃값과 배치 순서를 모두 같게 두고 옵티마이저만 바꾼다. 매 에폭 끝에 훈련 데이터 전체와 검증 데이터의 손실을 같은 시점에 잰다.
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.84SGD lr=0.01: 훈련 손실 1·5·30에폭 0.690 0.664 0.396, 검증 손실 0.409, 검증 정확도 0.860SGD 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.927Adam lr=0.01: 훈련 손실 1·5·30에폭 0.368 0.258 0.204, 검증 손실 0.235, 검증 정확도 0.927Adam lr=0.1: 훈련 손실 1·5·30에폭 0.295 0.234 0.221, 검증 손실 0.263, 검증 정확도 0.920← 좌우로 밀거나, 그림을 누른 뒤 ← → 키로 옮겨 전체를 본다
그림 설명. 왼쪽은 같은 초깃값·배치 순서에서 옵티마이저·학습률만 바꾼 다섯 설정의 검증 로그 손실(세로 약 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가 된다.
- 같은 SGD라도 학습률이 0.01이면 손실이 에폭마다 0.01~0.02씩 꾸준히 내려가기는 하지만 30에폭 안에 0.40까지밖에 못 간다. 훈련·검증 손실이 둘 다 높은 과소적합이다. 에폭을 늘리거나 학습률을 키워야 한다.
- 모멘텀과 Adam은 첫 에폭부터 손실이 빨리 내려간다(첫 에폭 훈련 손실 0.33·0.37 대 SGD 0.63). 30에폭 뒤에는 SGD(0.1)·모멘텀·Adam이 모두 검증 정확도 0.89~0.93에 도착했다. 잡음이 커서 두 범주가 겹친 데이터라 이 근처가 한계에 가깝고, 직선 경계인 로지스틱 회귀(0.84)보다는 확실히 높다.
- 학습률이 크면 곡선이 흔들린다. 그림 왼쪽에서 Adam(lr = 0.1)과 모멘텀(lr = 0.1)의 검증 손실은 에폭마다 0.22~0.35 사이를 크게 오르내린다. Adam(lr = 0.01)도 미니배치 기울기의 흔들림 때문에 작게 오르내리지만(0.23~0.29) 폭이 작고, SGD(lr = 0.1)는 느리지만 매끈하다. 끝 값이 비슷해도 흔들리는 학습은 “어느 에폭에서 멈추느냐”에 따라 결과가 달라진다. Adam을 쓰면 학습률을 신경 쓰지 않아도 된다는 뜻은 아니다.
- 어느 옵티마이저가 늘 이긴다는 규칙은 없다. 처음에는 Adam(lr = 0.001~0.01)으로 학습이 되는지 빨리 확인하고, 필요하면 SGD+모멘텀과 학습률 몇 개를 검증 점수로 비교한다.
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- 훈련 손실은 0에 가까워지는데 검증 손실은 어느 에폭부터 다시 오른다. 05장의 과적합이 학습 곡선에서는 이렇게 보인다(그림 오른쪽).
- 그사이 검증 정확도는 거의 그대로다(0.877 → 0.890). 정확도만 보면 과적합을 놓친다. 과적합한 모델은 틀리는 표본에도 확률 0.99처럼 지나치게 확신하고, 로그 손실은 확신하고 틀린 예측을 크게 벌주므로 검증 손실이 먼저, 크게 나빠진다. 확률값 자체를 쓰는 곳(06장 임계값, 위험 점수)이라면 이런 모델의 출력을 그대로 믿기 어렵다. 검증 손실이 낮은 체크포인트를 먼저 고르고, 실제 쓰임에 맞는 지표로 평가한다.
- 그래서 매 에폭 검증 손실을 재고, 가장 낮았던 에폭의 매개변수를 남긴다. 검증 손실이 일정 에폭(예: 10~20) 동안 나아지지 않으면 학습을 멈추는 것을 조기 종료(early stopping)라 한다. 이 에폭 수를 인내(patience)라 부른다.
copy.deepcopy가 꼭 필요하다.state_dict()는 매개변수 텐서를 복사하지 않고 가리키기만 한다. 그대로 저장해 두면 학습이 이어지는 동안 값이 같이 바뀌어, 끝에 꺼내 보면 마지막 에폭의 값이 들어 있다.
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))TrueTrue곡선 모양별 진단
섹션 제목: “곡선 모양별 진단”| 곡선 모양 | 뜻 | 먼저 할 일 |
|---|---|---|
| 훈련·검증 손실이 둘 다 높고 천천히 내려간다 | 과소적합, 학습률이 작거나 에폭이 부족 | 학습률 키우기, 에폭 늘리기, Adam 시도, 모델 키우기 |
| 훈련 손실은 계속 내려가고 검증 손실은 바닥을 찍고 오른다 | 과적합 | 가장 낮았던 에폭 쓰기(조기 종료), 데이터 늘리기, 모델 줄이기, 드롭아웃·가중치 감쇠 |
손실이 크게 들쭉날쭉하거나 커지다 nan |
학습률 과다, 기울기 비우기 누락, 입력 스케일 문제 | zero_grad 확인, 학습률 낮추기, 입력 표준화 확인 |
| 처음부터 손실이 에서 움직이지 않는다 | 기울기가 흐르지 않거나 갱신이 안 됨(초기화·모양, 학습률 0, 옵티마이저에 매개변수 누락) | 10장 진단 순서(초기화·(N, 1)/(N,) 모양), .grad 값·학습률·옵티마이저에 넣은 매개변수 확인 |
| 검증 손실이 훈련 손실보다 처음부터 훨씬 낮다 | 드롭아웃 같은 훈련 전용 동작, 또는 분할·누수 문제 | 같은 시점·같은 모드로 쟀는지, 분할을 확인 |
11-8. 체크포인트 저장과 재로딩
섹션 제목: “11-8. 체크포인트 저장과 재로딩”state_dict 저장·재로딩
섹션 제목: “state_dict 저장·재로딩”모델의 상태는 model.state_dict()(이름 → 텐서 딕셔너리)로 꺼낸다. 학습하는 매개변수와, 배치 정규화의 누적 평균·분산처럼 학습하지 않지만 저장해야 하는 값(버퍼)이 함께 들어 있다. 옵티마이저도 state_dict()가 있다. Adam의 이동 평균 ·처럼 옵티마이저가 들고 있는 값이 여기 들어 있다. 이어서 학습하려면 둘 다 저장한다.
import osimport 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'] 5True [0.781, 0.967]- 새로 만든 모델은 구조만 같으면 된다.
load_state_dict가 이름이 같은 텐서끼리 값을 덮어쓴다. 이름이나 모양이 다르면 오류를 낸다. - 전처리 값도 함께 저장한다. 표준화한 데이터로 학습한 모델은 같은 평균·표준편차로 바꾼 입력에서만 맞게 동작한다. 09장이 전처리를
Pipeline에 넣어 함께 저장한 것과 같은 이유다. torch.load(..., weights_only=True)는 텐서·숫자·문자열·리스트·딕셔너리만 읽는다. 체크포인트 파일은 파이썬 객체를 담을 수 있어서, 출처를 모르는 파일을 제한 없이 읽으면 그 안의 코드가 실행될 수 있다. PyTorch 2.6부터 기본값이True이고, 이 자료는 뜻이 보이도록 적는다.- 모델 객체 전체(
torch.save(model))를 저장하는 방법도 있지만, 불러올 때 클래스 정의와 코드 위치가 같아야 해서 깨지기 쉽다.state_dict저장이 기본이다.
이어서 학습하기
섹션 제목: “이어서 학습하기”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- 이 예제에서는 모델·옵티마이저·섞는 순서를 모두 이어 주자 끊지 않은 학습과 비트 하나까지 같았다. 이것이 체크포인트가 제대로 됐는지 확인하는 방법이다. 드롭아웃처럼 다른 난수를 쓰는 층이 있으면 전역 난수 상태(
torch.get_rng_state())도, 학습률 스케줄을 쓰면 스케줄러의state_dict()도 함께 저장해야 같은 경로로 이어진다. - 옵티마이저 상태를 빼면 Adam은 ·가 0인 처음 상태로 돌아가 다른 경로로 학습한다. 이번에는 검증 손실이 우연히 조금 낮았지만, 문제는 좋고 나쁨이 아니라 재현이 깨졌다는 점이다. 오류는 나지 않으므로 모르고 지나가기 쉽다.
- 실제 학습에서는 에폭마다(또는 검증 손실이 가장 낮을 때) 체크포인트를 저장한다. 이 실험은 CPU에서 같은 순서로 계산해 정확히 같았다. GPU나 여러 스레드에서는 계산 순서가 달라 마지막 자리가 다를 수 있다.
11-9. 학습을 돕는 기법 미리 보기
섹션 제목: “11-9. 학습을 돕는 기법 미리 보기”이 절의 기법은 12장 이후에 실제로 쓴다. 여기서는 무엇을 하는지와, 훈련과 평가에서 동작이 다른 층이 있다는 점만 확인한다.
초기화
섹션 제목: “초기화”10장에서 가중치를 0이나 같은 값으로 시작하면 안 되고, 표준편차 정도의 난수로 시작한다고 했다. 활성화 함수에 맞춰 크기를 정하는 대표 방법이 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.06250.088 0.088드롭아웃과 배치 정규화: 훈련과 평가가 다르다
섹션 제목: “드롭아웃과 배치 정규화: 훈련과 평가가 다르다”드롭아웃(dropout)은 훈련 중 유닛을 확률 로 무작위로 꺼서(0으로) 특정 유닛에 기대지 못하게 하는 과적합 억제 기법이다. 배치 정규화(batch normalization)는 층의 출력을 특성마다 배치의 평균·표준편차로 표준화한 뒤, 학습하는 계수 와 절편 로 크기와 위치를 다시 맞춰 깊은 신경망의 학습을 안정시킨다(아래 출력은 처음 값 , 일 때다). 둘 다 훈련과 평가에서 동작이 다르다.
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- 드롭아웃은 훈련 때 원소마다 확률 0.5로 0을 만들고(이번에는 8개 중 5개), 남은 값을 배 해서 평균이 같도록 맞춘다. 끄는 개수는 매번 달라진다. 평가 때는 아무것도 끄지 않고 그대로 통과시킨다.
- 배치 정규화는 훈련 때 이번 배치의 평균(3)·표준편차로 표준화하고, 그 값을 조금씩 누적한 평균·분산(
running_mean·running_var)을 기억한다. 이때 표준화에는 으로 나눈 분산(여기서 3.5)을, 누적에는 로 나눈 분산(약 4.667)을 쓴다. 누적값은 0·1에서 시작해 배치마다 10%씩만 새 값 쪽으로 움직이므로, 한 번 학습한 지금은 평균 0.3으로 아직 멀다. 평가 때는 이 누적값으로 표준화하므로 같은 입력인데 출력이 훈련 때와 전혀 다르다. 학습이 충분히 진행되면 누적값이 데이터의 평균·분산에 가까워지고, 평가 출력은 배치 구성과 상관없이 같은 입력에 같은 값이 된다. - 그래서 평가 전에
model.eval(), 학습 전에model.train()을 부른다. 빼먹으면 평가 결과가 실행할 때마다 달라지거나(드롭아웃), 배치 구성에 따라 달라진다(배치 정규화).eval()은 기울기 기록을 끄지 않으므로torch.no_grad()도 함께 쓴다.
- 이 장의 작은 MLP에는 두 층이 없어서
train()/eval()이 결과를 바꾸지 않는다. 그래도 습관으로 늘 적는다.
학습률 스케줄
섹션 제목: “학습률 스케줄”학습 초반에는 크게, 후반에는 작게 움직이면 빠르면서도 안정하게 수렴하는 경우가 많다. 에폭에 따라 학습률을 바꾸는 것을 학습률 스케줄(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.025StepLR(opt, step_size=s, gamma=γ)는 scheduler.step()이 s번 불릴 때마다 학습률에 γ를 곱한다. scheduler.step()은 optimizer.step() 뒤, 보통 에폭 끝에 부른다. 코사인 모양으로 줄이는 CosineAnnealingLR, 검증 손실이 멈추면 줄이는 ReduceLROnPlateau 등이 있다. 어떤 스케줄이 좋은지는 문제마다 달라 검증 점수로 고른다.
11-10. 수학 상자: 모멘텀·Adam과 수치 정밀도
섹션 제목: “11-10. 수학 상자: 모멘텀·Adam과 수치 정밀도”모멘텀과 Adam의 식
섹션 제목: “모멘텀과 Adam의 식”스텝 에서 기울기를 라 하면(는 학습률, 곱·나눗셈·제곱근은 매개변수마다 원소별로 한다):
- 모멘텀(PyTorch 방식): , (). 기울기가 늘 로 같으면 는 로 다가가므로, 는 같은 방향으로 최대 10배 빠르게 움직이는 효과를 낸다.
- Adam: , , , , . 기본값 , , . 에서 시작하므로 초반의 ·는 0 쪽으로 치우친다. 로 나누는 것이 편향 보정이다. 첫 스텝에서는 , 이라 이동이 이다. 이 보다 훨씬 크면 기울기 크기와 상관없이 약 다.
식을 직접 계산해 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 * vprint("모멘텀:", 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) # Adamb1, b2, eps = 0.9, 0.999, 1e-8for 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(= )씩, 기울기 반대 방향으로 움직였다. 이동이 이고, 여기서는 이 보다 훨씬 커서 와 같기 때문이다(기울기가 정도로 아주 작으면 이동도 보다 작다). 그 뒤로는 기울기 부호가 자주 바뀐 매개변수일수록 이 상쇄되어 덜 움직인다. 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-38True False[1.6516362661361307e+38, inf]-inf -200.0eps(기계 엡실론, 약 )는 1과, float32로 표현할 수 있는 1 다음 수의 차이다. 1 근처에서는 이 간격보다 훨씬 작은 수를 더하면 반올림되어 사라진다. 은 float32에서 그냥 1이다. (Adam 식의 은 이것과 다른 값으로, 가 0일 때 0으로 나누지 않도록 분모에 더하는 작은 수다.)- float32로 표현할 수 있는 가장 큰 수는 약 이라 는
inf로 넘친다(overflow). 반대로 아주 작은 값은 0으로 사라진다(underflow). 이 된 것이 이것이다. - 를 그대로 계산하면 가 되지만, 식을 로 바꾸고 큰 수를 밖으로 빼서 계산하면(
logsigmoid) 정확히 −200이다.BCEWithLogitsLoss·CrossEntropyLoss가 점수를 받는 이유가 이것이다.
- 많은 신경망 학습에서 float32는 정밀도와 계산 비용 사이의 실용적인 선택이다. 다만 값의 범위와 계산 방식에 따라 중간 계산이 넘치는 등의 수치 문제가 생길 수 있으므로, 안정한 계산식과 알맞은 입력 스케일을 함께 쓴다. 10장처럼 수치 미분과 비교할 때는 float64로 계산했다. fp16·bf16 같은 더 짧은 형식은 부록 1(하드웨어)과 18장 양자화에서 다룬다.
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 |
확인 문제
섹션 제목: “확인 문제”10문항. 풀면 결과가 기록되고 복습 일정에 들어간다.
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. 공식 문서와 참고 자료”- 데이터셋과 데이터로더(PyTorch 튜토리얼): https://docs.pytorch.org/tutorials/beginner/basics/data_tutorial.html
- 최적화(학습 루프, PyTorch 튜토리얼): https://docs.pytorch.org/tutorials/beginner/basics/optimization_tutorial.html
- 모델 저장·불러오기(PyTorch 튜토리얼): https://docs.pytorch.org/tutorials/beginner/saving_loading_models.html
torch.utils.data(Dataset·DataLoader): https://docs.pytorch.org/docs/stable/data.htmltorch.optim(옵티마이저·학습률 스케줄): https://docs.pytorch.org/docs/stable/optim.htmltorch.optim.SGD(모멘텀 식): https://docs.pytorch.org/docs/stable/generated/torch.optim.SGD.htmltorch.optim.Adam(갱신 식): https://docs.pytorch.org/docs/stable/generated/torch.optim.Adam.htmlnn.BCEWithLogitsLoss: https://docs.pytorch.org/docs/stable/generated/torch.nn.BCEWithLogitsLoss.htmltorch.load(weights_only): https://docs.pytorch.org/docs/stable/generated/torch.load.htmlnn.Dropout: https://docs.pytorch.org/docs/stable/generated/torch.nn.Dropout.htmlnn.BatchNorm1d: https://docs.pytorch.org/docs/stable/generated/torch.nn.BatchNorm1d.html- 재현성(난수 고정, PyTorch 노트): https://docs.pytorch.org/docs/stable/notes/randomness.html
- Adam 원 논문(Kingma·Ba, 2014): https://arxiv.org/abs/1412.6980