학습 실패 진단

단계적 접근

큰 모델, 큰 데이터, 긴 학습에서는 실패 하나를 확인하는 데 몇 시간이 걸린다. 진단의 기본 전략은 실패를 가장 작고 빠른 설정에서 재현하는 것이고, 그 반대 방향으로 학습을 쌓아 올리는 것이다. 각 단계는 통과 기준이 분명하고, 앞 단계를 통과해야 다음 단계로 간다.

1. 데이터를 확인한다. 학습 코드를 돌리기 전에 입력과 label을 직접 본다. 값의 범위, 단위, 결측, 상수 특징, class 비율, train과 test 사이의 중복, 그리고 몇 개 표본을 사람이 읽어 label이 맞는지.
2. 단순한 baseline을 돌린다. 평균 예측, 최다 class 예측(16.1장), 선형 모델(16.2장). 신경망이 이것보다 나쁘면 신경망 이전의 문제다. 선형 모델조차 우연 수준이면 입력과 label의 관계부터 의심한다.
3. 초기 손실을 확인한다. 학습 전 손실이 이론값과 맞는지 본다. $C$개 class 분류에서 모든 class에 같은 확률을 주면 손실은 $\ln C$이고, 회귀에서 0을 예측하면 손실은 목표값의 제곱 평균이다.
4. batch 하나에 과적합한다. 표본 수십 개로 수백 step 학습해 손실이 0 근처로 가는지 본다. 모델·손실·역전파·업데이트의 연결이 맞는지 보는 가장 싼 검사다.
5. 규모를 키운다. 전체 데이터로 짧게 학습해 train 손실이 baseline보다 내려가는지, 그다음 검증 곡선, 그다음 하이퍼파라미터 탐색 순서로 간다.

3과 4를 코드로 본다. class 5개, 표본 16개짜리 batch 하나에서 정상 모델, 끝에 softmax를 하나 더 붙인 모델, label을 무작위로 섞은 경우를 비교한다.

import math

import torch
from torch import nn

torch.manual_seed(0)
x = torch.randn(16, 10)                                   # (B, D) batch 하나
y = torch.randint(0, 5, (16,))                            # (B,) class 5개

def overfit(head, labels, steps=300):
    torch.manual_seed(1)
    model = nn.Sequential(nn.Linear(10, 64), nn.ReLU(), nn.Linear(64, 5), *head)
    opt = torch.optim.Adam(model.parameters(), lr=1e-2)
    for step in range(steps + 1):
        loss = nn.functional.cross_entropy(model(x), labels)
        first = loss.item() if step == 0 else first
        opt.zero_grad()
        loss.backward()
        opt.step()
    return first, loss.item()

print(f"기대 초기 손실 ln 5 = {math.log(5):.3f}")
for name, head, labels in [("정상", [], y), ("softmax 두 번", [nn.Softmax(dim=1)], y),
                           ("label 무작위", [], y[torch.randperm(16)])]:
    first, last = overfit(head, labels)
    print(f"{name:12s} 초기 손실 {first:.3f}   300 step 뒤 {last:.4f}")

기대 초기 손실 ln 5 = 1.609
정상           초기 손실 1.663   300 step 뒤 0.0003
softmax 두 번  초기 손실 1.617   300 step 뒤 0.9674
label 무작위    초기 손실 1.583   300 step 뒤 0.0004

세 경우 모두 초기 손실은 $\ln 5 = 1.609$ 근처라 3단계는 아무것도 걸러내지 못했다. 4단계는 softmax 중복을 잡았다. cross_entropy는 내부에서 log-softmax를 계산하므로, 이미 확률인 값에 softmax를 다시 적용하면 출력이 좁은 범위에 갇혀 손실이 0.97 아래로 내려가지 못한다. 그러나 무작위 label도 0.0004까지 내려갔다. 신경망은 16개 정도는 아무 label이나 외운다. batch 하나 과적합은 "학습 경로가 연결되어 있는가"를 보는 검사이지, "데이터가 맞는가"를 보는 검사가 아니다. 1, 2단계가 따로 있는 이유다.

1단계의 점검은 몇 줄로 자동화할 수 있다. 실제 데이터에서 흔한 문제를 일부러 심은 표를 점검해 본다.

import numpy as np

