자, 이제 여러분들만의 인공지능을 만들어 봅시다.

학습 목표 — 한 칸씩 밀린 정답

학습 자료를 토큰 번호로 바꾸면 긴 번호 줄이 됩니다. 여기서 13토큰짜리 구간을 잘라 앞 12개를 입력, 한 칸 밀린 뒤 12개를 정답으로 씁니다.

• 토큰이 [a, b, c, d] 라면 입력 [a, b, c] 의 정답은 [b, c, d] 입니다.
• 자리 1은 a 만 보고 b 를, 자리 2는 a·b 를 보고 c 를, 자리 3은 a·b·c 를 보고 d 를 맞힙니다.
• 인과 어텐션 덕분에 한 번의 forward 로 12가지 문제를 동시에 풉니다.

정답 표시를 사람이 붙이지 않아도 글 자체가 문제와 정답이 됩니다. 그래서 인터넷의 글을 그대로 학습 자료로 쓸 수 있습니다(자기 지도 학습). 다음 토큰을 잘 맞히려면 문법·문맥·형식·사실을 알아야 하므로, 이 단순한 목표가 언어 능력 전체를 끌어냅니다.

손실 — 교차 엔트로피(정답 확률의 음수 로그)

자리마다 모델이 정답 토큰에 준 확률을 p 라고 하면, 그 자리의 손실은 −log(p) 입니다. 구간의 손실은 12자리 손실의 평균입니다.

• p = 1 이면 손실 0: 정답을 확신했습니다.
• p = 0.5 면 0.693, p = 0.1 이면 2.303, p = 0.01 이면 4.605: 정답에 준 확률이 작을수록 손실이 가파르게 커집니다.
• 오답에 큰 확률을 주어도 직접 벌점을 받지는 않습니다. 확률의 합이 1이므로, 오답이 많이 가져가면 정답의 p 가 줄어 손실이 커집니다.

처음 손실은 미리 알 수 있습니다. 학습 전의 모델은 어휘 40개에 거의 같은 확률(1/40)을 주므로 손실이 −log(1/40) = ln 40 ≈ 3.689 입니다. train.py 가 처음 찍는 validation 3.7568 이 이 값과 거의 같으면 모델이 바르게 초기화된 것입니다. 어휘 50,257개인 GPT-2 라면 처음 손실은 약 10.8 입니다. 손실에 exp 를 씌운 값을 혼잡도(perplexity)라고 하는데, exp(3.689) = 40 처럼 "몇 개 중에서 고민하고 있는가"로 읽을 수 있습니다.

어휘가 수만 개인 모델의 손실은 대략 이렇게 읽습니다. 10 이상이면 무작위 수준, 5~7 이면 문법을, 3~5 면 형식을, 2~3 이면 뜻을 배우는 중이고, 2 아래로 내려가면 외우기(과적합)를 의심합니다. 어휘 수에 따라 출발점이 다르므로 XSLM 에서는 출발점 3.69 에서 얼마나 내려갔는지를 봅니다.

import math

for p in [1.0, 0.9, 0.5, 0.1, 0.01]:
    print('p =', p, ' loss =', round(0.0 - math.log(p), 4))
for vocab in [40, 50257]:
    print('guess evenly among', vocab, '->', round(math.log(vocab), 4))

cd ~/xslm
mkdir -p lab
micro lab/loss.py
python3 -m lab.loss

p = 1.0  loss = 0.0
p = 0.9  loss = 0.1054
p = 0.5  loss = 0.6931
p = 0.1  loss = 2.3026
p = 0.01  loss = 4.6052
guess evenly among 40 -> 3.6889
guess evenly among 50257 -> 10.8249

경사하강법과 학습률 — 기울기 반대 방향으로 조금씩

기울기는 "이 숫자를 조금 키우면 손실이 얼마나 늘어나는가"입니다. 손실을 줄이려면 기울기의 반대 방향으로 숫자를 옮깁니다.

• 새 값 = 옛 값 − 학습률 × 기울기

학습률(learning_rate)은 한 번에 얼마나 옮길지입니다. 아래 실험은 f(w) = (w − 3)² 의 가장 낮은 곳 w = 3 을 0에서 출발해 20걸음 찾아갑니다.

