사전 학습, 스케일링 법칙, 정렬

인터넷 규모의 글로 하는 사전 학습에 드는 계산량을 6ND 공식으로 어림하고, 친칠라 논문의 손실 공식으로 같은 계산량에서 모델 크기와 데이터 양을 어떻게 나눌지 최적화해 봐요. 다음 토큰 예측기가 대화 상대가 되기까지의 지시 학습과 사람 피드백 강화 학습을 따라가며, 선호 비교만으로 보상 모델을 학습하고 KL 벌점이 보상 해킹을 막는 원리를 계산으로 확인해요.

고급강의 4 / 9약 12분

앞 강의의 미니 GPT와 실제 대형 언어 모델의 차이는 크게 두 가지예요. 하나는 규모예요. 수천억 개의 파라미터를 수조 개의 토큰으로 학습해요. 다른 하나는 정렬이에요. 다음 토큰을 잘 맞히는 것만으로는 "질문에 도움이 되게 답하는 대화 상대"가 되지 않아서, 추가 학습으로 행동을 다듬어요. 이번 강의에서는 이 두 단계를 숫자와 함께 따라가요.

사전 학습: 인터넷을 읽는 단계

사전 학습은 웹 문서, 책, 백과사전, 논문, 코드 같은 엄청난 양의 글로 다음 토큰 맞히기를 하는 단계예요. 미니 GPT와 목표는 같고 규모만 달라요. 데이터 준비에도 많은 공이 들어요.

  • 걸러내기: 스팸, 광고 뭉치, 깨진 글, 유해한 글을 걸러요.
  • 중복 제거: 같은 글이 수없이 반복되면 모델이 그걸 통째로 외우고 계산도 낭비돼요. 시험 문제가 학습 데이터에 섞여 들어가면 점수가 부풀려지는데, 머신러닝 트랙 평가 강의의 누수와 같은 문제예요.
  • 섞는 비율: 코드를 얼마나, 어떤 언어를 얼마나 넣느냐가 모델의 능력을 좌우해요.

사전 학습을 마친 모델을 기반 모델이라고 불러요. 기반 모델은 글을 "이어 쓰는" 데 능숙하지만, 질문에 답하는 법은 따로 배우지 않았어요. "프랑스의 수도는?"을 넣으면 "독일의 수도는? 이탈리아의 수도는?"처럼 시험지를 이어 쓸 수도 있어요. 인터넷에는 그런 글이 많으니까요.

계산량 어림하기

트랜스포머 학습에 드는 계산량(부동소수점 연산 횟수)은 대략 이렇게 어림해요.

C≈6ND(N:파라미터 수,  D:학습 토큰 수)C \approx 6ND \quad (N: \text{파라미터 수}, \; D: \text{학습 토큰 수})

토큰 하나를 처리할 때 순전파에 파라미터당 약 2번, 역전파에 약 4번의 연산이 들기 때문이에요. 1,750억 파라미터를 3,000억 토큰으로 학습한 GPT-3로 계산해 볼게요.

import math
import numpy as np

N, D = 175e9, 300e9
C = 6 * N * D
print(f"{C:.2e}")                                   # 3.15e+23
gpu = 1e14                                          # GPU 한 대가 실제로 내는 속도를 초당 100조 번으로 가정
days = C / gpu / 86400
print(round(days), round(days / 1000, 1))           # 36458 36.5

약 3×10233 \times 10^{23}번의 연산이에요. 초당 100조 번 계산하는 GPU 한 대로는 3만 6천 일, 약 100년이 걸리고, 1,000대를 동시에 써도 한 달이 넘어요. 대형 모델 학습에 수천 대의 GPU와 막대한 비용이 드는 이유예요.

스케일링 법칙: 크게, 그런데 어떻게?

2020년 연구들은 언어 모델의 손실이 파라미터 수, 데이터 양, 계산량에 따라 거듭제곱 법칙으로 매끄럽게 줄어든다는 것을 보여 줬어요. 규모를 키우면 성능이 예측 가능하게 좋아진다는 이 발견이 거대 모델 경쟁의 출발점이 됐어요.