rng = np.random.default_rng(2)
X = rng.normal([300.0, 1.0, 0.5, 7.0], [10.0, 0.1, 0.2, 0.0], size=(500, 4))   # (N, 4)
X[rng.choice(500, 3, replace=False), 1] = np.nan          # 결측 3개
y = (X[:, 0] > 300).astype(int)
y[:40] = 1                                                # 앞쪽 40개 label이 잘못 붙음
train, test = X[:400], np.vstack([X[400:490], X[:10]])    # test에 train 표본 10개가 섞임

print("특징별 평균  ", np.round(np.nanmean(X, 0), 3))
print("특징별 표준편차", np.round(np.nanstd(X, 0), 3))
print("NaN 개수     ", np.isnan(X).sum(0))
print("상수 특징     ", np.where(np.nanstd(X, 0) == 0)[0])
print("label 비율    ", np.bincount(y) / len(y))
dup = {r.tobytes() for r in train} & {r.tobytes() for r in test}
print("train과 test에 함께 있는 행", len(dup))
print("앞 50개와 나머지의 label 1 비율", y[:50].mean().round(3), y[50:].mean().round(3))

특징별 평균   [299.266   1.001   0.489   7.   ]
특징별 표준편차 [10.292  0.095  0.199  0.   ]
NaN 개수      [0 3 0 0]
상수 특징      [3]
label 비율     [0.494 0.506]
train과 test에 함께 있는 행 10
앞 50개와 나머지의 label 1 비율 0.92 0.46

평균과 표준편차에서 첫 특징이 다른 특징보다 수백 배 큰 스케일(온도 K)이라 정규화가 필요하다는 것, 두 번째 특징에 결측이 3개 있다는 것, 네 번째 특징은 상수라 정보가 없다는 것이 보인다. train과 test에 같은 행이 10개 있고(15.4장), 데이터 앞쪽의 label 비율이 나머지와 크게 다르다. 마지막 것은 파일을 만든 과정(예: 특정 장비나 날짜의 측정이 앞에 모여 있음)이나 label을 붙이는 과정의 오류를 의심하게 한다. 어느 것도 학습 코드의 오류 메시지로는 드러나지 않는다.

증상별 진단

곡선에 나타난 증상에서 출발해 가능한 원인을 좁히는 표다. 원인 열은 확인하기 쉬운 것부터 적었다.

이상하게 좋은 성능은 특별히 다룰 가치가 있다. 성능이 나쁠 때는 누구나 코드를 의심하지만, 좋을 때는 의심하지 않는다. 과거 연구가 70%에 머문 문제에서 99%가 나왔다면, 축하하기 전에 누수를 찾는다. 가장 흔한 것은 같은 대상에서 나온 표본이 train과 검증에 나뉘어 들어간 것이고, 그다음이 정답에서 계산된 특징이나 측정 순서처럼 정답과 우연히 연결된 정보다.

흔한 원인

증상 표의 원인들은 실제로 몇 가지 범주로 모인다. 각 범주에 대해 확인 방법을 함께 적는다.

• 데이터·label 오류. 입력과 label이 어긋남(섞을 때 한쪽만 섞음, 정렬 기준이 다른 두 파일을 합침), label의 단위·부호·인코딩 오류, 결측을 0으로 채움. → 표본을 직접 보고, 선형 baseline의 성능을 확인한다.
• 정규화 누락. 스케일이 수백 배 다른 특징을 그대로 넣거나, 목표값을 표준화하지 않음. 초기 출력이 커져 초기 손실이 이론값에서 벗어나고, 학습률 하나로는 모든 방향에 맞출 수 없다(10.3장). → 특징별 평균·표준편차, 초기 손실.
• 학습률. 너무 크면 흔들리거나 발산하고, 너무 작으면 아주 천천히 내려간다. → 업데이트 비율, 학습률 탐색(10.4장).
• 초기화. 가중치의 스케일이 층을 지날수록 활성값을 포화시키거나 0으로 줄인다(17.1장). → 층별 활성값 통계(아래 도구 절).
• mask. padding 위치가 손실이나 attention에 들어감, mask의 0과 1이 뒤바뀜, 미래 시점을 가리지 않음(누수). → 손실을 mask 위치만으로 다시 계산해 비교, 미래를 가린 입력으로 예측이 달라지는지 확인.
• eval 모드. 평가에서 model.eval() 누락, 평가 뒤 model.train() 누락(17.6장). → 같은 입력을 두 번 평가해 같은 값이 나오는지.
• 손실 집계. batch 평균의 평균, sum과 mean의 혼동(학습률이 batch 크기만큼 바뀐 효과), gradient accumulation에서 나누기 누락(10.4장). → batch 크기를 바꿔도 같은 값이 나오는지.
• 학습 루프 순서. zero_grad 누락으로 gradient 누적, scheduler 호출 주기 오류(17.5장). → 학습률 0으로 같은 batch를 두 번 통과시켜 gradient가 같은지.

