Chapter 07

대규모 언어 모델

ChatGPT, Claude, Llama 같은 대규모 언어 모델(LLM)은 놀랍도록 단순한 목표 하나로 학습된다. "지금까지의 글을 보고 다음 토큰을 맞혀라." 이 장에서는 그 목표를 확률로 정확히 적고, 글자 수를 세는 n-gram 모델에서 출발해 브라우저 안에서 작은 신경망 언어 모델을 직접 학습시켜 본다. 그다음 수천억 파라미터·수조 토큰 규모로 키울 때 필요한 계산량, 모델 크기와 데이터의 최적 배분을 알려 주는 스케일링 법칙, 그리고 '글을 이어 쓰는 기계'를 '말을 알아듣는 조수'로 바꾸는 SFT·RLHF·DPO까지 따라간다.

언어 모델을 조건부 확률 $P(x_t \mid x_{\lt t})$의 곱으로 정의하고, 교차 엔트로피와 퍼플렉시티를 계산할 수 있다.
n-gram 모델의 카운트 추정, 희소성 문제, 스무딩과 백오프를 설명할 수 있다.
임베딩 → 은닉층 → 소프트맥스로 이루어진 신경망 언어 모델을 역전파와 Adam으로 학습시키는 과정을 이해하고, 과적합을 손실 곡선에서 읽는다.
학습 계산량 $C \approx 6ND$로 GPU-시간과 학습 일수를 추정할 수 있다.
Chinchilla 스케일링 법칙에서 계산 최적 배분과 '과학습(overtraining)' 경향의 이유를 설명할 수 있다.
사전학습 → SFT → 선호 학습(RLHF/PPO, DPO) 파이프라인과 DPO 손실의 의미를 안다.
인컨텍스트 학습, chain-of-thought, 추론 모델, 환각과 보정이 무엇인지 설명할 수 있다.
RLVR(검증 가능한 보상 강화학습)이 파이프라인의 어디에 들어가는지, 테스트타임 계산과 증류가 무엇인지 안다.
마스크 디퓨전 언어 모델이 자기회귀 모델과 어떻게 다르게 생성하는지, 그 장단점을 설명할 수 있다.

언어 모델이란: 다음 토큰의 확률 분포

언어 모델(language model)은 토큰 열에 확률을 매기는 모델이다. 4장에서 본 것처럼 텍스트는 먼저 토큰 $x_1, x_2, \dots, x_T$로 쪼개진다. 문장 전체의 확률 $P(x_1,\dots,x_T)$를 직접 모델링하기는 어렵지만, 확률의 연쇄법칙(chain rule)을 쓰면 이것을 "앞의 토큰들이 주어졌을 때 다음 토큰의 확률"들의 곱으로 정확히 분해할 수 있다.

$$P(x_1, x_2, \dots, x_T) = \prod_{t=1}^{T} P(x_t \mid x_1, \dots, x_{t-1}) = \prod_{t=1}^{T} P(x_t \mid x_{\lt t})$$

근사가 아니라 항등식이다. 따라서 "다음 토큰 분포"만 잘 맞히는 모델이 있으면 어떤 문장의 확률도 계산할 수 있고, 거기서 샘플을 뽑아 새 문장을 생성할 수도 있다.

그래서 오늘날의 LLM은 모두 한 가지 일만 한다. 문맥 $x_{\lt t}$를 받아 어휘 전체(Llama 3 기준 128,256개 토큰)에 대한 확률 분포 $P_\theta(\cdot \mid x_{\lt t})$를 출력한다. 생성할 때는 이 분포에서 토큰 하나를 고르고, 그것을 문맥 끝에 붙여 다시 모델에 넣는다. 이런 방식을 자기회귀(autoregressive) 생성이라고 한다. 디코딩 전략(온도·top-k·top-p)과 KV 캐시는 8장에서 자세히 다룬다.

그림 7-1. 자기회귀 언어 모델. 모델은 문맥을 받아 다음 토큰의 확률 분포를 내고(막대는 설명용 예시 값), 생성할 때는 거기서 하나를 뽑아 문맥에 붙여 다시 넣는다. 학습할 때는 실제 다음 토큰의 확률을 높이도록 파라미터 θ를 조정한다.

교차 엔트로피와 퍼플렉시티

학습 목표는 실제 텍스트에 높은 확률을 주는 것이다. 곱은 다루기 불편하므로 로그를 취하고 부호를 뒤집어 평균을 낸다. 이것이 3장에서 본 교차 엔트로피 손실(cross-entropy)이며, 토큰마다 "정답 토큰에 준 확률의 −log"를 평균한 값이다.

$$\mathcal{L}(\theta) = -\frac{1}{T}\sum_{t=1}^{T} \log P_\theta(x_t \mid x_{\lt t}), \qquad \mathrm{PPL} = \exp(\mathcal{L}) = \Bigl(\prod_t P_\theta(x_t\mid x_{\lt t})\Bigr)^{-1/T}$$

$\mathcal{L}$은 자연로그 기준이면 nats, 밑 2이면 bits 단위다. 퍼플렉시티(perplexity) PPL은 확률의 기하평균의 역수로, "모델이 매 스텝 평균적으로 몇 개의 후보 사이에서 균등하게 헷갈리는가"로 읽는다. 어휘 $V$개에 균등 분포를 주면 PPL = $V$다.

손실 1 nat 차이는 PPL로 $e \approx 2.7$배 차이다. LLM 논문에서 손실이 2.0에서 1.9로 "겨우" 0.1 줄어든 것은 PPL이 약 10% 줄었다는 뜻이고, 모든 토큰에서 평균적으로 그만큼 덜 놀란다는 뜻이다. 아래 시뮬레이터에서 토큰별 확률을 직접 끌어 올리고 내리며 감을 잡아 보자.

SIMULATOR

확률의 연쇄법칙과 퍼플렉시티

단위

예시 모델

문장 확률 ∏P—

평균 손실 𝓛—

퍼플렉시티—

가장 큰 기여 토큰—

해볼 것: 막대를 위아래로 끌어 각 토큰의 조건부 확률 $P(x_t\mid x_{\lt t})$를 바꾼다(세로축은 로그 눈금). ① '한 토큰에서 크게 틀림'은 '잘 학습된 모델'에서 '좋다' 하나만 0.55 → 0.001로 내린 것이다. 문장 확률은 550배 줄고, 7개 토큰의 평균인데도 PPL이 1.9에서 4.6으로 2배 넘게 뛴다. −log가 확신에 찬 오답을 크게 벌하기 때문이다. ② 모든 막대를 0.5로 맞추면 PPL = 2(동전 던지기 수준), 0.1로 맞추면 PPL = 10이 된다. ③ '균등 분포'는 GPT-2 어휘 50,257개에 균등한 확률을 준 경우로, 학습 전 모델의 출발점이다(손실 ≈ ln 50,257 ≈ 10.8 nats).

n-gram 모델: 세어서 만드는 언어 모델

가장 오래된 언어 모델은 신경망 없이 세기만 한다. 문맥 전체 $x_{\lt t}$를 다 보는 대신 바로 앞 $n-1$개 토큰만 본다고 가정하면(마르코프 가정(Markov assumption)), 조건부 확률은 코퍼스의 출현 횟수 비율로 추정된다.

$$P(x_t \mid x_{t-n+1:t-1}) \approx \frac{c(x_{t-n+1:t-1},\, x_t) + k}{c(x_{t-n+1:t-1}) + kV}$$

$c(\cdot)$는 코퍼스에서 해당 문자열이 나온 횟수, $V$는 어휘 크기다. $k=0$이면 최대우도 추정(MLE), $k=1$이면 라플라스(add-one) 스무딩이다. $n=1$(유니그램)은 문맥을 전혀 보지 않고 글자 빈도만 쓴다.

n을 키우면 문맥을 더 많이 보니 예측이 날카로워진다. 하지만 문맥의 가짓수는 $V^{n-1}$으로 폭발하고, 코퍼스는 유한하다. 한국어 음절만 해도 자주 쓰는 것이 2,000개를 넘으니 3글자 문맥은 수십억 가지인데, 대부분은 코퍼스에 한 번도 나오지 않는다. 처음 보는 문맥에서 MLE는 0/0이 되고, 처음 보는 조합에는 확률 0을 준다. 확률 0이 하나라도 끼면 문장 확률 전체가 0, 퍼플렉시티는 무한대가 된다. 이것이 희소성 문제(sparsity)다. 스무딩은 0을 피하게 해 주고, 백오프(backoff)는 본 적 없는 문맥이면 더 짧은 문맥으로 물러나 추정한다. 2010년대 초까지 음성 인식과 기계 번역은 수십억 단어로 센 5-gram 모델과 Kneser–Ney 스무딩을 썼다.