그런데 계산량이 정해져 있다면, 그걸 모델을 키우는 데 쓸까요, 데이터를 늘리는 데 쓸까요? 2022년 딥마인드의 친칠라 논문은 손실을 이렇게 맞췄어요.

L(N,D)=E+ANα+BDβL(N, D) = E + \frac{A}{N^{\alpha}} + \frac{B}{D^{\beta}}

EE는 데이터 자체의 예측 불가능성(앞 강의의 손실 바닥), 둘째 항은 모델이 작아서 생기는 손실, 셋째 항은 데이터가 부족해서 생기는 손실이에요. 논문의 한 방법으로 맞춘 값(E=1.69E = 1.69, A=406.4A = 406.4, B=410.7B = 410.7, α=0.34\alpha = 0.34, β=0.28\beta = 0.28)으로 계산해 볼게요.

E, A, B, alpha, beta = 1.69, 406.4, 410.7, 0.34, 0.28

def loss(N, D):
    return E + A / N ** alpha + B / D ** beta

print(round(loss(70e9, 1.4e12), 3), f"{6 * 70e9 * 1.4e12:.2e}")    # 1.937 5.88e+23 (친칠라)
print(round(loss(280e9, 300e9), 3), f"{6 * 280e9 * 300e9:.2e}")    # 1.993 5.04e+23 (고퍼)
모델파라미터학습 토큰계산량공식으로 본 손실
고퍼2,800억3,000억5.0×10235.0 \times 10^{23}1.993
친칠라700억1조 4천억5.9×10235.9 \times 10^{23}1.937

비슷한 계산량인데, 4분의 1 크기의 모델에 데이터를 4.7배 넣은 친칠라가 더 낮은 손실을 내요. 실제로도 친칠라는 고퍼보다 여러 시험에서 좋은 성적을 냈어요. 그전까지의 큰 모델들은 크기에 비해 데이터를 너무 적게 먹은 셈이었어요.

계산량이 정해졌을 때의 최적 배분

미적분 트랙의 최적화로 직접 풀어 볼게요. C=6NDC = 6ND로 묶여 있으니 NN을 정하면 DD가 정해지고, 손실이 가장 낮은 NN을 찾으면 돼요.

def best_split(C):
    Ns = np.logspace(7, 13, 20001)        # 파라미터 1천만에서 10조까지 촘촘히
    Ds = C / (6 * Ns)
    L = loss(Ns, Ds)
    i = L.argmin()
    return Ns[i], Ds[i], L[i]

for C in [1e21, 1e23, 1e25]:
    n, d, l = best_split(C)
    print(f"{C:.0e} {n:.3g} {d:.3g} {d / n:.0f} {l:.3f}")
계산량최적 파라미터최적 토큰토큰 ÷ 파라미터손실
102110^{21}18억914억502.329
102310^{23}146억1조 1천억782.005
102510^{25}1,170억14조 3천억1221.845

계산량을 100배 늘리면 최적의 모델 크기는 약 8배, 데이터는 약 12.5배 늘어요. 모델과 데이터를 함께 키워야 한다는 게 핵심 결론이에요.

솔직하게 짚어 둘 점이 있어요. 친칠라 논문에서 가장 널리 인용되는 어림값은 "파라미터 하나당 약 20토큰"인데, 위 공식으로 계산하면 50에서 120이 나와요. 논문은 세 가지 방법으로 최적 배분을 추정했는데, 앞의 두 방법은 약 20을 냈고 위 공식은 세 번째 방법의 결과예요. 2024년의 한 재현 연구는 이 세 번째 방법의 맞춤 값에 문제가 있다고 지적했고, 데이터를 다시 맞춘 결과는 앞의 두 방법과 잘 맞았어요. 그러니 위 표는 계산하는 방법을 익히는 용도로 보고, 비율 자체를 외우지는 마세요. 법칙의 방향(함께 키우기)은 튼튼하지만, 정확한 비율은 맞추는 방식에 민감하다는 것이 정직한 요약이에요. 게다가 실무에서는 학습이 끝난 뒤 사용할 때의 비용도 중요해서, 일부러 작은 모델을 "최적"보다 훨씬 많은 토큰으로 학습시키는 경우가 많아요. 작은 모델은 서비스 비용이 싸니까요. 2024년에 공개된 한 80억 파라미터 모델은 15조 개가 넘는 토큰으로 학습했어요.

