다섯 단계 해부

모든 PyTorch training step 이 같은 다섯 줄

이 리듬 외워. 경력 동안 만 번 쓸 거고, 절대 안 변해:

optimizer.zero_grad() — 이전 step 누적 gradient 비우기.
output = model(batch) — forward pass. autograd graph 짓기.
loss = criterion(output, target) — scalar loss 계산.
loss.backward() — backward pass. 모든 leaf 의 .grad 채우기.
optimizer.step() — gradient 로 update rule 적용.

순서 비협상. forward 는 loss 전, loss 는 backward 전, backward 는 step 전, step 은 gradient 존재 후, zero_grad 는 모든 거 전 (또는 이전 iteration 끝). 섞으면 silent 버그.

다섯 단계 wrap 하는 것

epoch 위 outer loop (dataset 한 번 full pass).
DataLoader 의 batch 위 inner loop.
각 epoch 위에 model.train() (또는 loop 전 한 번, training 이 default mode).
주기적 evaluation pass (model.eval() + torch.inference_mode() 사용).

그게 전체 skeleton. 다른 모든 거 — scheduler, gradient clipping, mixed precision, logging, checkpointing — 가 이 다섯 단계 위 layer.

Code

최소 완전 training loop·python

import torch
import torch.nn as nn

model = nn.Linear(10, 2)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

for epoch in range(num_epochs):
    model.train()
    for x_batch, y_batch in train_loader:
        # 1. clear gradients
        optimizer.zero_grad()

        # 2. forward
        out = model(x_batch)

        # 3. loss
        loss = criterion(out, y_batch)

        # 4. backward
        loss.backward()

        # 5. step
        optimizer.step()

흔한 추가: clipping, scheduling, eval·python

import torch
import torch.nn as nn

# Setup
model = nn.Linear(10, 2)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
criterion = nn.MSELoss()

for epoch in range(50):
    model.train()
    for x, y in train_loader:
        optimizer.zero_grad()
        loss = criterion(model(x), y)
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)  # ← optional but common
        optimizer.step()

    scheduler.step()                    # ← per-epoch scheduler

    # Quick eval pass
    model.eval()
    with torch.inference_mode():
        val_loss = sum(criterion(model(x), y).item() for x, y in val_loader) / len(val_loader)
    print(f"epoch {epoch}: val_loss = {val_loss:.4f}")

'안전 unit test' — 내 loop 가 실제로 train?·python

import torch
import torch.nn as nn

# Tiny sanity test: can we overfit a single batch?
model = nn.Linear(10, 2)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-2)
criterion = nn.MSELoss()

x = torch.randn(8, 10)
y = torch.randn(8, 2)

losses = []
for step in range(200):
    optimizer.zero_grad()
    loss = criterion(model(x), y)
    loss.backward()
    optimizer.step()
    losses.append(loss.item())

print(f"loss start: {losses[0]:.6f}, end: {losses[-1]:.6f}")
# loss start: 1.234567, end: 0.000012
# If end loss isn't << start loss, something is wrong with your loop.
# This 'overfit one batch' test catches 80% of training-loop bugs.

모든 PyTorch training step 이 같은 다섯 줄

다섯 단계 wrap 하는 것

Code

External links

Exercise

Progress

댓글 0