아래 시뮬레이터에는 교육용으로 직접 작성한 짧은 한국어 문장 수십 개가 들어 있다. 문자(음절과 공백) 단위로 n-gram을 세고, 다음 글자 분포를 보여 준다. 코퍼스는 자유롭게 고칠 수 있다.

SIMULATOR

문자 단위 n-gram 언어 모델

n (문맥 = n−1 글자)

스무딩 k 백오프 (본 적 없는 문맥 → 짧은 문맥) 생성 온도 T

문맥 (막대를 누르면 그 글자를 덧붙인다)

—

평가 문장 (퍼플렉시티 계산)

학습 코퍼스 편집 (한 줄 = 한 문장)

어휘 V (글자 종류)—

이 문맥의 출현 수 c(h)—

본 문맥 종류—

평가 문장 PPL—

확률 0 글자 수—

해볼 것: ① n=1에서 '이어서 생성'을 누르면 글자 빈도만 맞춘 무의미한 문자열이 나오고, n=3~4로 올리면 코퍼스의 어절이 그럴듯하게 이어진다(n=4에서는 코퍼스 문장을 거의 그대로 베낀다). ② k=0, n=4에서 평가 문장을 "나는 저녁에 도서관에 간다."처럼 코퍼스에 없는 조합으로 바꾸면 확률 0인 글자가 생겨 PPL이 ∞가 된다. k를 0.1로 올리거나 백오프를 켜면 유한해진다. ③ 문맥 칸에 "우주"처럼 코퍼스에 없는 말을 넣으면 c(h)=0, 즉 '본 적 없는 문맥'이다. 같은 문맥에서 n을 낮추면 다시 분포가 생긴다. 이 한계를 넘으려면 비슷한 글자·단어끼리 통계를 공유해야 한다. 그것이 다음 절의 임베딩이다.

신경망 언어 모델: 통계를 공유하는 임베딩

n-gram 모델에서 "고양이가 잔다"와 "강아지가 잔다"는 아무 관계가 없는 별개의 카운트다. 하나를 많이 봐도 다른 쪽 확률은 오르지 않는다. Bengio 등(2003)의 신경 확률 언어 모델(Neural Probabilistic Language Model)은 이 문제를 두 단계로 풀었다. 첫째, 각 토큰을 학습 가능한 밀집 벡터 $\mathbf{e}\in\mathbb{R}^d$, 즉 4장의 임베딩으로 바꾼다. 둘째, 문맥 임베딩들을 이어 붙여 MLP(2장)에 넣고 다음 토큰의 로짓을 출력한다. 비슷한 문맥에서 쓰이는 토큰은 학습 중에 비슷한 벡터를 갖게 되고, 그래서 한 문맥에서 배운 것이 비슷한 문맥으로 일반화된다.

그림 7-2. 문자 단위 MLP 언어 모델(Bengio 2003의 구조를 글자에 적용). 문맥 K개 글자의 임베딩을 조회해 이어 붙이고, tanh 은닉층을 거쳐 어휘 크기 V의 로짓을 낸다. 임베딩 표 C, W₁, W₂가 모두 역전파로 함께 학습된다.

$$\mathbf{e} = [C_{x_{t-K}};\dots;C_{x_{t-1}}],\quad \mathbf{h} = \tanh(\mathbf{e}W_1 + \mathbf{b}_1),\quad P(\cdot\mid x_{\lt t}) = \mathrm{softmax}(\mathbf{h}W_2 + \mathbf{b}_2)$$

역전파의 출발점은 $\partial\mathcal{L}/\partial\mathbf{z} = \mathbf{p} - \mathbf{y}_{\text{one-hot}}$(소프트맥스+교차 엔트로피의 깔끔한 기울기)다. 그다음 $\partial\mathcal{L}/\partial\mathbf{h} = (\mathbf{p}-\mathbf{y})W_2^\top$, tanh를 지나며 $(1-\mathbf{h}^2)$이 곱해지고, $W_1^\top$을 거쳐 임베딩까지 내려가 문맥 글자의 행 $C_{x}$에만 더해진다(3장의 연쇄법칙).

아래가 이 장의 대표 시뮬레이터다. 위 구조를 JavaScript로 그대로 구현했다. 순전파, 손실, 역전파(기울기를 수치 미분과 대조해 검증함), Adam 업데이트를 모두 Float32Array 위에서 직접 계산하며, 화면이 갱신될 때마다 미니배치 64개로 몇 스텝씩 학습한다. 학습 데이터는 교육용으로 직접 쓴 약 2,800자짜리 짧은 영어 이야기다(영어 소문자 26자·공백·마침표·쉼표, V = 28). 한국어 음절은 어휘가 수백~수천 개라 이 작은 모델과 데이터로는 학습이 느려서 영어를 골랐다.

SIMULATOR

브라우저에서 학습하는 문자 단위 MLP 언어 모델

학습

문맥 길이 K

임베딩 차원 d

은닉 크기 H

학습률 η Weight decay

스텝0

학습 손실—

검증 손실—

검증 PPL—

파라미터 수—

속도—

학습 중 샘플 (온도 0.8, "the " 다음부터)

글자 임베딩 지도 (PCA 2D, 학습하며 갱신)

직접 생성해 보기

온도 T

—

학습 텍스트 보기 (교육용으로 작성한 약 2,800자, 앞 90% 학습 / 뒤 10% 검증)

해볼 것: ① '학습 시작'을 누르고 샘플을 지켜보자. 스텝 0의 무작위 글자 → 수백 스텝에서 "the", "and" 같은 짧은 단어 → 1,000스텝 무렵에는 문법이 그럴듯한 가짜 문장이 나온다. 손실 곡선의 점선 ln 28 ≈ 3.33은 균등 분포 수준이다. ② 수백 스텝이 지나면 학습 손실(진한 선)은 계속 내려가는데 검증 손실(분홍)은 바닥을 찍고 다시 오른다. 2,500자 남짓한 데이터를 약 1만 개 파라미터가 외워 버리는 과적합이다. 초기화 후 weight decay를 0.1~0.2로 주고 다시 학습하면 검증 손실의 반등이 줄어든다. ③ 학습률을 10⁻¹로 올리면 손실이 요동치고, 10⁻⁴이면 거의 안 내려간다. ④ d=2로 두면 임베딩 지도가 그대로 실제 임베딩이다. 학습이 진행되면 모음(a e i o u)이 한쪽에 모이는 경향을 볼 수 있다(초기화 시드·설정에 따라 다를 수 있다).

이 작은 모델과 GPT의 차이

구조의 뼈대(임베딩 → 비선형 변환 → 어휘 소프트맥스, 교차 엔트로피, 역전파, Adam)는 GPT와 같다. 다른 점은 ① 문맥이 고정 길이 K(여기선 4글자)라는 것, ② 문맥 위치마다 다른 가중치 블록을 써서 위치 간 정보 공유가 없다는 것, ③ 규모(약 10⁴ 파라미터 vs 10⁹~10¹²), 그리고 ④ 데이터(2.8천 글자 vs 10¹³ 토큰)다. 이 시뮬레이터에서 본 과적합은 데이터가 모델보다 훨씬 작아서 생긴다. 실제 LLM 사전학습에서는 대개 데이터를 한 번(1 에폭) 정도만 보므로 학습 손실과 검증 손실이 거의 붙어서 함께 내려간다.

왜 Transformer로 바뀌었나

고정 길이 문맥의 한계를 넘기 위해 2010년대에는 순환 신경망(RNN, LSTM)이 쓰였다. 은닉 상태 $\mathbf{h}_t = f(\mathbf{h}_{t-1}, x_t)$를 한 토큰씩 갱신하므로 이론상 문맥 길이에 제한이 없다. 하지만 두 가지 근본 문제가 있었다.

긴 거리 정보 손실: 1,000 토큰 앞의 정보는 1,000번의 비선형 변환을 거쳐야 현재에 도달한다. 그동안 고정 크기 벡터에 압축되고, 기울기는 그만큼 곱해지며 소실·폭주한다(3장).
병렬화 불가: $\mathbf{h}_t$는 $\mathbf{h}_{t-1}$이 끝나야 계산할 수 있다. 문장 길이 T만큼의 순차 단계가 필요하므로, 수천 개의 코어가 행렬곱을 동시에 하는 GPU의 힘을 쓰지 못한다.

2017년의 Transformer(5장, 6장)는 순환을 없앴다. 셀프 어텐션은 모든 위치가 모든 이전 위치를 한 단계에 직접 참조하고(경로 길이 1), 학습할 때는 인과 마스크만 씌우면 한 시퀀스의 T개 위치 손실을 큰 행렬곱 몇 번으로 동시에 계산할 수 있다. 계산량은 $T^2$로 늘지만 GPU에서는 순차 단계 T번보다 훨씬 빠르다. "규모를 키우면 좋아진다"는 스케일링을 실제로 밀어붙일 수 있게 된 결정적 이유가 이 병렬성이다.