규모가 가져온 것

규모가 커지면서 맥락 속 학습(프롬프트 강의의 퓨샷처럼 예시 몇 개만 보고 새 과제를 해내는 능력)이 크게 좋아졌어요. 일부 능력은 일정 규모를 넘으면 갑자기 나타나는 것처럼 보여서 "창발"이라고 불렸는데, 평가 지표를 정답/오답 대신 연속적인 점수로 바꾸면 사실은 매끄럽게 좋아지는 경우가 많다는 반론도 있어요. 평가를 어떻게 하느냐가 결론을 바꾸는, 머신러닝 트랙 평가 강의의 교훈이 여기서도 나와요.

정렬: 이어 쓰기 기계를 대화 상대로

기반 모델을 "도움이 되고, 정직하고, 해롭지 않은" 대화 상대로 다듬는 과정을 정렬이라고 불러요. 대표적인 단계는 이래요.

1단계: 지시 학습

사람이 쓴 좋은 질문과 답의 예시 수만 개로 추가 학습해요. 지시를 따르고, 대화 형식으로 답하는 법을 배워요. 학습 방식은 사전 학습과 똑같이 다음 토큰 맞히기인데, 데이터가 "모범 대화"로 바뀐 거예요. 이 단계를 지도 미세 조정(SFT)이라고 해요.

2단계: 사람의 선호로 보상 모델 학습

좋은 답을 사람이 직접 쓰는 건 비싸지만, 두 답 중 어느 쪽이 나은지 고르는 건 훨씬 쉬워요. 그래서 모델이 만든 답 두 개를 보여 주고 사람이 더 나은 쪽을 고른 비교 데이터를 모아요. 그리고 답마다 점수 rr을 매기는 보상 모델을 학습해요. 답 ii가 답 jj보다 선호될 확률을 이렇게 둬요(브래들리 테리 모형).

P(i≻j)=σ(ri−rj)P(i \succ j) = \sigma(r_i - r_j)

머신러닝 트랙의 로지스틱 회귀 그대로예요. 점수 차이를 시그모이드에 넣은 거죠. 진짜 품질이 다른 답 5개에 대해, 사람들이 300번 비교한 데이터를 만들어 학습해 볼게요. 사람들도 가끔 실수하도록 확률적으로 고르게 했어요.

rng = np.random.default_rng(0)
true_q = np.array([2.0, 1.0, 0.5, 0.0, -1.5])          # 답 5개의 진짜 품질 (아무도 모름)
pairs = []
for _ in range(300):
    i, j = rng.choice(5, 2, replace=False)
    p_i = 1 / (1 + np.exp(-(true_q[i] - true_q[j])))   # 품질 차이가 클수록 확실하게 골라요
    pairs.append((i, j) if rng.random() < p_i else (j, i))   # (이긴 쪽, 진 쪽)
pairs = np.array(pairs)

r = np.zeros(5)                                          # 배울 점수
for step in range(2000):
    p = 1 / (1 + np.exp(-(r[pairs[:, 0]] - r[pairs[:, 1]])))
    g = np.zeros(5)
    np.add.at(g, pairs[:, 0], -(1 - p))                  # 이긴 쪽 점수는 올리고
    np.add.at(g, pairs[:, 1], (1 - p))                   # 진 쪽 점수는 내려요
    r -= 0.05 * g / len(pairs)
    r -= r.mean()                                        # 점수는 차이만 의미 있어서 평균을 0으로