• 0.01: 너무 조심스러워 1.0 근처까지밖에 못 갑니다. 학습이 느립니다.
• 0.1: 2.97 까지 와서 거의 도착했습니다.
• 0.5: 이 함수에서는 한 걸음에 정확히 3에 닿습니다.
• 1.1: 너무 크게 뛰어 골짜기 반대편으로 넘어가기를 되풀이하다 −112 로 튀어 나갑니다(발산).

실제 모델은 숫자가 수천~수십억 개라 골짜기 모양을 알 수 없으므로 학습률을 실험으로 정합니다. XSLM 의 0.03 은 작은 모델이 튀지 않는 조심스러운 값입니다. 학습률을 바꾸면 settings.json 이 바뀌므로 새 체크포인트로 시작합니다.

# f(w) = (w - 3) ** 2 is smallest at w = 3. Its gradient is 2 * (w - 3).
for lr in [0.01, 0.1, 0.5, 1.1]:
    w = 0.0
    for step in range(20):
        w -= lr * 2 * (w - 3)
    print('lr', lr, '-> w =', round(w, 4))

cd ~/xslm
mkdir -p lab
micro lab/descent.py
python3 -m lab.descent

lr 0.01 -> w = 0.9972
lr 0.1 -> w = 2.9654
lr 0.5 -> w = 3.0
lr 1.1 -> w = -112.0128

학습 루프 한 바퀴 — 여섯 걸음

train.py 의 반복 한 번은 이 순서입니다.

• 구간 고르기: 학습 토큰 줄에서 무작위 시작점을 골라 13토큰을 자릅니다.
• 기울기 지우기: 모든 파라미터의 grad 를 0으로 만듭니다. 기울기는 += 로 쌓이므로 이전 반복의 값이 남으면 섞입니다. 이번 구간에 나오지 않는 토큰의 임베딩 줄은 계산 그래프에 없어 backward 가 건드리지 않으므로, 여기서 지우지 않으면 옛 기울기가 그대로 남습니다.
• 순전파: model.loss 가 forward 와 손실 계산을 합니다.
• 역전파: loss.backward() 로 1,248개 모두의 기울기를 구합니다.
• 갱신: 기울기 크기를 제한한 뒤 p.data −= 학습률 × 기울기 × 배율 로 모든 숫자를 옮깁니다.
• 저장·기록: 체크포인트를 저장하고 step 과 loss 를 찍습니다.

학습은 이 바퀴를 정한 횟수만큼 돕니다. 시작 전과 끝난 뒤에는 검증 자료의 첫 구간으로 손실을 재서 학습에 쓰지 않은 글에서도 나아졌는지 봅니다.

XSLM 은 자료를 몇 번 돌았는지(epoch) 대신 걸음 수(step)로 셉니다. 구간을 무작위로 뽑으므로 어떤 부분은 여러 번, 어떤 부분은 덜 뽑힙니다. 큰 모델도 대개 step 으로 셉니다.

기울기 자르기 — 한 번에 너무 멀리 가지 않게

가끔 어떤 구간에서 기울기가 갑자기 아주 커집니다. 그대로 갱신하면 숫자가 한 번에 멀리 튀어 지금까지의 학습을 망칩니다(기울기 폭발). 그래서 train.py 는 갱신 전에 기울기 전체의 길이를 잽니다.

• 길이 = √(모든 기울기의 제곱의 합)
• 배율 = min(1, 1 ÷ 길이)
• 길이가 1 이하면 배율 1로 그대로 쓰고, 1보다 크면 길이가 정확히 1이 되도록 모든 기울기를 같은 비율로 줄입니다.

방향은 그대로 두고 크기만 줄이는 것이 핵심입니다. PyTorch 에서는 clip_grad_norm_ 이 같은 일을 합니다(보통 최대 길이 1.0). 분모의 1e-8 은 기울기가 모두 0일 때 0으로 나누지 않으려는 작은 수입니다.

옵티마이저 — SGD 와 AdamW

기울기로 숫자를 고치는 규칙을 옵티마이저라고 합니다.

• SGD(XSLM): 새 값 = 옛 값 − 학습률 × 기울기. 지금 기울기만 보고 기억하는 것이 없습니다. 그래서 체크포인트에 옵티마이저 상태를 저장할 필요가 없습니다.
• 모멘텀: 지난 기울기들의 흐름(속도)을 기억해, 같은 방향이면 더 빨리, 흔들리면 덜 움직입니다.
• Adam·AdamW: 숫자마다 기울기의 평균과 크기의 평균을 기억해 숫자마다 알맞은 걸음 크기를 스스로 정합니다. AdamW 는 숫자가 너무 커지지 않게 조금씩 줄이는 가중치 감쇠(weight decay)를 더합니다. 큰 언어 모델 학습의 표준이고, 학습률은 보통 0.0003 정도입니다.

