잘 학습시키는 기술: 초기화, 정규화, 옵티마이저

학습이 안 될 때 가장 먼저 해 볼 두 가지 점검, 층을 지나며 신호가 사라지거나 터지는 이유와 He 초기화, 깊은 신경망을 살리는 배치 정규화, 너무 작거나 커서 망가지는 학습률, SGD와 모멘텀과 Adam의 차이를 실험으로 비교해요. 정답의 28%가 틀린 데이터에서 신경망이 잡음까지 외워 가는 과정과, 드롭아웃이 그 속도를 늦추는 모습도 직접 확인해요.

고급강의 4 / 6약 14분

신경망을 학습시키다 보면 이상한 일이 자주 생겨요. 손실이 전혀 안 줄거나, 갑자기 NaN이 뜨거나, 학습 데이터는 100% 맞히는데 시험 성적은 형편없거나요. 이번 강의에서는 이런 문제를 다스리는 기술들을 실험으로 비교해요. 원리를 알면 남의 코드에 왜 그 설정이 들어 있는지 읽히고, 내 모델이 망가졌을 때 어디부터 볼지 알게 돼요.

모든 실험은 손글씨 숫자 데이터로 해요. 실험마다 모델과 학습을 반복해서 만들 수 있게 함수 두 개를 준비해 둘게요.

import math
import numpy as np
import torch
from torch import nn
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_digits(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=0)
sc = StandardScaler().fit(X_tr)
Xtr = torch.tensor(sc.transform(X_tr), dtype=torch.float32)
Xte = torch.tensor(sc.transform(X_te), dtype=torch.float32)
ytr, yte = torch.tensor(y_tr), torch.tensor(y_te)
loss_fn = nn.CrossEntropyLoss()

def make(depth=2, width=128, bn=False, dropout=0.0, he=False):
    """은닉층 depth개짜리 신경망. 배치 정규화, 드롭아웃, He 초기화를 골라 넣어요."""
    layers, d = [], 64
    for _ in range(depth):
        lin = nn.Linear(d, width)
        if he:
            nn.init.kaiming_normal_(lin.weight, nonlinearity="relu")
            nn.init.zeros_(lin.bias)
        layers.append(lin)
        if bn:
            layers.append(nn.BatchNorm1d(width))
        layers.append(nn.ReLU())
        if dropout:
            layers.append(nn.Dropout(dropout))
        d = width
    layers.append(nn.Linear(d, 10))
    return nn.Sequential(*layers)

def run(model, opt, epochs, log, y_train=ytr, sched=None):
    """64개씩 미니배치로 학습하고, log에 적은 에포크마다 (에포크, 학습 손실, 학습 정확도, 시험 정확도)를 기록해요."""
    g = torch.Generator().manual_seed(0)
    out = []
    for ep in range(1, epochs + 1):
        model.train()
        perm = torch.randperm(len(Xtr), generator=g)
        for s in range(0, len(Xtr), 64):
            bi = perm[s:s + 64]
            opt.zero_grad()
            loss_fn(model(Xtr[bi]), y_train[bi]).backward()
            opt.step()
        if sched:
            sched.step()
        if ep in log:
            model.eval()
            with torch.no_grad():
                tl = loss_fn(model(Xtr), y_train).item()
                tr = (model(Xtr).argmax(1) == y_train).float().mean().item()
                te = (model(Xte).argmax(1) == yte).float().mean().item()
            out.append((ep, round(tl, 3), round(tr, 3), round(te, 3)))
    return out

학습이 안 될 때 가장 먼저 할 두 가지

본격적인 기술에 앞서, 경험 많은 사람들이 늘 하는 점검이 있어요.

torch.manual_seed(0)
m = make()
with torch.no_grad():
    print(round(loss_fn(m(Xtr), ytr).item(), 3), round(math.log(10), 3))   # 2.311 2.303