print(r.round(2), (true_q - true_q.mean()).round(2))
print(list(np.argsort(-r)) == list(np.argsort(-true_q)))
print(round(1 / (1 + math.exp(-(r[0] - r[4]))), 3))       # 답 1이 답 5를 이길 확률
답진짜 품질 (평균 0으로 맞춤)학습한 점수
11.61.41
20.60.76
30.10.27
4-0.4-0.47
5-1.9-1.97

비교 결과만 보고 진짜 품질의 순서를 정확히 되찾았고, 값도 꽤 가까워요. 이제 처음 보는 대결도 예측할 수 있어요. 답 1이 답 5를 이길 확률은 σ(1.41+1.97)≈0.967\sigma(1.41 + 1.97) \approx 0.967이에요. 실제 보상 모델은 답 5개 대신 어떤 글이든 받아 점수를 내는 신경망(대개 언어 모델에 점수 출력층을 붙인 것)이에요.

3단계: 보상을 높이도록 학습하되, 너무 멀리 가지 않게

이제 언어 모델이 보상 모델의 점수가 높은 답을 내도록 강화 학습해요(보상으로 배우는 강화 학습은 AI 엔지니어링 트랙에서 자세히 다뤄요). 이 전체 과정을 사람 피드백 강화 학습(RLHF)이라고 해요. 여기서 아주 중요한 장치가 있어요. 보상만 좇으면 보상 모델의 허점을 파고드는 이상한 답으로 쏠릴 수 있어요. 그래서 원래 모델에서 너무 멀어지지 않도록 정보 이론 강의의 KL 발산으로 벌점을 줘요.

최대화할 것=Ep[r]−β DKL(p ∥ q)\text{최대화할 것} = \mathbb{E}_{p}[r] - \beta \, D_{KL}(p \,\|\, q)

qq는 원래 모델의 답 분포, pp는 학습 중인 모델의 분포예요. 이 식을 최대로 하는 분포는 p∝q er/βp \propto q \, e^{r/\beta}라는 깔끔한 모양이 돼요. 답이 네 종류뿐인 장난감으로 β\beta의 효과를 볼게요. 넷째 답은 원래 모델이 거의 안 쓰는데 보상 모델이 이상하게 높은 점수(3.0)를 주는 답이에요. 보상 모델의 허점일 수 있죠.

q = np.array([0.4, 0.3, 0.2, 0.1])          # 원래 모델의 답 분포
rew = np.array([1.0, 1.2, 0.5, 3.0])        # 보상 모델 점수 (넷째 답은 허점일 수 있어요)
for b in [0.1, 0.5, 2.0]:
    p = q * np.exp(rew / b)
    p /= p.sum()
    print(b, p.round(3), round(float((p * np.log(p / q)).sum()), 3), round(float(p @ rew), 3))
β\beta학습된 답 분포원래 모델과의 KL평균 보상
0.10, 0, 0, 1.02.3033.00
0.50.063, 0.070, 0.012, 0.8561.5862.72
2.00.345, 0.286, 0.134, 0.2350.0821.46

벌점이 약하면(β=0.1\beta = 0.1) 모델은 넷째 답만 내도록 쏠려요. 보상은 최고지만, 그 답이 정말 좋은 답인지 보상 모델의 착각인지는 알 수 없어요. 이렇게 측정 지표를 높이는 데만 몰두하다 진짜 목표에서 벗어나는 것을 보상 해킹이라고 해요. "지표가 목표가 되면 더 이상 좋은 지표가 아니다"라는 굿하트의 법칙 그대로예요. 벌점을 키우면(β=2.0\beta = 2.0) 원래 모델의 성격을 지키면서 보상이 높은 쪽으로 조금만 옮겨 가요.

최근의 변형들

  • DPO(직접 선호 최적화, 2023): 보상 모델과 강화 학습을 따로 두지 않고, 선호 비교 데이터로 언어 모델을 직접 학습해요. 위의 p∝qer/βp \propto q e^{r/\beta} 관계를 거꾸로 이용한 방법이라 더 간단하고 안정적이에요.
  • AI 피드백: 사람 대신 AI가 원칙 목록(헌법)에 따라 답을 비교하고 고치게 해서 피드백을 대량으로 만들어요. 앤트로픽의 "헌법적 AI"(2022)가 대표적이에요.
  • 추론 모델: 정답을 확인할 수 있는 수학이나 코딩 문제에서, 맞는 답에 보상을 주는 강화 학습으로 긴 추론 과정을 스스로 익히게 하는 방식이 최근 크게 발전했어요.