도구

증상을 원인으로 좁히는 데 쓰는 도구들이다. 모두 "어디서 처음 이상해졌는가"를 찾는 도구라는 공통점이 있다.

gradient norm 추적. 17.8장에서처럼 step마다 global gradient norm을 기록하고, 층별 norm은 더 긴 주기로 기록한다. 발산은 손실보다 gradient norm에서 먼저 보이고, 특정 층의 norm만 0에 붙어 있으면 그 층 아래에서 gradient가 사라지고 있다. 기록이 길면 사람이 다 볼 수 없으므로, 최근 정상값의 중앙값보다 몇 배 큰 step을 자동으로 표시해 둔다(연습문제).

비유한 값(NaN·inf)이 처음 생긴 위치. 손실이 NaN이 되면 그 NaN이 어디서 처음 생겼는지 찾아야 한다. forward에서 생긴 것은 모듈마다 출력을 검사하는 forward hook(17.3장)으로, backward에서만 생긴 것은 PyTorch의 anomaly detection으로 찾는다. 아래 예는 첫 입력 특징(농도)의 로그를 취하는 모델에 농도 0인 표본 하나를 넣는다.

import warnings

class LogFeature(nn.Module):
    """농도 같은 양수 특징의 로그를 취한다(0이 들어오면 -inf)."""
    def forward(self, x):
        return torch.cat([torch.log(x[:, :1]), x[:, 1:]], dim=1)

torch.manual_seed(0)
model = nn.Sequential(LogFeature(), nn.Linear(3, 8), nn.Tanh(), nn.Linear(8, 1))
x = torch.rand(6, 3)                                      # (B, 3)
x[4, 0] = 0.0                                             # 농도 0인 표본 하나
first_bad = []
def find_nonfinite(module, inputs, output):
    if not first_bad and not torch.isfinite(output).all():
        rows = (~torch.isfinite(output)).any(1).nonzero().flatten().tolist()
        first_bad.append(f"{module.__class__.__name__} (표본 {rows})")
for m in model:
    m.register_forward_hook(find_nonfinite)
loss = model(x).pow(2).mean()
loss.backward()
print(f"손실 {loss.item():.4f}, 유한한가 {torch.isfinite(loss).item()}")
print("처음 비유한 출력을 낸 모듈:", first_bad[0])
print("NaN gradient:", [n for n, p in model.named_parameters() if not torch.isfinite(p.grad).all()])

w = torch.zeros(3, requires_grad=True)                    # backward에서만 생기는 NaN
with warnings.catch_warnings(record=True) as caught, torch.autograd.set_detect_anomaly(True):
    try:
        torch.sqrt((w ** 2).sum()).backward()             # |w|를 w = 0에서 미분
    except RuntimeError as e:
        print("anomaly mode:", str(e))

손실 0.1516, 유한한가 True
처음 비유한 출력을 낸 모듈: LogFeature (표본 [4])
NaN gradient: ['1.weight']
anomaly mode: Function 'PowBackward0' returned nan values in its 0th output.

이 예는 NaN 진단에서 흔히 놓치는 점을 보여 준다.