Adam 은 파라미터마다 숫자 두 개를 더 기억하므로, 이어 학습하려면 체크포인트에 그 상태(optimizer state)도 저장해야 합니다. 그래서 PyTorch 체크포인트에는 보통 모델 가중치와 함께 옵티마이저 상태가 들어갑니다. 학습 중 메모리도 가중치만 둘 때의 몇 배가 듭니다.

배치 — 여러 구간의 평균 기울기

XSLM 은 한 번에 구간 하나(배치 크기 1)로 기울기를 구합니다. 구간마다 내용이 달라 기울기가 크게 흔들리므로 손실도 오르락내리락합니다.

큰 모델은 여러 구간을 한 번에 계산해 평균 기울기를 씁니다. 예를 들어 256토큰 구간 16개(배치 크기 16)면 한 번의 갱신에 4,096토큰을 봅니다.

• 평균을 내면 흔들림이 줄어 갱신 방향이 안정됩니다.
• GPU 는 여러 구간을 동시에 계산하므로 배치를 키워도 시간이 거의 늘지 않습니다.
• 대신 메모리를 그만큼 씁니다. 메모리가 모자라면(OOM) 배치나 구간 길이를 줄입니다.

메모리가 부족할 때는 작은 배치로 여러 번 backward 해 기울기를 모은 뒤 한 번 갱신하는 기울기 누적(gradient accumulation)을 씁니다. XSLM 의 backward 는 시작할 때 그래프 안의 기울기를 0으로 지우므로 이 방법을 그대로는 쓸 수 없습니다.

과적합과 과소적합 — 학습 손실과 검증 손실을 같이 본다

두 손실을 함께 보면 모델의 상태를 알 수 있습니다.

• 둘 다 내려간다: 잘 배우고 있습니다.
• 학습 손실만 내려가고 검증 손실은 오른다: 과적합입니다. 학습 자료를 외워서 처음 보는 글에는 오히려 나빠집니다.
• 둘 다 잘 안 내려간다: 과소적합입니다. 모델이 너무 작거나, 학습이 부족하거나, 학습률이 맞지 않습니다.

XSLM 으로 직접 재 보았습니다(데스크톱 Python, 기본 자료). 기본 학습률 0.03 으로 1,500번 학습하면 검증 손실이 3.76 에서 3.23 으로 내려갔습니다. 학습률 0.1 로 3,000번 학습하면 학습 손실은 구간에 따라 1.3 까지 내려갔지만 검증 손실은 4.42 로 올랐고, 0.3 이면 5.28 까지 올랐습니다. 학습 문장 12쌍을 외우기는 쉬워도, 처음 보는 3쌍에 통할 규칙을 배울 만큼 자료가 많지 않기 때문입니다.

과적합을 줄이는 가장 확실한 방법은 자료를 늘리는 것이고, 모델 줄이기·dropout·학습 일찍 멈추기(검증 손실이 가장 낮았던 체크포인트 쓰기)도 씁니다. 과소적합이면 모델을 키우거나 학습을 더 합니다.

체크포인트 — 무엇을 왜 저장하나

checkpoints/model.json 은 학습을 멈췄다가 정확히 이어 하기 위한 모든 것을 담습니다.

• weights: 9개 행렬의 숫자 1,248개.
• step: 지금까지 한 갱신 횟수.
• random: 난수 생성기의 상태. 이어 학습할 때 구간 순서를 끊김 없이 이어 갑니다.
• settings·tokenizer: 모델의 크기와 번호 규칙. generate.py 와 runner.py 는 이것만 읽고 모델을 다시 만듭니다.
• data_hash: 학습·검증 자료의 SHA-256 지문. 자료가 바뀌었는지 알아냅니다.

그래서 3번씩 두 번 나눠 학습한 결과와 6번을 한 번에 학습한 결과가 숫자 하나까지 같습니다. 직접 확인해 보세요. --steps 3 을 두 번 실행한 model.json 을 다른 이름으로 옮겨 두고, 새로 --steps 6 을 한 번 실행한 결과와 비교합니다.