그림 7-3. RNN(왼쪽)은 은닉 상태를 한 칸씩 넘겨 주므로 계산이 순차적이고 먼 정보가 여러 번 압축된다. Transformer(오른쪽)의 인과 셀프 어텐션은 각 출력이 이전 모든 입력을 직접 보며, 모든 위치를 한 번에 계산할 수 있다.

현재의 LLM은 거의 모두 디코더 전용 Transformer(decoder-only)다. GPT 계열, Llama, Qwen, DeepSeek, Mistral 모두 같은 틀에 RoPE, RMSNorm, SwiGLU FFN, GQA 같은 개선을 얹은 형태다(6장). 학습 목표는 이 장의 처음과 똑같은 다음 토큰 교차 엔트로피다. 2024년 이후에는 Mamba 같은 상태공간 모델(SSM)이나 어텐션과 섞은 하이브리드도 연구되지만, 주류는 여전히 Transformer다.

사전학습: 데이터와 계산량

사전학습(pretraining)은 인터넷 문서, 책, 코드, 논문 등 거대한 텍스트에서 다음 토큰 예측을 학습하는 단계다. 데이터 규모는 해마다 커졌다. GPT-3(2020)는 약 3,000억(300B) 토큰, Chinchilla(2022)는 1.4조 토큰, Llama 2(2023)는 2조 토큰, Llama 3(2024)는 약 15조(15T) 토큰으로 학습했다. 원본 웹 크롤(Common Crawl 등)을 그대로 쓰지 않고, 중복 제거, 언어 식별, 품질 분류기 필터링, 개인정보·유해 콘텐츠 제거, 코드·수학 비중 조절 같은 정제를 거친다. 데이터 품질이 모델 품질을 크게 좌우한다는 것이 현장의 공통된 경험이다.

계산량 C ≈ 6ND

파라미터 $N$개짜리 Transformer가 토큰 하나를 처리하는 순전파에는 대략 $2N$ FLOPs가 든다(가중치 하나당 곱셈 1 + 덧셈 1). 역전파는 활성값에 대한 기울기와 가중치에 대한 기울기를 모두 계산하므로 순전파의 약 2배인 $4N$이다. 따라서 토큰당 $6N$, 전체 $D$개 토큰을 학습하면

$$C \approx 6ND \ \text{FLOPs}, \qquad \text{학습 시간} \approx \frac{C}{(\text{GPU 수}) \times (\text{GPU 최대 FLOPS}) \times \text{MFU}}$$

어텐션의 $T^2$ 항은 문맥이 아주 길지 않으면 작아서 무시한다. MFU(Model FLOPs Utilization)는 실제로 모델 계산에 쓰인 FLOPS ÷ 하드웨어 최대치다. 통신·메모리 대기·파이프라인 공백 때문에 대규모 학습에서는 보통 35~50%다(Llama 3 405B 학습은 BF16에서 약 38~43%로 보고됨).

예를 들어 Llama 3 8B를 15T 토큰으로 학습하면 $C \approx 6 \times 8\times10^9 \times 15\times10^{12} = 7.2\times10^{23}$ FLOPs다. Meta는 Llama 3.1 405B의 사전학습 계산량을 약 $3.8\times10^{25}$ FLOPs, H100 최대 16,000여 개, 약 3,084만 GPU-시간으로 보고했다(2024). 아래 계산기로 직접 확인해 보자.

SIMULATOR

학습 계산량 계산기

파라미터 N 학습 토큰 D

GPU (BF16 dense 최대)

GPU 수 MFU

프리셋

계산량 C = 6ND—

GPU-시간—

학습 기간—

토큰/파라미터—

1 GPU로 하면—

해볼 것: ① 'Llama 3.1 405B' 프리셋(H100 16,384개, MFU 40%)에서 C ≈ 3.8×10²⁵, 약 2,700만 GPU-시간, 약 2달 남짓이 나온다. Meta 보고치(약 3,084만 GPU-시간)와 같은 자릿수다. 차이는 실패·재시작, 장문맥 추가 학습 등이다. ② 그래프의 점을 좌우로 끌어 GPU 수를 바꿔 보자. 이상적으로는 GPU를 2배로 늘리면 기간이 절반이 되지만(직선), 실제로는 규모가 커질수록 통신 때문에 MFU가 떨어진다. ③ GPU를 A100으로 바꾸면 같은 학습에 약 3.2배 긴 시간이 든다. 'GPT-3' 프리셋은 2020년에 V100 클러스터로 수 주가 걸린 학습이 H100 1,024개로는 열흘이 채 안 걸린다는 것을 보여 준다.

모델 (연도)	N	D (토큰)	D/N	C ≈ 6ND	비고
GPT-3 (2020)	175B	300B	1.7	3.1×10²³	V100 클러스터
Chinchilla (2022)	70B	1.4T	20	5.9×10²³	계산 최적 배분
Llama 2 70B (2023)	70B	2T	29	8.4×10²³	A100, 약 172만 GPU-시간
Llama 3 8B (2024)	8B	15T	~1,900	7.2×10²³	H100, 약 130만 GPU-시간
Llama 3 70B (2024)	70B	15T	~210	6.3×10²⁴	H100, 약 640만 GPU-시간
Llama 3.1 405B (2024)	405B	15.6T	~39	3.8×10²⁵	H100 최대 16K개

GPU-시간은 Meta 모델 카드의 보고치다. 학습에 필요한 메모리(가중치·기울기·Adam 상태로 파라미터당 약 16바이트)와 분산 학습은 3장과 12장에서 다룬다.

스케일링 법칙: 크기와 데이터의 최적 배분

Kaplan 등(OpenAI, 2020)은 언어 모델의 테스트 손실이 파라미터 수 N, 데이터 D, 계산량 C에 대해 수 자릿수에 걸쳐 매끄러운 거듭제곱 법칙(power law)을 따른다는 것을 보였다. 로그-로그 그래프에서 직선이라는 뜻이다. 이 관찰 덕분에 작은 모델 수십 개를 학습해 보고, 수백 배 큰 모델의 손실을 학습 전에 예측할 수 있게 되었다.

그렇다면 계산 예산 C가 정해졌을 때 N과 D를 어떻게 나눠야 할까? 큰 모델을 적은 데이터로? 작은 모델을 많은 데이터로? Hoffmann 등(DeepMind, 2022)은 400개 넘는 모델을 학습해 다음 형태를 적합했다.

$$L(N, D) = E + \frac{A}{N^{\alpha}} + \frac{B}{D^{\beta}}, \qquad E=1.69,\ A=406.4,\ B=410.7,\ \alpha=0.34,\ \beta=0.28$$

$E$는 아무리 키워도 남는 손실(텍스트 자체의 엔트로피), 두 번째 항은 모델이 유한해서, 세 번째 항은 데이터가 유한해서 생기는 손실이다. 제약 $C = 6ND$ 아래에서 $L$을 최소화하면 $N_{opt} \propto C^{\beta/(\alpha+\beta)}$, $D_{opt} \propto C^{\alpha/(\alpha+\beta)}$가 된다.

논문의 핵심 결론은 "N과 D를 거의 같은 비율로 키워라", 구체적으로 파라미터당 약 20 토큰이었다. 같은 계산량(약 5.8×10²³ FLOPs)으로 Gopher 280B(300B 토큰)보다 Chinchilla 70B(1.4T 토큰)가 모든 평가에서 더 좋았다. GPT-3(175B, 300B 토큰, 파라미터당 1.7 토큰)는 이 기준으로 크게 데이터 부족이었던 셈이다.

같은 논문, 다른 숫자

위 수식의 계수(논문의 '접근법 3')를 그대로 최소화하면 최적 비율이 파라미터당 20이 아니라 계산량에 따라 30~150 토큰으로 나온다. 논문의 다른 두 접근법은 약 20을 줬다. Besiroglu 등(Epoch AI, 2024)은 원 데이터를 재구성해 다시 적합한 결과(E=1.82, A=482.0, B=2085.4, α=0.348, β=0.366)가 접근법 1·2와 일치하는 약 20 토큰/파라미터를 준다고 보고했다. 아래 시뮬레이터에서 두 계수 세트를 바꿔 볼 수 있다. 스케일링 법칙은 물리 법칙이 아니라 경험적 적합이며, 데이터 구성·토크나이저·아키텍처가 바뀌면 계수도 바뀐다는 점을 기억하자.

SIMULATOR

스케일링 법칙 탐색: N–D 평면의 손실 지형

계산 예산 C

계수

실제 모델 표시

최적 N_opt—

최적 D_opt—

D/N (최적)—

L_opt—