opt = torch.optim.Adam(m.parameters(), lr=1e-3)
xb, yb = Xtr[:32], ytr[:32]                    # 딱 32장만
for step in range(1, 201):
    opt.zero_grad()
    l = loss_fn(m(xb), yb)
    l.backward()
    opt.step()
    if step in (1, 50, 200):
        print(step, round(l.item(), 4))         # 2.323 → 0.0583 → 0.0013
  1. 처음 손실이 예상과 맞는가. 학습 전의 모델은 숫자 10개 중 아무거나 고르는 수준이어야 하니, 교차 엔트로피는 −ln⁡(1/10)=ln⁡10≈2.303-\ln(1/10) = \ln 10 \approx 2.303 근처여야 해요. 2.311이 나왔어요. 처음 손실이 이보다 훨씬 크면 초기화나 마지막 층이 잘못됐다는 신호예요.
  2. 아주 작은 데이터를 외울 수 있는가. 32장쯤은 거의 완벽하게 외워야 정상이에요. 200번 만에 손실이 0.0013이 됐어요. 이걸 못 하면 데이터, 손실, 학습 루프 어딘가에 버그가 있는 거예요. 큰 데이터로 몇 시간 돌려 보기 전에 1분 안에 버그를 잡을 수 있어요.

초기화: 신호가 사라지거나 터지지 않게

층 20개짜리 신경망에 무작위 입력을 넣고, 층을 지날 때마다 신호(활성값)의 크기가 어떻게 변하는지 볼게요. 가중치를 어떤 크기의 난수로 시작하느냐가 핵심이에요.

def act_std(act, std_fn, depth=20, width=256):
    torch.manual_seed(0)
    x = torch.randn(1000, width)
    out = []
    for _ in range(depth):
        x = x @ (torch.randn(width, width) * std_fn(width))
        x = torch.tanh(x) if act == "tanh" else torch.relu(x)
        out.append(x.std().item())
    return out

for act, name, f in [("tanh", "0.01", lambda n: 0.01), ("tanh", "1.0", lambda n: 1.0),
                     ("tanh", "xavier", lambda n: math.sqrt(1 / n)), ("relu", "xavier", lambda n: math.sqrt(1 / n)),
                     ("relu", "he", lambda n: math.sqrt(2 / n))]:
    s = act_std(act, f)
    print(act, name, f"{s[0]:.3g}", f"{s[9]:.3g}", f"{s[19]:.3g}")
활성화가중치 표준편차1층10층20층
tanh0.010.1560.0000000110−1610^{-16} (사라짐)
tanh1.00.9750.9740.974 (포화)
tanh1/n\sqrt{1/n} (Xavier)0.6280.2260.155
ReLU1/n\sqrt{1/n} (Xavier)0.5840.0180.0006 (사라짐)
ReLU2/n\sqrt{2/n} (He)0.8260.5790.635 (유지)
  • 너무 작으면 층을 지날 때마다 신호가 줄어들어 20층에서는 0이 돼요. 역전파 강의의 기울기 소실과 같은 이야기예요.
  • 너무 크면 tanh가 -1이나 1에 달라붙어(포화) 기울기가 0이 돼요. 신호는 크지만 배울 수가 없어요.
  • 입력 nn개를 더하면 분산이 nn배가 되니, 가중치 분산을 1/n1/n로 맞추면 크기가 유지돼요(Xavier 초기화). ReLU는 절반을 0으로 지우니 2배를 더 줘서 2/n2/n로 맞춰요(He 초기화). 표를 보면 ReLU에 He를 쓴 경우만 20층까지 신호가 살아 있어요.

실제 학습으로 확인해 볼게요. 은닉층 10개짜리 깊은 신경망이에요.

for name, kw in [("기본", {}), ("He", {"he": True}), ("배치정규화", {"bn": True})]:
    torch.manual_seed(0)
    m = make(depth=10, **kw)
    print(name, run(m, torch.optim.Adam(m.parameters(), lr=1e-3), 10, (1, 3, 10)))
설정1에포크 시험 정확도3에포크10에포크
PyTorch 기본 초기화0.0820.4780.869
He 초기화0.7220.9220.942
기본 초기화 + 배치 정규화0.5530.8870.942