저장은 안전하게 합니다. model.tmp 에 먼저 다 쓴 뒤 os.replace 로 이름을 바꿉니다. 이름 바꾸기는 한순간에 일어나므로, 쓰는 도중에 Ctrl+C 를 누르거나 전원이 꺼져도 model.json 은 이전 완성본과 새 완성본 둘 중 하나입니다. 반쯤 쓴 깨진 파일이 남지 않습니다.

PyTorch 는 torch.save 로 가중치·옵티마이저 상태·step·설정을 이진 파일(.pt)에 저장합니다. XSLM 은 걸음마다 저장하지만, 큰 모델은 저장에도 시간이 들어 수백 걸음마다 평가하며 저장합니다.

재현성 — seed 로 같은 결과를 다시 얻는다

컴퓨터의 난수는 seed(씨앗 번호)에서 정해진 규칙으로 만든 수열입니다. seed 가 같으면 언제나 같은 수열이 나옵니다. XSLM 은 seed 7 로 두 곳을 정합니다.

• 가중치의 처음 값(model.py 의 random.Random(seed)).
• 학습 구간의 순서(train.py 의 rng).

그래서 같은 자료·같은 설정이면 누가 어디서 실행해도 같은 학습 과정을 밟습니다. 학습률 하나만 바꿔 비교하려면 나머지 무작위성이 같아야 하므로 재현성은 실험의 기본입니다. seed 를 바꾸면 다른 처음 값에서 출발해 결과가 달라집니다. 운 좋은 seed 하나에 기댄 결론은 믿기 어려우므로, 중요한 비교는 seed 를 몇 개 바꿔 되풀이합니다.

다만 Python 이나 운영체제의 수학 라이브러리가 다르면 소수점 끝자리가 달라질 수 있어, 아주 긴 학습에서는 숫자가 조금씩 벌어질 수 있습니다.

학습 기록 읽기 — 숫자가 말해 주는 것

train.py 는 이런 줄을 찍습니다.

• parameters: 1248 resume: 0 — 파라미터 수와 이어서 시작한 걸음. 처음이면 0입니다.
• validation: 3.7568 — 학습 전 검증 손실. ln(어휘 수)와 비슷해야 합니다.
• step: 1 loss: 3.6875 — 걸음마다 그 구간의 학습 손실.
• validation: … — 학습 뒤 검증 손실.
• saved: checkpoints/model.json — 저장한 곳.

걸음마다의 loss 는 구간이 달라 오르내립니다. 숫자 하나가 아니라 여러 걸음의 흐름을 봅니다. 기본 20번이면 3.7 근처에서 조금 움직이는 정도이고, 수백~수천 번이면 뚜렷하게 내려갑니다.

flush=True 는 출력을 바로 화면에 내보내라는 뜻입니다. 이것이 없으면 Python 이 출력을 모았다가 한꺼번에 보여 주어 학습이 멈춘 것처럼 보이고, nohup 으로 파일에 쓸 때도 늦게 기록됩니다.

학습이 잘 안 될 때 — 증상별 점검

증상으로 원인을 좁힙니다.

• 손실이 3.7 근처에서 거의 그대로: 학습 횟수가 적습니다. --steps 를 늘리거나, 새 체크포인트로 학습률을 조금 키워 봅니다.
• 손실이 크게 튀거나 커지기만 함: 학습률이 너무 큽니다. 줄여서 새로 시작합니다.
• ValueError: math domain error 또는 nan: 확률이 0이 되어 log(0)을 계산했거나 숫자가 발산했습니다. 학습률을 낮추고 기울기 자르기가 들어 있는지 봅니다.
• AssertionError: changed settings/tokenizer 또는 changed data: 체크포인트와 지금 설정·자료가 다릅니다. 옛 체크포인트를 옮기고 새로 시작합니다.
• AssertionError: add more text: 학습이나 검증 토큰이 13개보다 적습니다. raw.txt 에 줄을 더합니다.
• 너무 느림: width·context 를 줄이면 빨라지지만 새 체크포인트가 필요합니다. 먼저 --steps 를 작게 나눠 실행합니다.
• 학습은 됐는데 Runner 의 답이 그대로: Runner 는 켤 때 한 번만 읽습니다. 껐다 켭니다.