탐침 (N, D)—

탐침 손실 / 손해—

해볼 것: 위 그림은 가로 N, 세로 D(모두 로그)에서 손실 L(N,D)의 등고선이고, 흰 대각선이 계산량 C = 6ND가 일정한 선이다. 아래 그림은 그 선을 따라 잘라 본 손실(가로 N)이다. ① 위 그림의 탐침(◆)을 끌어 보자. 탐침을 지나는 등계산량 선이 다시 그려지고, 같은 계산량에서 최적점(●) 대비 손실이 얼마나 나쁜지 보여 준다. GPT-3 점에 가져가면 같은 계산으로 더 작은 모델·더 많은 데이터가 낫다는 것이 보인다. ② C 슬라이더를 10¹⁹에서 10²⁶까지 움직이면 최적점이 대각선 방향 직선(로그-로그)을 따라 이동한다. 계수를 'Epoch 2024 재적합'으로 바꾸면 D/N이 약 20 근처로 안정된다. ③ Llama 3 8B(15T 토큰)는 최적점에서 한참 위(데이터 쪽)에 있다. 같은 계산이면 더 큰 모델이 손실은 낮지만, 작은 모델은 추론 비용이 싸다. 수억 명에게 서비스할 모델이라면 학습에 계산을 더 써서 작은 모델을 '과학습'시키는 편이 전체 비용이 적다.

Chinchilla 이후 업계는 두 방향으로 갈렸다. 최고 성능 하나만 노리는 경우에는 계산 최적 근처를, 널리 배포할 모델은 계산 최적보다 훨씬 많은 데이터로 학습하는 과학습(overtraining)을 택한다. Llama 3 8B의 파라미터당 약 1,900 토큰이 극단적인 예다. Meta는 8B와 70B 모두 15T 토큰까지도 손실이 로그-선형으로 계속 내려갔다고 보고했다. 학습은 한 번이지만 추론은 수조 번 일어나므로, 수명 전체의 계산을 최소화하는 기준이 달라지는 것이다. 또 다른 제약은 데이터 고갈이다. 고품질 공개 텍스트는 수십조 토큰 규모로 추정되어, 합성 데이터와 여러 에폭 반복이 활발히 연구되고 있다.

2024~2026년: 계산 최적을 한참 넘어서

과학습은 이후 더 극단으로 갔다. Qwen3(2025)는 0.6B짜리 가장 작은 모델까지 약 36T 토큰 규모의 데이터로 학습했다. 파라미터당 약 60,000 토큰으로, Chinchilla 기준(약 20)의 3,000배다. 위 시뮬레이터의 'Qwen3 0.6B' 점이 계산 최적 궤적에서 얼마나 멀리 있는지 확인해 보자. 이렇게 해도 손실이 계속 내려가는 한, 스마트폰이나 노트북에서 돌릴 작은 모델에는 이득이다. 학습 비용은 한 번이지만 추론 비용은 사용량에 비례하기 때문이다.

모델	파라미터 (활성)	토큰	토큰 / 활성 파라미터
Chinchilla (2022)	70B	1.4T	20
Llama 3 8B (2024)	8B	15T	~1,900
Qwen3-0.6B (2025)	0.6B	~36T	~60,000
Llama 4 Scout (2025)	17B (총 109B)	~40T	~2,400
DeepSeek-V4-Flash (2026)	13B (총 284B)	32T 이상	~2,500

MoE에서 'N'은 무엇인가

MoE 모델에는 파라미터 수가 두 개 있다. 토큰 하나를 처리하는 데 쓰이는 활성 파라미터 $N_{\text{활성}}$이 계산량 $C \approx 6N_{\text{활성}}D$와 추론 속도를 정하고, 총 파라미터 $N_{\text{총}}$이 메모리와 '지식 용량'을 정한다. 같은 계산(같은 $N_{\text{활성}}$)에서 전문가를 늘려 총 파라미터를 키우면 손실이 더 내려간다는 것이 MoE의 핵심이고, 그래서 2025~2026년 플래그십은 총 1T 안팎에 활성은 그 2~5%(예: Kimi K2 32B/1T, DeepSeek-V4-Pro 49B/1.6T, Qwen3.5 17B/397B) 수준이다. 밀집 모델용 Chinchilla 식을 그대로 쓸 수는 없어서, 희소도(총/활성 비율)를 변수로 넣은 MoE 스케일링 법칙이 따로 연구되고 있다. 대가는 메모리다. 1.6T 파라미터는 FP8로도 1.6 TB라 GPU 여러 장에 나눠 올려야 하고, 전문가 사이의 통신과 부하 균형이 서빙의 핵심 문제가 된다(12장).

사전학습 이후: SFT와 선호 학습

사전학습만 마친 베이스 모델(base model)은 "인터넷 문서를 이어 쓰는 기계"다. "프랑스의 수도는?"이라고 넣으면 답 대신 "독일의 수도는? 이탈리아의 수도는?"처럼 퀴즈 목록을 이어 쓸 수도 있다. 이 모델을 사람의 지시를 따르고, 도움이 되며, 해로운 요청을 거절하는 조수로 바꾸는 과정을 사후 학습(post-training) 또는 정렬(alignment)이라 한다.

그림 7-4. LLM 학습 파이프라인. 계산의 대부분은 사전학습에 들고, SFT와 선호 학습은 훨씬 적은 데이터로 모델의 '행동 방식'을 바꾼다. RLHF는 보상 모델을 따로 학습해 강화학습(PPO)으로 정책을 최적화하고, DPO는 같은 목표를 비교 데이터에 대한 분류 손실 하나로 푼다. 2025년 이후 추론 모델에는 정답을 자동으로 채점할 수 있는 과제에서 강화학습을 하는 ④ RLVR 단계가 더해졌다(이 장 끝의 개요, 11장). 실제로는 단계가 여러 번 반복·교차되기도 한다(예: DeepSeek-R1의 SFT → RL → SFT → RL).

SFT와 채팅 템플릿

지도 미세조정(SFT, Supervised Fine-Tuning)은 사람이 쓴(또는 강한 모델이 생성하고 사람이 검수한) "지시 → 모범 답변" 쌍으로 같은 다음 토큰 손실을 계속 학습한다. 다만 손실은 답변 부분 토큰에만 건다. 대화는 역할을 구분하는 특수 토큰으로 감싼 채팅 템플릿으로 직렬화된다. 다음은 Llama 3 Instruct의 형식이다.

<|begin_of_text|><|start_header_id|>system<|end_header_id|>

너는 친절한 조수다.<|eot_id|><|start_header_id|>user<|end_header_id|>

프랑스의 수도는?<|eot_id|><|start_header_id|>assistant<|end_header_id|>

프랑스의 수도는 파리입니다.<|eot_id|>     ← 이 부분에만 손실

특수 토큰은 어휘에 따로 예약된 ID를 가지며 일반 텍스트로는 만들어지지 않는다. 모델은 <|eot_id|>를 생성하는 것으로 "내 차례가 끝났다"를 표시하고, 서빙 시스템은 이 토큰을 만나면 생성을 멈춘다. 템플릿이 학습 때와 다르면 모델 품질이 눈에 띄게 떨어지므로, 추론 프레임워크는 모델과 함께 배포된 템플릿을 그대로 써야 한다.

RLHF와 DPO

SFT는 "모범 답을 흉내 내기"라서, 모범 답보다 나은 답을 배우기 어렵고 무엇이 더 나은지에 대한 신호가 없다. 사람에게 좋은 답을 직접 쓰게 하는 것보다 두 답 중 나은 쪽을 고르게 하는 것이 훨씬 쉽고 일관적이다. RLHF(Reinforcement Learning from Human Feedback)는 이 비교 데이터로 보상 모델 $r_\phi$를 학습하고(Bradley–Terry 모델: $P(y_w \succ y_l) = \sigma(r_\phi(y_w) - r_\phi(y_l))$), 정책 $\pi_\theta$가 보상을 최대화하되 SFT 모델 $\pi_{ref}$에서 너무 멀어지지 않도록 KL 페널티를 건 목표를 PPO로 최적화한다(InstructGPT, 2022).

$$\max_{\pi_\theta}\ \mathbb{E}_{y\sim\pi_\theta}\bigl[r_\phi(x,y)\bigr] - \beta\, \mathrm{KL}\bigl(\pi_\theta(\cdot\mid x)\,\|\,\pi_{ref}(\cdot\mid x)\bigr)$$

이 목표의 최적해는 $\pi^*(y\mid x) \propto \pi_{ref}(y\mid x)\exp(r(x,y)/\beta)$로 닫힌 형태다. 이를 거꾸로 풀면 보상이 $r = \beta\log\frac{\pi^*}{\pi_{ref}} + \text{상수}$이므로, 보상 모델 없이 정책의 로그 확률비 자체를 "암묵적 보상"으로 쓸 수 있다. 이것을 Bradley–Terry 손실에 대입한 것이 DPO(Direct Preference Optimization, Rafailov 등 2023)다.