기본 초기화는 첫 에포크에 찍는 수준(8%)에서 출발해 한참 뒤처져요. PyTorch의 기본값은 ReLU를 깊게 쌓는 경우에는 조금 작아서, 층이 깊어질수록 신호가 약해지거든요. He 초기화는 첫 에포크부터 72%예요. 초기화 한 줄이 이만큼 차이를 내요.

배치 정규화: 층마다 다시 맞추기

초기화로 시작은 맞춰도, 학습하면서 가중치가 바뀌면 층마다 신호의 분포가 계속 출렁여요. 배치 정규화는 미니배치 안에서 각 뉴런의 값을 평균 0, 표준편차 1로 다시 맞춘 뒤, 학습 가능한 배율 γ\gamma와 이동 β\beta를 곱하고 더해요.

z^=z−μ배치σ배치2+ϵ,출력=γz^+β\hat{z} = \frac{z - \mu_{\text{배치}}}{\sqrt{\sigma^2_{\text{배치}} + \epsilon}}, \qquad \text{출력} = \gamma \hat{z} + \beta

위 표의 마지막 줄처럼, 초기화가 나빠도 배치 정규화를 넣으면 깊은 신경망이 잘 학습돼요. 더 큰 학습률을 견디게 해 주는 효과도 있어요.

주의할 점이 있어요. 학습할 때는 그 배치의 평균과 분산을 쓰지만, 평가할 때는 배치가 하나뿐일 수도 있으니 학습 중에 쌓아 둔 이동 평균을 써요. PyTorch 강의에서 model.eval()을 꼭 쓰라고 한 이유가 이거예요. 그리고 트랜스포머처럼 배치 크기가 들쭉날쭉한 모델에서는 배치 대신 샘플 하나 안에서 정규화하는 층 정규화(LayerNorm)를 써요. LLM 트랙에서 다시 만나요.

학습률: 가장 중요한 하나

설정값을 딱 하나만 고를 수 있다면 학습률이에요. 순수한 SGD로 학습률만 바꿔 10에포크를 돌려 볼게요.

for lr in [0.001, 0.01, 0.1, 1.0, 3.0]:
    torch.manual_seed(0)
    m = make()
    print(lr, run(m, torch.optim.SGD(m.parameters(), lr=lr), 10, (10,)))
학습률10에포크 뒤 학습 손실시험 정확도
0.0012.2830.211
0.011.9580.771
0.10.0930.969
1.00.0020.978
3.0NaN (발산)0.082

너무 작으면 거의 움직이지 못하고(21%), 너무 크면 손실이 터져서 NaN이 돼요. 최적화 강의의 골짜기 그림 그대로예요. 좋은 값은 대개 터지기 직전보다 조금 작은 곳에 있어요. 그래서 학습률은 0.001, 0.01, 0.1처럼 10배씩 바꿔 가며 찾는 게 요령이에요.

학습률 스케줄

처음에는 크게 움직이고 끝으로 갈수록 조금씩 움직이면 좋겠죠. 학습률을 코사인 곡선처럼 서서히 줄이는 코사인 스케줄을 써 볼게요.

for use in [False, True]:
    torch.manual_seed(0)
    m = make()
    opt = torch.optim.SGD(m.parameters(), lr=0.1, momentum=0.9)
    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=20) if use else None
    print(use, run(m, opt, 20, (20,), sched=sched))    # 고정 0.973, 코사인 0.976

이 작은 문제에서는 차이가 0.3%p로 작지만, 큰 모델에서는 스케줄이 성능을 꽤 좌우해요. 큰 언어 모델은 처음 몇천 걸음 동안 학습률을 0에서 천천히 올리는 워밍업을 한 뒤 코사인으로 줄이는 방식을 많이 써요. 처음부터 큰 학습률을 쓰면 아직 엉망인 가중치가 크게 흔들려 학습이 망가질 수 있거든요.

옵티마이저: SGD, 모멘텀, Adam