• 손실은 유한했다. $\log 0 = -\infty$가 선형층을 지나 $\pm\infty$가 되었지만, tanh가 이를 $\pm 1$로 눌러 손실은 0.1516이 되었다. 손실만 감시했다면 문제를 몰랐을 것이다.
• gradient는 NaN이 되었다. 포화된 tanh의 미분은 0이고, 첫 선형층 가중치의 gradient는 그 0과 입력 $-\infty$의 곱이라 NaN이다. 한 번의 업데이트로 그 가중치 전체가 NaN이 된다.
• forward hook은 원인의 위치(LogFeature, 표본 4)를 바로 짚었다. 데이터 쪽의 0을 고치거나, $\log(x + \epsilon)$처럼 정의역을 보호하는 처리가 필요하다.
• anomaly mode는 backward 중 NaN을 처음 반환한 연산(PowBackward0)에서 멈춘다. $\lVert \mathbf{w} \rVert = \sqrt{\sum w_i^2}$를 $\mathbf{w} = 0$에서 미분하면 sqrt의 미분이 무한대가 되고, 그 뒤의 곱에서 NaN이 생긴다. anomaly mode는 그 연산을 만든 forward 코드의 위치도 함께 경고로 출력한다. 모든 연산을 검사하므로 학습이 크게 느려진다. 실패를 재현한 짧은 실행에서만 켠다.

활성값 통계. 층마다 활성값의 평균·표준편차, 포화 비율(tanh라면 $\lvert a \rvert > 0.99$, ReLU라면 0인 비율)을 본다. 초기화 스케일이 깊은 층에서 만드는 차이를 tanh 10층으로 본다(초기화의 원리는 17.1장).

rng = np.random.default_rng(0)
x0 = rng.normal(size=(512, 256))                          # (N, D) 표준화된 입력
for name, std in [("std 1", 1.0), ("std 1/sqrt(D)", 1 / np.sqrt(256)), ("std 0.01", 0.01)]:
    a, rows = x0, []
    for layer in range(1, 11):
        W = rng.normal(0, std, size=(256, 256))           # (D, D)
        a = np.tanh(a @ W)                                # (N, D)
        if layer in (1, 5, 10):
            rows.append(f"층 {layer:2d}: std {a.std():.3g}, 포화 {np.mean(np.abs(a) > 0.99):.0%}")
    print(f"{name:14s} | " + " | ".join(rows))

std 1          | 층  1: std 0.975, 포화 87% | 층  5: std 0.974, 포화 87% | 층 10: std 0.974, 포화 86%
std 1/sqrt(D)  | 층  1: std 0.629, 포화 1% | 층  5: std 0.323, 포화 0% | 층 10: std 0.226, 포화 0%
std 0.01       | 층  1: std 0.157, 포화 0% | 층  5: std 0.000104, 포화 0% | 층 10: std 1.1e-08, 포화 0%

표준편차 1로 초기화하면 첫 층부터 활성값의 87%가 포화된다. 포화된 tanh의 미분은 거의 0이라 gradient가 흐르지 않는다. 0.01로 초기화하면 층을 지날 때마다 활성값이 줄어 10층에서 $10^{-8}$ 수준이 되고, 깊은 층의 신호와 gradient가 사라진다. $1/\sqrt{D}$로 초기화하면 둘 다 피한다(층을 지나며 조금씩 줄어드는 것은 tanh가 분산을 줄이기 때문이며, 17.1장의 Xavier 초기화가 이를 다룬다). 학습이 처음부터 안 될 때 층별 통계 한 줄이 "모델 구조가 문제"라는 잘못된 결론을 막는다.

디버깅 기록

진단은 실험이다. 기록하지 않은 실험은 반복된다. 디버깅을 시작하면 다음 형식으로 한 줄씩 남긴다.

이 형식에는 지켜야 할 규칙이 두 개 들어 있다.

• 한 번에 하나만 바꾼다. 학습률, 정규화, 초기화를 한꺼번에 바꿔 학습이 되면, 무엇이 필요했는지 모른다. 다음에 같은 증상이 다른 원인으로 나타나면 그때 바꾼 세 가지를 모두 다시 시도하게 된다. 작은 설정에서 하나씩 시험하는 비용은 크지 않다.
• 예측을 먼저 쓴다. 결과를 본 뒤에 "그럴 줄 알았다"고 쓰면 모든 결과가 가설을 지지하는 것처럼 보인다. 결과보다 예측을 먼저 적으면, 예측이 틀린 실험이 가장 많은 정보를 준다.

원인을 확정하면 그 버그를 잡는 테스트를 남긴다(6.6장). 실습의 체크리스트가 그 예다. 디버깅 기록은 연구 노트(23.7장)의 일부로 보관하면, 몇 달 뒤 같은 증상을 만났을 때 검색할 수 있다.