$$\mathcal{L}_{DPO} = -\log\sigma\Bigl(\beta\Bigl[\log\frac{\pi_\theta(y_w\mid x)}{\pi_{ref}(y_w\mid x)} - \log\frac{\pi_\theta(y_l\mid x)}{\pi_{ref}(y_l\mid x)}\Bigr]\Bigr)$$

$y_w$는 선호된 응답, $y_l$은 거부된 응답이다. 괄호 안(마진)이 클수록 손실이 작다. 기울기는 $\beta(1-\sigma(\cdot))$만큼의 크기로 $y_w$의 로그 확률을 올리고 $y_l$을 내리며, 이미 잘 구분된 쌍(σ≈1)에서는 기울기가 거의 0이 된다. β는 참조 정책에서 얼마나 멀어지도록 허용할지 정하는 '목줄'이다.

실제 LLM에서 $\log\pi_\theta(y\mid x)$는 응답 토큰들의 로그 확률 합이다. 아래 장난감에서는 한 프롬프트에 대한 응답 후보 5개만 있는 범주형 정책 $\pi_\theta = \mathrm{softmax}(\boldsymbol\theta)$로 단순화해, 같은 DPO 기울기를 정확히 계산한다. 이 경우 $\partial\mathcal{L}/\partial\boldsymbol\theta = -\beta(1-\sigma(h))(\mathbf{e}_w - \mathbf{e}_l)$로, 두 응답의 로짓만 움직인다.

SIMULATOR

선호 최적화(DPO) 장난감

β (KL 목줄) 학습률 η

업데이트

마지막 쌍—

DPO 손실—

σ(마진)—

KL(π‖π_ref)—

업데이트 수0

해볼 것: 프롬프트는 "파이썬에서 리스트를 뒤집는 방법은?"이다. 응답 막대를 먼저 선호하는 것, 다음에 거부할 것 순서로 누르면 'A ≻ B' 쌍 하나로 DPO 업데이트가 한 번 일어난다. 흐린 테두리는 참조 정책 π_ref(SFT 모델), 진한 막대는 현재 정책 π다. ① A(정확·간결) ≻ C(틀린 답)를 여러 번 주면 C의 확률이 줄고, 마진이 커지면서 σ가 1에 가까워져 업데이트가 저절로 느려진다. ② β를 2로 올리고 '초기화 → 자동 선호 ×30'을 하면 KL이 작게 머물고, β=0.05면 훨씬 멀리 간다(학습률은 같게). ③ 오른쪽 숫자는 암묵적 보상 β·log(π/π_ref)다. 비교에 한 번도 나오지 않은 응답은 직접 기울기를 받지 않지만, 확률은 소프트맥스 정규화 때문에 함께 변한다.

DPO는 보상 모델과 강화학습 루프가 필요 없어 구현이 간단하고 안정적이라 2023년 이후 오픈 모델에서 널리 쓰였다. Llama 3도 SFT 후 DPO를 여러 라운드 반복했다. 반면 PPO류의 온라인 강화학습은 정책이 직접 생성한 새 응답으로 계속 학습할 수 있어, 정답 검증이 가능한 수학·코드 과제에서 다시 주목받았다(다음 절의 추론 모델). 사람 대신 AI가 원칙에 따라 비교 판단을 내리게 하는 RLAIF, Constitutional AI 같은 방법도 함께 쓰인다.

보상 해킹과 아첨

보상 모델은 사람 선호의 불완전한 근사다. 정책이 이를 과하게 최적화하면 길고 장황한 답, 확신에 찬 말투, 사용자의 의견에 무조건 동의하는 아첨(sycophancy) 같은 '보상은 높지만 실제로는 나쁜' 행동을 배운다. KL 페널티(β)는 이런 과최적화를 막는 장치이며, 위 시뮬레이터에서 β가 작을수록 정책이 참조에서 멀리 벗어나는 것이 바로 그 위험이다.

창발, 인컨텍스트 학습, 추론 모델

GPT-3 논문(2020)의 제목은 "Language Models are Few-Shot Learners"였다. 가중치를 전혀 바꾸지 않고, 프롬프트에 예시 몇 개를 넣는 것만으로 모델이 새 과제를 수행한다는 발견이다. 이를 인컨텍스트 학습(in-context learning, ICL)이라 한다.

영어 → 한국어
cheese → 치즈
sea otter → 해달
peppermint → 페퍼민트
plush giraffe → 봉제 기린      ← 모델이 패턴을 이어 씀 (few-shot, 예시 3개)

예시 없이 지시만 주면 zero-shot, 몇 개 주면 few-shot이다. 모델 입장에서는 이것도 그냥 "다음 토큰 예측"이다. 사전학습 데이터에 이런 패턴(목록, 표, 문답)이 무수히 있으므로, 문맥에서 과제를 추론하고 이어 쓰는 능력이 학습된다. 연구에 따르면 어텐션 헤드 중 일부가 "앞에서 A 다음에 B가 왔으면, 지금 A가 나왔을 때 B를 복사"하는 인덕션 헤드(induction head)로 발달하며, 이것이 ICL의 기본 회로 중 하나로 알려져 있다(5장).

창발 능력?

특정 규모를 넘으면 갑자기 나타나는 듯한 능력을 창발(emergent abilities)이라 부른다(Wei 등, 2022). 예를 들어 여러 자리 덧셈 정확도가 작은 모델에서는 0 근처이다가 어느 크기에서 급격히 오른다. 하지만 Schaeffer 등(2023)은 이 '급변'의 상당 부분이 평가 지표 때문이라고 지적했다. 정답 전체가 맞아야 1점인 정확도는 불연속적이지만, 토큰별 로그 확률 같은 연속 지표로 보면 손실과 함께 매끄럽게 좋아진다. 다음 토큰 손실의 매끄러운 감소(스케일링 법칙)가 사람이 보는 과제 성능에서는 문턱처럼 보일 수 있다는 뜻이다.

Chain-of-thought와 테스트타임 계산

"단계별로 생각해 보자"처럼 중간 추론을 글로 쓰게 하면 수학·논리 문제의 정확도가 크게 오른다. 이것이 chain-of-thought(CoT) 프롬프팅이다. 이유는 계산 구조에서 찾을 수 있다. Transformer는 토큰 하나를 만들 때 고정된 층 수만큼의 계산만 한다. 답을 곧바로 한 토큰으로 내야 하면 그 안에 모든 계산을 끝내야 하지만, 중간 단계를 토큰으로 써 내려가면 생성한 토큰 수만큼 계산을 더 쓰고, 써 둔 중간 결과를 다시 읽어 활용할 수 있다.

2024~2025년의 추론 모델(reasoning models)은 이것을 학습으로 끌어올렸다. OpenAI o1(2024), DeepSeek-R1(2025) 등은 답을 내기 전에 긴 사고 과정을 생성하도록 강화학습으로 훈련된다. 수학 정답이나 코드 테스트 통과처럼 자동으로 검증 가능한 보상을 주면, 모델은 스스로 검산하고, 막히면 다른 접근을 시도하는 긴 추론을 배운다. 이렇게 하면 모델 크기를 키우는 대신 추론 시점에 더 많은 토큰(계산)을 써서 성능을 올릴 수 있다. 이를 테스트타임 계산 스케일링(test-time compute)이라 부르며, 학습 계산량에 이은 두 번째 스케일링 축으로 여겨진다. 대가는 응답 지연과 토큰 비용이다(8장, 12장). 학습 방법(RLVR)은 이 장의 11절에서 개요를, 11장에서 자세히 다룬다.

환각과 보정

LLM은 사실과 다른 내용을 그럴듯하게 만들어 내곤 한다. 존재하지 않는 논문을 인용하거나, 모르는 사람의 약력을 지어낸다. 이를 환각(hallucination)이라 한다. 다음 토큰 예측의 관점에서 보면 이상한 일이 아니다. 모델은 "그럴듯한 다음 토큰"을 내도록 학습되었고, 사전학습 데이터에서 질문 다음에는 거의 항상 답이 온다. "모르겠다"로 이어지는 문서는 드물다. 드물게 등장한 사실(롱테일 지식)일수록 모델이 정확히 기억하지 못하면서도 형식만은 자신 있게 채운다.

그렇다면 모델이 자기 답의 신뢰도를 알 수는 있을까? 이를 재는 개념이 보정(calibration)이다. 모델이 "확률 70%"라고 말한 답들을 모았을 때 실제로 70%가 맞으면 잘 보정된 것이다. GPT-4 기술 보고서(2023)는 사전학습만 한 모델이 객관식 문제에서 꽤 잘 보정되어 있지만, RLHF 후에는 보정이 나빠진다(과신하게 된다)는 그래프를 보여 줬다. 확신에 찬 답이 선호를 많이 받기 때문으로 해석된다.