for name in ["SGD", "모멘텀", "Adam"]:
    torch.manual_seed(0)
    m = make()
    opt = {"SGD": lambda p: torch.optim.SGD(p, lr=0.01),
           "모멘텀": lambda p: torch.optim.SGD(p, lr=0.01, momentum=0.9),
           "Adam": lambda p: torch.optim.Adam(p, lr=1e-3)}[name](m.parameters())
    print(name, run(m, opt, 10, (1, 5, 10)))
옵티마이저1에포크5에포크10에포크
SGD (학습률 0.01)0.2070.5890.771
SGD + 모멘텀 0.90.6870.9160.960
Adam (학습률 0.001)0.8070.9600.969
  • 모멘텀은 지난 이동 방향을 기억해서 같은 방향으로는 가속하고, 지그재그는 상쇄해요. 같은 학습률인데 SGD보다 훨씬 빨라요.
  • Adam은 모멘텀에 더해, 가중치마다 기울기 크기의 이력을 보고 걸음 크기를 따로 조절해요. 설정을 크게 신경 쓰지 않아도 잘 되는 편이라 첫 선택으로 무난해요.
  • AdamW는 Adam에 가중치 감쇠를 제대로(기울기와 분리해서) 넣은 버전이에요. 트랜스포머와 LLM 학습의 사실상 표준이에요.

최적화 강의에서 손으로 구현했던 모멘텀과 Adam이 그대로 PyTorch 한 줄이 된 거예요.

과적합 다스리기: 정답이 틀린 데이터에서

과적합의 무서움을 극단적으로 보여 주는 실험을 해 볼게요. 학습 데이터의 정답 중 약 28%를 일부러 틀리게 바꿔요. 실제 데이터에서도 사람이 붙인 정답이 꽤 틀려 있는 경우가 흔해요.

g = torch.Generator().manual_seed(0)
noisy = ytr.clone()
flip = torch.rand(len(noisy), generator=g) < 0.3
noisy[flip] = torch.randint(0, 10, (int(flip.sum()),), generator=g)   # 무작위 정답으로 바꿔치기
print(int((noisy != ytr).sum()), len(noisy))                           # 384 1347

for name, kw, wd in [("그대로", {}, 0.0), ("가중치 감쇠", {}, 0.1), ("드롭아웃", {"dropout": 0.5}, 0.0), ("둘 다", {"dropout": 0.5}, 0.1)]:
    torch.manual_seed(0)
    m = make(width=512, **kw)
    opt = torch.optim.AdamW(m.parameters(), lr=1e-3, weight_decay=wd)
    print(name, run(m, opt, 200, (20, 200), y_train=noisy))
설정20에포크: 틀린 정답까지 맞힌 비율20에포크: 시험 정확도200에포크: 틀린 정답까지 맞힌 비율200에포크: 시험 정확도
그대로0.9250.8071.0000.793
가중치 감쇠 0.10.9150.8110.9960.798
드롭아웃 0.50.7420.9270.9990.849
둘 다0.7400.9240.9960.838

이 표에 딥러닝의 중요한 성질이 담겨 있어요.

  • 신경망은 결국 틀린 정답까지 100% 외워요. 정답의 28%가 엉터리인데도 학습 데이터를 다 맞히게 되죠. 그리고 외울수록 시험 성적은 떨어져요.
  • 드롭아웃은 학습할 때마다 뉴런의 절반을 무작위로 꺼서, 특정 뉴런이 특정 샘플을 외우기 어렵게 만들어요. 20에포크에서 드롭아웃 모델이 학습 데이터를 맞힌 비율은 0.742로, 원래 맞는 정답의 비율(약 72%)과 거의 같아요. 진짜 패턴만 배우고 잡음은 아직 안 외운 상태예요. 그래서 시험 정확도가 92.7%예요.
  • 하지만 오래 학습하면 드롭아웃도 결국 외워요(200에포크에 84.9%). 그래서 조기 종료와 함께 써야 해요. 신경망 강의에서는 조기 종료가 오히려 손해였는데, 잡음이 많은 데이터에서는 이렇게 결정적이에요.
  • 이 실험에서 가중치 감쇠는 효과가 작았어요. 어떤 정규화가 얼마나 효과적인지는 데이터와 모델마다 달라서, 늘 검증으로 확인해요.