정렬이 풀지 못한 숙제

  • 환각: 그럴듯하게 틀린 말을 해요. 사전 학습은 "그럴듯한 다음 말"을 배우는 과정이라 근본적으로 어려운 문제예요.
  • 아첨: 사람 평가자가 듣기 좋은 답을 선호하면, 모델이 사용자의 틀린 말에도 맞장구치는 경향이 생길 수 있어요.
  • 과도한 거절: 안전을 너무 강하게 학습하면 멀쩡한 요청까지 거절해요.

이 숙제들은 LLM 평가와 안전성 강의에서 측정하고 다루는 법을 배워요.

실습

  1. 6ND 공식으로, 70억 파라미터 모델을 2조 토큰으로 학습하는 계산량과 GPU 1,000대로 걸리는 날수를 어림해 보세요.
  2. 친칠라 공식에서 EE를 1.69 대신 0으로 두면 최적 배분이 바뀌나요? 이유를 생각해 보세요.
  3. 선호 비교 실험에서 비교 횟수를 30번, 3,000번으로 바꿔 학습한 점수가 진짜 품질에 얼마나 가까워지는지 보세요.
  4. KL 벌점 실험에서 넷째 답의 보상을 3.0 대신 1.3으로 바꾸면, β=0.1\beta = 0.1일 때 분포가 어떻게 되나요?

자주 하는 실수

  • 크기만 보고 모델 성능을 짐작하기. 학습한 데이터 양과 질이 크기만큼 중요해요.
  • 스케일링 법칙의 숫자를 절대적인 상수로 믿기. 방향은 튼튼하지만 정확한 값은 맞추는 방식과 데이터에 따라 달라요.
  • 보상 모델 점수를 진짜 품질로 착각하기. 보상 모델도 틀리고, 그 허점을 파고들 수 있어요.
  • 기반 모델에 대화하듯 질문하기. 기반 모델은 이어 쓰기 기계라, 질문보다 "이어 쓸 글의 앞부분"을 줘야 원하는 결과가 나와요.

점검 문제

  1. 파라미터 100억 개를 토큰 2,000억 개로 학습하는 계산량은?
  2. 친칠라가 더 큰 고퍼보다 좋은 성능을 낸 이유는?
  3. 보상 모델을 학습할 때 사람에게 답을 직접 쓰게 하지 않고 두 답을 비교하게 하는 이유는?
  4. 브래들리 테리 모형에서 두 답의 점수 차이가 0이면 한쪽이 선호될 확률은?
  5. RLHF에서 KL 벌점을 두는 이유는?

정답

  1. 6×1010×2×1011=1.2×10226 \times 10^{10} \times 2 \times 10^{11} = 1.2 \times 10^{22}번이에요.
  2. 비슷한 계산량을 모델 크기보다 데이터 양에 더 써서, 크기와 데이터의 균형이 더 좋았기 때문이에요.
  3. 좋은 답을 직접 쓰기보다 둘 중 나은 쪽을 고르는 게 훨씬 쉽고 빠르고 일관적이기 때문이에요.
  4. σ(0)=0.5\sigma(0) = 0.5, 반반이에요.
  5. 보상만 좇다 보상 모델의 허점을 파고드는 이상한 답으로 쏠리지 않도록, 원래 모델에서 너무 멀어지는 것을 막기 위해서예요.

다음 강의

정렬까지 마친 모델도 우리 회사의 문서나 어제 나온 소식은 몰라요. 다음 강의에서는 필요한 자료를 찾아 맥락에 넣어 주는 RAG를 직접 만들어 봐요. 문서를 조각내고, 임베딩으로 검색하고, 출처와 함께 답하게 하는 전 과정을 따라가요.