그림 7-5. 신뢰도 다이어그램(reliability diagram, 개념도). 예측을 확신도 구간별로 묶어 실제 정답률을 찍는다. 대각선 위에 있으면 잘 보정된 것이고, 아래로 처지면 과신이다. 선호 학습 후 모델이 과신 쪽으로 이동하는 경향이 보고되었다.

환각을 줄이는 실용적 방법은 여러 층에서 쓰인다. 모르면 모른다고 답하는 예시를 SFT·선호 데이터에 넣고, 사실성 평가로 보상을 주며, 무엇보다 모델 기억에만 의존하지 않고 검색한 문서를 문맥에 넣어 근거를 대며 답하게 한다. 이것이 10장의 RAG다. 출처를 인용하게 하면 사용자가 직접 확인할 수 있다는 장점도 있다.

컨텍스트 길이와 모델 연표

모델이 한 번에 볼 수 있는 토큰 수인 컨텍스트 길이(context window)는 몇 년 사이 수백 배 늘었다. 어텐션 계산량은 길이의 제곱에 비례하고 KV 캐시 메모리는 길이에 비례하므로(8장), 이는 FlashAttention 같은 커널 최적화, RoPE 주파수 조정 같은 위치 인코딩 확장 기법(6장), 긴 문서로 하는 추가 학습이 함께 이룬 결과다.

그림 7-6. 대표 모델의 최대 컨텍스트 길이(공개 발표 기준, 로그 눈금). 보라색은 가중치 공개 모델, 분홍색은 API로만 제공되는 모델이다. 긴 문맥을 받는다고 해서 그 안의 정보를 고르게 잘 쓰는 것은 아니며, 중간 부분의 정보를 놓치는 'lost in the middle' 현상이 보고되었다.

모델	연도	파라미터	학습 토큰	컨텍스트	특징
GPT-2	2019	1.5B	WebText 40 GB	1,024	"너무 위험해서" 단계적 공개, 어휘 50,257
GPT-3	2020	175B	300B	2,048	few-shot 인컨텍스트 학습
Chinchilla	2022	70B	1.4T	2,048	계산 최적 스케일링
InstructGPT / ChatGPT	2022	비공개	—	—	SFT + RLHF(PPO)의 대중화
GPT-4	2023	비공개	비공개	8K / 32K	멀티모달 입력
Llama 2	2023	7B / 13B / 70B	2T	4,096	상업 이용 가능한 공개 가중치
Mixtral 8×7B	2023	46.7B (활성 12.9B)	비공개	32K	희소 MoE (6장)
Llama 3 / 3.1	2024	8B / 70B / 405B	~15T	8K → 128K	어휘 128,256, GQA, DPO
DeepSeek-V3	2024	671B (활성 37B)	14.8T	128K	MoE, FP8 학습 (9장)
OpenAI o1	2024	비공개	비공개	128K	강화학습으로 훈련한 긴 추론
DeepSeek-R1	2025	671B (활성 37B)	V3 기반	128K	검증 가능한 보상 RL, 공개 가중치 추론 모델
Llama 4 Scout / Maverick	2025.4	109B (활성 17B) / 400B (활성 17B)	~40T / ~22T	10M / 1M	Meta 첫 MoE, 네이티브 멀티모달
Qwen3	2025.4	0.6B~32B, 235B (활성 22B)	~36T	32K (확장 128K)	생각/비생각 모드 통합, Apache 2.0
Kimi K2	2025.7	1.04T (활성 32.6B)	15.5T	128K	Muon(MuonClip) 학습 (3장)
gpt-oss-120b / 20b	2025.8	117B (활성 5.1B) / 21B (활성 3.6B)	비공개	128K	OpenAI의 공개 가중치 추론 모델, MoE 가중치 MXFP4
Qwen3.5	2026.2	397B (활성 17B)	비공개	262K	Gated DeltaNet 선형 어텐션 3 : 풀 어텐션 1 하이브리드
Muse Spark (Meta)	2026.4	비공개	비공개	—	Meta Superintelligence Labs의 첫 모델, Llama와 달리 가중치 비공개(API)
DeepSeek-V4-Pro / Flash	2026.4	1.6T (활성 49B) / 284B (활성 13B)	32T 이상	1M	압축·희소 어텐션(CSA/HCA), Muon 학습

비공개 모델의 파라미터 수와 데이터 규모는 공식 발표가 없으므로 표에 적지 않았다. 흐름을 요약하면 2019~2022년은 "더 크게", 2022~2024년은 "더 많은 데이터와 정렬", 2024년 이후는 "MoE로 효율적으로, 강화학습과 테스트타임 계산으로 더 깊게"라고 할 수 있다. 2025~2026년에는 대형 오픈 모델의 기본값이 MoE가 되었고(활성 파라미터는 총 파라미터의 수 % 수준), 선형·압축 어텐션 하이브리드로 수십만~100만 토큰 컨텍스트가 흔해졌으며, 거의 모든 플래그십이 생각 모드를 갖춘 추론 모델이 되었다. 공개 가중치 경쟁은 DeepSeek·Qwen·Kimi 같은 중국 연구소와 OpenAI(gpt-oss)가 이끌었고, Llama로 공개 가중치를 주도하던 Meta는 2026년 폐쇄형 Muse Spark로 방향을 틀었다. 아키텍처 세부는 6장, 서빙 측면은 8장에서 다룬다.

추론 모델과 RLVR 개요

8절에서 본 추론 모델이 어떻게 만들어지는지 파이프라인 관점에서 정리해 보자. 그림 7-4의 ④단계, RLVR(Reinforcement Learning with Verifiable Rewards)이 핵심이다. 선호 학습은 "사람이 보기에 어느 쪽이 나은가"라는 흐릿한 신호를 쓰지만, 수학 문제의 최종 답이나 코드의 단위 테스트는 규칙으로 자동 채점할 수 있다. 보상 모델을 학습할 필요가 없고, 보상 모델의 허점을 파고드는 보상 해킹도 훨씬 적다.

$$r(x, y) = \begin{cases} 1 & \text{검증기 통과 (정답 일치, 테스트 통과)} \\ 0 & \text{그 외} \end{cases}, \qquad \max_{\pi_\theta}\ \mathbb{E}_{y\sim\pi_\theta(\cdot\mid x)}\bigl[r(x,y)\bigr] - \beta\,\mathrm{KL}\bigl(\pi_\theta\,\|\,\pi_{ref}\bigr)$$

목표의 모양은 RLHF와 같고, 보상 $r_\phi$가 규칙 기반 검증기로 바뀌었을 뿐이다. 형식 보상(생각을 정해진 태그 안에 쓰는가 등)을 더하기도 한다. 모델은 정답 여부만 알 뿐 "어떻게 풀어야 하는가"는 배우지 않는다. 긴 추론, 검산, 되돌아가기는 보상을 더 자주 받는 행동이라서 스스로 강화된다.

DeepSeek-R1(2025.1)이 쓴 GRPO(Group Relative Policy Optimization; DeepSeekMath, 2024)는 프롬프트 하나에 응답 $G$개를 뽑아 채점하고, 각 응답의 어드밴티지를 그룹 안에서의 상대 점수 $A_i = (r_i - \operatorname{mean}(r))/\operatorname{std}(r)$로 정한다. PPO처럼 가치 함수(critic) 모델을 따로 학습하지 않아도 된다. 모두 맞히거나 모두 틀린 프롬프트는 어드밴티지가 0이 되어 학습 신호가 없으므로, 모델에게 '적당히 어려운' 문제를 고르는 것이 중요하다. GRPO의 단계별 계산과 시뮬레이터, 그리고 추론 모델을 도구와 연결한 에이전트는 11장에서 자세히 다룬다.

그림 7-7. RLVR 루프의 한 스텝(개념도). 같은 문제에 대해 응답 여러 개를 샘플하고, 검증기가 0/1로 채점한다. GRPO는 그룹 평균보다 나은 응답의 확률을 올리고 못한 응답의 확률을 내린다. 이 과정을 수많은 문제에 반복하면 정답에 이르는 긴 추론 습관이 강화된다.

R1-Zero가 보여 준 것

DeepSeek은 SFT 없이 베이스 모델(DeepSeek-V3-Base)에 곧바로 RLVR을 건 R1-Zero를 보고했다. 학습이 진행될수록 응답 길이가 저절로 길어지고, "잠깐, 다시 확인해 보자" 같은 자기 검증과 반성이 나타났다. 아무도 그런 추론 방식을 시범으로 보여 주지 않았다는 점이 중요하다. 다만 읽기 어려운 문장과 언어 섞임 문제가 있어서, 최종 R1은 소량의 긴 추론 예시로 먼저 SFT(cold start)를 한 뒤 RL → 거부 샘플링으로 만든 데이터로 다시 SFT → 다시 RL을 거쳤다.