그 밖의 무기들

기술하는 일다시 만나는 곳
데이터 증강사진을 뒤집고 자르고 돌려 학습 데이터를 부풀려요CNN 강의
기울기 자르기기울기가 너무 커지면 크기를 잘라 폭주를 막아요RNN 강의
혼합 정밀도16비트 숫자로 계산해 속도와 메모리를 아껴요LLM 트랙
체크포인트검증 성적이 가장 좋았던 순간의 가중치를 저장해 둬요모든 학습

문제가 생겼을 때 점검 순서

  1. 처음 손실이 이론값(분류면 ln⁡\ln 클래스 수) 근처인가?
  2. 작은 배치 하나를 외울 수 있는가?
  3. 학습률을 10배씩 바꿔 봤는가?
  4. 입력을 표준화했고, 초기화가 활성화 함수에 맞는가?
  5. 학습 손실과 검증 손실을 함께 그려 봤는가? (같이 안 줄면 과소적합, 학습만 줄면 과적합)
  6. 그다음에야 모델 구조를 바꾼다.

실습

  1. 초기화 실험에서 ReLU에 표준편차 2/n\sqrt{2/n}의 1.5배를 쓰면 20층에서 신호가 어떻게 되나요?
  2. 은닉층 10개짜리 신경망에 He 초기화와 배치 정규화를 함께 넣으면 더 나아지나요?
  3. 잡음 실험에서 드롭아웃 비율을 0.2, 0.5, 0.8로 바꿔 20에포크의 시험 정확도를 비교하세요.
  4. 학습률 1.0인 SGD에 모멘텀 0.9를 더하면 어떻게 되나요? 이유를 설명해 보세요.

자주 하는 실수

  • 학습률을 처음에 정한 값 그대로 두기. 가장 먼저 바꿔 볼 설정이에요.
  • ReLU에 tanh용 초기화 쓰기. 깊어질수록 신호가 사라져요.
  • 평가할 때 model.eval() 빼먹기. 드롭아웃과 배치 정규화가 학습 방식으로 동작해요.
  • 검증 성적이 가장 좋을 때를 저장하지 않기. 마지막 에포크가 최고라는 보장이 없어요.
  • 기술을 한꺼번에 여러 개 바꾸기. 무엇이 효과였는지 알 수 없어요.

점검 문제

  1. 클래스가 100개인 분류 모델의 학습 전 손실은 대략 얼마여야 하나요?
  2. ReLU 신경망에 Xavier 초기화를 쓰면 깊어질수록 신호가 왜 줄어드나요?
  3. 배치 정규화가 학습할 때와 평가할 때 다르게 동작하는 부분은?
  4. 학습률이 너무 크면 어떤 일이 생기나요?
  5. 정답에 잡음이 많은 데이터에서 드롭아웃과 조기 종료를 함께 쓰는 이유는?

정답

  1. ln⁡100≈4.6\ln 100 \approx 4.6이에요.
  2. ReLU가 입력의 절반가량을 0으로 지워서, 분산을 1/n1/n로 맞추는 Xavier로는 층마다 신호가 절반씩 줄어요. 그래서 2배를 보정한 He 초기화를 써요.
  3. 학습할 때는 그 미니배치의 평균과 분산을 쓰고, 평가할 때는 학습 중에 쌓은 이동 평균을 써요.
  4. 손실이 줄지 않고 출렁이다 터져서 NaN이 될 수 있어요.
  5. 드롭아웃이 잡음을 외우는 속도를 늦추지만 결국은 외우기 때문에, 진짜 패턴만 배운 시점에 조기 종료로 멈춰야 해요.

다음 강의

지금까지는 숫자 사진을 픽셀 64개짜리 목록으로 펼쳐서 다뤘어요. 그러면 "이웃한 픽셀끼리 관계가 있다"는 사진의 구조를 버리게 돼요. 다음 강의에서는 사진의 구조를 그대로 살리는 **CNN(합성곱 신경망)**을 배워요. 적은 가중치로 훨씬 잘 보는 비결을 확인해요.