테스트타임 계산: 생각을 길게, 또는 여러 번

추론 모델의 정확도는 생각 토큰을 더 쓸수록 오른다. 계산을 더 쓰는 방법은 두 갈래다. 하나는 한 응답을 길게(순차적 확장), 다른 하나는 여러 응답을 뽑아 고르기(병렬 확장)다. 병렬 확장의 가장 단순한 형태는 다수결(self-consistency)이다. 한 번 풀 때 정답률이 $p = 0.6$이고 시도가 독립이며 오답이 매번 다르다면, 5번 풀어 3번 이상 같은 답이 나올 확률만 따져도 $\sum_{k\ge3}\binom{5}{k}0.6^k0.4^{5-k} \approx 0.68$로 정답률이 오른다. 검증기가 있으면 정답이 하나라도 나오면 되므로($1 - 0.4^5 \approx 0.99$) 더 크게 오른다. 대신 토큰 비용과 지연이 시도 횟수에 비례한다. 그래서 최근 모델은 Qwen3의 생각/비생각 모드 전환, gpt-oss의 추론 강도(low/medium/high)처럼 생각 예산을 조절하는 장치를 둔다. 생각 토큰이 출력의 대부분을 차지하면서 서빙 비용 구조도 바뀌었다(8장).

증류: 큰 추론 모델의 생각을 작은 모델에

작은 모델에 직접 RLVR을 거는 것보다, 큰 추론 모델이 생성한 추론 흔적으로 작은 모델을 SFT하는 증류(distillation)가 더 싸고 강할 때가 많다. DeepSeek은 R1이 만든 약 80만 개의 샘플로 Qwen·Llama 기반 1.5B~70B 모델을 SFT한 R1-Distill 계열을 공개했고, 같은 크기의 모델에 RL을 직접 건 것보다 증류 쪽이 더 높은 성능을 보였다고 보고했다. 큰 모델이 RL로 찾아낸 추론 패턴을 '정답 데이터'로 바꿔 전달하는 셈이다.

디퓨전 언어 모델은 대안이 될까

이 장의 모든 모델은 자기회귀(autoregressive)였다. 왼쪽부터 한 토큰씩, 길이 $L$인 답에는 모델 호출이 $L$번 필요하다. 이미지 생성을 장악한 디퓨전(diffusion)처럼 "전체를 대충 만든 뒤 여러 번 다듬는" 방식을 텍스트에 쓸 수는 없을까? 토큰은 연속값이 아니라서 가우시안 잡음을 더하는 대신, 토큰을 [M](마스크)으로 바꾸는 것을 '잡음'으로 쓰는 마스크 디퓨전 언어 모델(masked diffusion LM)이 가장 성공적인 형태다.

$$\text{순방향: } t \sim U(0,1),\ \text{각 토큰을 확률 } t \text{로 } [M] \text{으로}, \qquad \mathcal{L}(\theta) = -\,\mathbb{E}_{t,\,x_0,\,x_t}\Bigl[\frac{1}{t}\sum_{i:\,x_t^i = [M]} \log p_\theta\bigl(x_0^i \mid x_t\bigr)\Bigr]$$

$x_0$는 원문, $x_t$는 일부가 가려진 문장이다. 모델은 인과 마스크가 없는 Transformer로, 가려진 모든 위치의 원래 토큰을 양쪽 문맥을 보고 동시에 예측한다. BERT의 마스크 언어 모델과 비슷하지만 마스크 비율이 0~100% 전 범위이고 $1/t$ 가중이 붙어, 이 손실이 로그 우도의 상한(ELBO)이 된다. 그래서 '생성 모델'로 쓸 수 있다.

생성은 거꾸로 간다. 길이 $L$을 정하고 전부 [M]인 상태에서 시작해, $T$번의 스텝마다 모델이 가려진 모든 위치를 예측하고 그중 가장 확신하는 몇 개만 확정한다(나머지는 다시 가린다, low-confidence remasking). $T < L$이면 한 스텝에 여러 토큰이 동시에 정해지므로 모델 호출 수가 줄어든다. 대표 사례는 다음과 같다.

모델	공개	내용
LLaDA 8B	2025.2	2.3T 토큰으로 처음부터 학습한 마스크 디퓨전 LM(연구). 여러 벤치마크에서 같은 규모의 자기회귀 모델(Llama 3 8B)과 비슷한 수준, '역방향 저주'(A는 B다 → B는 A다) 과제에서는 우위
Mercury (Inception Labs)	2025 / 2026.2 Mercury 2	상용 디퓨전 LLM. 코드 모델 Mercury Coder로 시작해, H100에서 초당 1,000 토큰 안팎의 속도를 내세움(회사 발표). Mercury 2는 추론형
Gemini Diffusion (Google)	2025.5	Google I/O에서 공개한 실험적 텍스트 디퓨전 모델. 빠른 생성 속도를 강조

그림 7-8. 자기회귀 생성(왼쪽)과 마스크 디퓨전 생성(오른쪽, 설명용 예시). 색칠한 칸이 그 스텝에 새로 정해진 토큰이고, ⟨/s⟩는 문장 끝 토큰이다. 디퓨전은 문장 끝처럼 확신이 큰 위치부터 채우고, 이미 정해진 양쪽 토큰을 보며 가운데를 메운다. 6토큰을 3번의 모델 호출로 만들었지만, 매 호출은 시퀀스 전체를 처리한다.

SIMULATOR

마스크 디퓨전 생성 (장난감)

길이 L (어절)

디퓨전 스텝 T

확정 순서

재마스킹: 확정된 토큰도 확신이 낮아지면 다시 [M]

생성

후보 분포 (표의 칸을 누르면 그 스텝·위치의 예측을 보여 준다)

—

모델 호출 (디퓨전 / 자기회귀)—

스텝당 확정 토큰 (평균)—

결과 문장 PPL (bigram 기준)—

코퍼스에 있는 이웃 쌍—

재마스킹 횟수—

이 시뮬레이터의 '모델'은 신경망이 아니라, n-gram 절의 교육용 코퍼스(44문장)에서 센 어절 단위 bigram이다. 가려진 칸의 후보 $c$ 점수는 왼쪽 이웃 $a$와 오른쪽 이웃 $b$가 정해져 있을 때 $P(c\mid a)\,P(b\mid c)$(정해지지 않은 쪽은 생략)로, 양쪽 문맥을 보는 아주 작은 양방향 모델이다. 표의 각 행이 한 스텝이고, 색칠한 칸이 그 스텝에 확정된 토큰이다. 해볼 것: ① T = L로 두면 한 스텝에 한 칸씩 채운다. 확신도 순이면 보통 문장 시작(⟨s⟩ 다음)이나 끝(마침표 앞)부터 채워진다. ② T = 1로 내리면 모든 칸을 한 번에 정한다. 이웃끼리 서로를 모른 채 동시에 정해져 "코퍼스에 있는 이웃 쌍"이 줄고 PPL이 나빠진다. 병렬 디코딩의 대가다. ③ T = 2~3에서 재마스킹을 켜 보자. 나중에 정해진 이웃과 어울리지 않는 토큰이 다시 [M]이 되어 고쳐질 기회를 얻는다. ④ '확정 순서'를 무작위로 바꾸면 확신 없는 칸을 먼저 정해 버려 결과가 나빠지는 경우가 많다. ⑤ 맨 아래 행의 토큰을 누르면 그 칸을 [M]으로 되돌리고 나머지를 고정한 채 다시 채운다(인필링). 자기회귀 모델은 오른쪽 문맥을 볼 수 없어 이런 '가운데 채우기'를 그대로는 못 한다. ⑥ '자기회귀와 비교'는 같은 bigram으로 왼쪽부터 L번 뽑은 결과다. 이 장난감에서는 끝(⟨/s⟩)을 미리 보지 못하는 자기회귀가 오히려 불리해 보이지만, 문맥이 길고 모델이 강한 실제 LLM에서는 이런 차이가 그대로 나타나지 않는다. 숫자보다 '생성 순서와 호출 수'의 차이를 보자.

장점과 한계

	자기회귀 (현재 주류)	마스크 디퓨전
모델 호출 수	출력 토큰 수 $L$	스텝 수 $T$ (보통 $T < L$, 줄일수록 품질 저하)
호출 하나의 비용	새 토큰 1개 + KV 캐시 재사용 (8장)	시퀀스 전체(양방향 어텐션이라 표준 KV 캐시를 그대로 못 씀)
문맥	왼쪽만	양쪽. 인필링·편집·역방향 관계에 유리
출력 길이	EOS가 나올 때까지 자유	미리 정한 길이 L(블록 단위 반자기회귀로 완화)
동시 결정 오류	없음(한 번에 하나)	한 스텝에 정한 토큰들은 서로를 모름 → 어긋날 수 있음

현실의 디퓨전 LM은 블록 단위로 왼쪽에서 오른쪽으로 진행하면서 블록 안에서만 디퓨전을 하는 반자기회귀 방식, 블록 사이에 KV 캐시를 쓰는 기법 등으로 단점을 줄이고 있다. 긴 출력을 짧은 시간에 내야 하는 코드 자동완성 같은 곳에서 특히 매력적이다. 하지만 2026년 현재 최상위 범용 모델과 학습·서빙 생태계(KV 캐시, 추측 디코딩, RLVR 도구)는 여전히 자기회귀 중심이며, 디퓨전 LM은 빠르게 성장하는 대안 후보로 보는 것이 정확하다.

핵심 정리

언어 모델은 연쇄법칙 $P(x_{1:T}) = \prod_t P(x_t\mid x_{\lt t})$에 따라 다음 토큰 분포만 학습한다. 손실은 정답 토큰 확률의 −log 평균(교차 엔트로피), 퍼플렉시티는 그 지수다.
n-gram은 카운트로 확률을 추정하지만 문맥 가짓수가 $V^{n-1}$로 폭발해 희소성 문제가 생긴다. 스무딩·백오프로 0 확률을 피한다.
신경망 언어 모델은 임베딩으로 비슷한 토큰끼리 통계를 공유해 일반화한다. 같은 역전파+Adam으로 학습하며, 데이터가 작으면 학습/검증 손실이 벌어지는 과적합이 나타난다.
RNN의 순차 계산과 장거리 정보 손실을 Transformer가 병렬 어텐션으로 해결했고, 이 병렬성이 대규모 스케일링을 가능하게 했다.
학습 계산량은 $C \approx 6ND$. GPU 수 × 최대 FLOPS × MFU로 나누면 학습 기간이 나온다. Llama 3.1 405B는 약 $3.8\times10^{25}$ FLOPs였다.
Chinchilla 스케일링 법칙 $L = E + A/N^\alpha + B/D^\beta$는 계산 최적이 대략 파라미터당 20 토큰임을 보였다. 추론 비용을 고려해 실제 배포 모델은 그보다 훨씬 많은 데이터로 과학습한다.
사전학습 → SFT(채팅 템플릿, 답변 토큰 손실) → 선호 학습(RLHF/PPO, DPO). DPO는 $\beta\log(\pi/\pi_{ref})$를 암묵적 보상으로 써서 비교 데이터에 직접 분류 손실을 건다.
인컨텍스트 학습, CoT, 추론 모델(테스트타임 계산)은 모두 "다음 토큰 예측"의 연장이다. 환각은 그럴듯함을 학습한 결과이며, 보정과 RAG가 대응책이다.
2024~2026년 모델은 계산 최적(파라미터당 ~20 토큰)을 수백~수만 배 넘겨 학습한다(Qwen3-0.6B 약 36T 토큰). MoE는 계산이 활성 파라미터, 메모리가 총 파라미터에 비례해, 총 1T급·활성 수십 B가 플래그십의 표준이 되었다.
추론 모델은 사전학습 → SFT → 선호 학습 뒤에 RLVR(정답·테스트로 자동 채점하는 강화학습, 예: GRPO)을 더해 만든다. 테스트타임 계산(길게 생각하기, 여러 번 풀기)으로 성능을 올리고, 큰 모델의 추론 흔적을 작은 모델에 증류한다.
마스크 디퓨전 LM은 전부 [M]인 시퀀스를 T번의 스텝에 걸쳐 확신도 높은 위치부터 병렬로 채운다. 호출 수는 줄지만 동시 결정 오류·고정 길이·KV 캐시 문제가 있어, 아직 자기회귀가 주류다.

확인 퀴즈

1. 어떤 모델이 평가 텍스트의 모든 토큰에 평균적으로(기하평균) 확률 0.25를 줬다. 퍼플렉시티와 손실(nats)은?

PPL은 확률 기하평균의 역수이므로 1/0.25 = 4이고, 손실은 −ln 0.25 = ln 4 ≈ 1.39 nats(= 2 bits)다. "매 스텝 4개 후보 중에서 균등하게 헷갈리는 수준"으로 읽는다.

2. MLE(스무딩 없는) 4-gram 모델로 평가 문장의 퍼플렉시티가 무한대가 나왔다. 가장 직접적인 원인은?

카운트 비율로 추정하면 본 적 없는 조합은 확률 0이고, 하나라도 0이면 곱 전체가 0, −log는 무한대다. n을 키울수록 이런 일이 더 자주 생긴다(희소성). 스무딩, 백오프, 그리고 근본적으로는 임베딩 기반 신경망 모델이 해법이다.

3. 70B 파라미터 모델을 2T 토큰으로 학습한다. H100(BF16 989 TFLOPS) 2,048개, MFU 40%라면 학습 기간은 대략?

C = 6 × 7×10¹⁰ × 2×10¹² = 8.4×10²³ FLOPs. 초당 2,048 × 989×10¹² × 0.4 ≈ 8.1×10¹⁷ FLOPs이므로 약 1.04×10⁶초 ≈ 12일이다.

4. Chinchilla 분석에 따르면 GPT-3(175B, 300B 토큰)는 같은 계산량에서 어떻게 했어야 손실이 더 낮았을까?

GPT-3는 파라미터당 1.7 토큰으로 계산 최적(약 20)보다 데이터가 크게 부족했다. 같은 C에서 N을 줄이고 D를 늘리면 L(N,D)가 더 낮아진다. 스케일링 시뮬레이터에서 탐침을 GPT-3에 두고 같은 등계산량 선 위 최적점과 비교해 보면 보인다.

5. DPO 손실에서 β를 키우면 어떤 효과가 있는가?

마진은 β × (로그 확률비 차이)이므로 β가 크면 확률비가 조금만 벌어져도 σ(마진)이 1에 가까워지고 기울기 β(1−σ)가 빠르게 줄어든다. 이는 RLHF 목표의 KL 페널티 계수 β와 같은 역할이다.

6. Chain-of-thought가 어려운 문제의 정확도를 높이는 이유로 가장 적절한 것은?

Transformer는 토큰 하나당 층 수만큼의 고정 계산만 한다. 중간 추론을 써 내려가면 계산을 토큰 수만큼 늘리고 중간 결과를 문맥으로 재활용한다. 추론 모델은 이 '테스트타임 계산'을 강화학습으로 체계화했다. 가중치는 추론 중에 바뀌지 않는다.

7. GRPO로 수학 문제 하나에 응답 4개를 샘플했더니 모두 정답(보상 1)이었다. 이 문제에서 생기는 학습 신호는?

GRPO의 어드밴티지는 A_i = (r_i − mean)/std로 그룹 안의 상대 점수다. 모두 맞히거나 모두 틀리면 r_i − mean = 0이라 정책 기울기가 0이 된다. 그래서 너무 쉽거나 너무 어려운 문제는 학습에 쓸모가 적고, 정답률이 중간인 문제를 골라 쓰는 것이 중요하다. GRPO에는 critic이 없다(11장).

8. 길이 256 토큰의 답을 마스크 디퓨전 LM으로 T = 32 스텝에 생성한다. 자기회귀 모델과 비교한 설명으로 옳은 것은?

자기회귀는 256번 호출(토큰당 1번, KV 캐시로 한 번의 비용은 작음)이 필요하다. 마스크 디퓨전은 T = 32번이면 되지만 매번 전체 시퀀스를 처리하고, 한 스텝에 동시에 정하는 8개 토큰은 서로 독립적으로 뽑혀 어긋날 수 있다. T를 줄일수록 빨라지고 품질은 떨어진다. 보통 길이 L은 미리 정한다(또는 블록 단위로 진행한다).

	자기회귀 (현재 주류)	마스크 디퓨전
모델 호출 수	출력 토큰 수 \(L\)	스텝 수 \(T\) (보통 \(T < L\), 줄일수록 품질 저하)
호출 하나의 비용	새 토큰 1개 + KV 캐시 재사용 (8장)	시퀀스 전체(양방향 어텐션이라 표준 KV 캐시를 그대로 못 씀)
문맥	왼쪽만	양쪽. 인필링·편집·역방향 관계에 유리
출력 길이	EOS가 나올 때까지 자유	미리 정한 길이 L(블록 단위 반자기회귀로 완화)
동시 결정 오류	없음(한 번에 하나)	한 스텝에 정한 토큰들은 서로를 모름 → 어긋날 수 있음