LLM·트랜스포머

LLM / 17번째 글

LLM 사전학습: 수조 개 토큰으로 무엇을 배우나

LLM 사전학습의 전체 파이프라인을 해설한다. 데이터 수집·필터링·중복 제거·토큰화·Document Packing, 분산 학습 전략(Data/Tensor/Pipeline Parallelism), Chinchilla 스케일링 법칙, 체크포인트 관리까지 실전 코드와 함께 완전히 다룬다.

PALDYN Team32 MIN READ

지난 글에서 LLM이 왜 혁명적인지, 창발적 능력의 정체가 무엇인지를 살펴봤다. 여기서는 그 능력이 어디서 오는지를 파고든다. 사전학습(Pre-training)은 아무것도 모르는 모델에 수조 개의 토큰을 읽혀 언어의 통계적 구조와 세계에 대한 지식을 동시에 새겨 넣는 단계이고, LLM을 만드는 데 드는 계산의 대부분이 여기서 쓰인다. 이 글은 그 단계를 데이터, 계산, 안정성, 평가의 순서로 따라간다. 무엇을 읽히는지, 몇 대의 GPU로 며칠을 돌리는지, 도중에 무엇이 깨지는지, 끝난 모델을 무엇으로 판단하는지가 각 절의 질문이다.

사전학습의 목표

다음 토큰 예측

사전학습의 목표는 단 하나, 다음 토큰 예측이다. 토큰은 모델이 글을 자르는 단위로 낱말 하나일 때도 있고 낱말 조각일 때도 있는데, 모델은 앞의 토큰 T1,…,TnT_1, \dots, T_n 을 보고 다음 토큰 Tn+1T_{n+1} 이 무엇일지 확률 분포를 낸다. 모델 안에는 수십억에서 수천억 개의 숫자가 들어 있고 이 숫자들이 그 분포를 정한다. 값을 바꿀 수 있는 이 숫자들이 파라미터이고, 예측이 정답에 가까워지도록 파라미터를 조금씩 옮기는 절차가 학습이다.

목표가 이렇게 단순한데도 모델이 문법만이 아니라 사실과 추론까지 배우는 이유는 다음 토큰을 맞히는 데 그것들이 필요하기 때문이다. 「대한민국의 수도는」 뒤를 맞히려면 지리를 알아야 하고, 코드의 다음 줄을 맞히려면 앞 줄이 무슨 일을 하는지 알아야 한다. 정답 라벨을 사람이 붙일 필요가 없다는 점도 크다. 글 자체가 정답을 들고 있으므로 웹에 있는 텍스트를 거의 그대로 학습 데이터로 쓸 수 있고, 이것이 데이터 규모를 수조 토큰까지 키울 수 있었던 바탕이다.

손실과 perplexity

예측이 얼마나 틀렸는지는 교차 엔트로피 손실로 잰다. 정답 토큰에 모델이 준 확률의 로그를 음수로 뒤집어 평균 낸 값이다.

L=−1n∑t=1nlog⁡pθ(Tt+1∣T1,…,Tt)\mathcal{L} = -\frac{1}{n}\sum_{t=1}^{n} \log p_\theta(T_{t+1} \mid T_1, \dots, T_t)

정답에 확률 1을 주면 손실이 0이고, 확률이 낮을수록 손실이 커진다. 이 손실에 지수를 씌운 eLe^{\mathcal{L}} 이 perplexity인데, 모델이 매 자리에서 평균 몇 개의 후보 사이에서 망설이는지로 읽으면 된다. perplexity가 10이면 열 개 중 하나를 고르는 정도로 헷갈린다는 뜻이다. 아래 코드가 그 손실을 구현한 것으로, 라벨을 한 칸 밀어 각 위치가 자기 다음 토큰을 정답으로 갖게 만드는 것이 요점이다.

# 사전학습 손실 함수 (Causal LM)
import torch
import torch.nn as nn

class CausalLMLoss(nn.Module):
    def __init__(self):
        super().__init__()
        self.ce = nn.CrossEntropyLoss(ignore_index=-100)

    def forward(self, logits, labels):
        # logits: (B, T, V) — 각 위치에서 어휘 크기 V의 확률
        # labels: (B, T)    — 정답 토큰 ID
        # 1칸 밀어서 '다음 토큰' 예측 구조 구성
        shift_logits = logits[:, :-1].contiguous()
        shift_labels = labels[:, 1:].contiguous()
        return self.ce(
            shift_logits.view(-1, shift_logits.size(-1)),
            shift_labels.view(-1),
        )

데이터 수집과 정제

LLM 사전학습 파이프라인

데이터 출처

사전학습 데이터는 많다고 좋은 것이 아니다. 같은 계산을 쓴다면 질 낮은 문서를 읽히는 것은 그만큼 좋은 문서를 덜 읽히는 일이라, 데이터 품질이 곧 모델 품질이 된다. 출처는 대개 다음 갈래로 나뉜다.

  • Common Crawl — 웹 전체를 주기적으로 긁은 스냅샷이다. 양은 압도적이지만 광고, 메뉴, 스팸이 섞여 있어 가장 많이 걸러 낸다.
  • 책 — 긴 문맥을 따라가는 능력과 서사적 추론에 기여한다. 저작권 문제로 무엇을 쓸 수 있는지가 계속 바뀌는 갈래다.
  • 코드 — GitHub 같은 공개 저장소다. 코딩 능력은 물론 단계를 밟는 추론에도 도움이 된다는 관찰이 많다.
  • 백과사전 — Wikipedia처럼 사실 밀도가 높은 문서다. 양은 작지만 정확한 사실의 핵심 출처다.
  • 논문 — ArXiv, PubMed 같은 학술 문서다. 전문 지식과 수식, 논증하는 글쓰기를 배운다.

품질 필터링

웹 문서를 거르는 첫 단계는 규칙이다. 너무 짧은 문서, 글자보다 기호가 많은 문서, 같은 줄이 되풀이되는 문서, 원하는 언어가 아닌 문서를 버린다. 아래 함수가 그 규칙들을 모은 형태다. 규칙만으로 안 걸러지는 것은 분류기가 맡는다. 위키백과나 교과서처럼 좋은 글과 무작위 웹 문서를 구별하도록 작은 모델을 훈련시키고 그 점수로 자르는 방식인데, 최근에는 LLM이 매긴 「교육적 가치」 점수로 거르는 데이터셋도 공개되어 있다.

필터에는 대가가 있다. 기준을 세게 잡을수록 남는 데이터의 평균 품질은 오르지만 다양성이 줄고, 분류기가 「좋은 글」의 기준으로 삼은 문체가 표준어·영어·격식체 쪽으로 쏠려 있으면 방언이나 소수 언어, 구어체 문서가 함께 사라진다. 그래서 필터는 한 번 정하고 끝나는 것이 아니라, 작은 모델을 걸러진 데이터로 각각 학습시켜 결과를 비교하며 문턱을 고르는 실험의 대상이다.

import re
from langdetect import detect

def quality_filter(text: str, target_lang: str = "ko") -> bool:
    # 너무 짧은 문서 제거
    words = text.split()
    if len(words) < 100:
        return False

    # 알파벳·한글 비율 체크
    alpha_chars = sum(c.isalpha() for c in text)
    if alpha_chars / max(len(text), 1) < 0.5:
        return False

    # 언어 감지
    try:
        if detect(text) != target_lang:
            return False
    except Exception:
        return False

    # 반복 콘텐츠 감지
    lines = text.split("\n")
    unique_lines = set(lines)
    if len(unique_lines) / max(len(lines), 1) < 0.5:
        return False  # 50% 이상 줄이 중복

    return True

중복 제거

같은 텍스트가 학습 데이터에 여러 번 들어 있으면 모델이 그 문장을 통째로 외우는 쪽으로 기울고, 같은 계산으로 볼 수 있었던 새 문서의 자리를 빼앗는다. 중복을 걷어 낸 데이터로 학습하면 학습 데이터를 그대로 토해 내는 일이 줄었다는 연구도 있다. 중복은 세 층에서 생긴다. 바이트까지 같은 정확 중복은 문서의 해시값만 비교하면 잡힌다. 날짜나 광고 한 줄만 다른 근사 중복은 해시로는 안 잡혀서 문서끼리 얼마나 겹치는지를 재야 한다. 그리고 한 문서 안에서 같은 문단이 되풀이되는 문서 내 중복은 줄 단위 비율로 거른다.

근사 중복을 재는 기준은 보통 자카드 유사도, 곧 두 문서의 낱말 조각 집합에서 교집합이 합집합의 몇 퍼센트인지다. 수십억 문서를 둘씩 다 비교하면 계산이 불가능하므로 MinHash를 쓴다. 문서마다 해시 함수 128개를 돌려 각각의 최솟값만 남긴 서명을 만들면, 두 서명에서 값이 일치하는 칸의 비율이 자카드 유사도의 추정치가 된다. 여기에 서명을 여러 띠로 잘라 한 띠라도 같은 문서끼리만 후보로 묶는 LSH를 얹으면 비교할 짝이 크게 준다. 아래 코드의 threshold=0.8이 「80% 넘게 겹치면 같은 문서로 친다」는 문턱이다. SimHash는 문서 하나를 비트열 하나로 줄이고 비트가 몇 개 다른지로 가까움을 재는 다른 방식으로, 웹 검색의 중복 페이지 탐지에서 오래 쓰였다.

from datasketch import MinHash, MinHashLSH

def text_to_minhash(text: str, num_perm: int = 128) -> MinHash:
    m = MinHash(num_perm=num_perm)
    for word in text.lower().split():
        m.update(word.encode("utf-8"))
    return m

# LSH 인덱스 구성
lsh = MinHashLSH(threshold=0.8, num_perm=128)

seen_ids = set()
for doc_id, text in enumerate(documents):
    mh = text_to_minhash(text)
    if doc_id not in lsh:
        result = lsh.query(mh)
        if not result:  # 유사 문서 없음 → 추가
            lsh.insert(str(doc_id), mh)
            seen_ids.add(doc_id)
        # 유사 문서 있음 → 중복으로 제거

deduped = [doc for i, doc in enumerate(documents) if i in seen_ids]

단계별 감소

이 단계들을 지나면 원래 크롤의 상당 부분이 사라진다. 흔히 웹 원본의 10% 안팎만 남는다고 말하지만, 공개된 웹 데이터셋 보고들을 보면 남는 비율은 파이프라인과 기준에 따라 한 자릿수 퍼센트에서 수십 퍼센트까지 크게 갈린다. 대체로 언어 판별과 규칙 필터에서 가장 많이 떨어지고, 중복 제거에서 또 크게 준다. 웹에는 같은 글을 퍼 온 페이지가 생각보다 훨씬 많기 때문이다. 정확한 비율을 외우는 것보다 중요한 것은 순서다. 싼 규칙을 먼저 돌려 양을 줄이고, 비싼 분류기와 근사 중복 탐지는 줄어든 데이터에만 돌린다.

데이터 믹스와 토큰화

데이터 믹스

갈래별 데이터를 어떤 비율로 섞을지가 데이터 믹스다. 갈래마다 양이 다르므로 있는 그대로 섞으면 웹 문서가 압도하는데, 그 비율이 곧 모델이 무엇을 잘하게 될지를 정한다. 코드와 수학을 늘리면 단계를 밟는 추론과 형식을 지키는 능력이 좋아진다는 관찰이 여러 모델 보고에서 나왔고, 그 대가로 일반 지식이나 다국어 비중이 줄어든다. 작은 갈래는 몇 번 반복해서 비중을 올리기도 하는데, 같은 데이터를 여러 바퀴 도는 것은 어느 정도까지는 새 데이터와 비슷한 효과를 내지만 바퀴가 늘수록 이득이 빠르게 줄어든다는 연구가 있다. 한 바퀴를 에폭이라 하며, 사전학습은 대부분의 데이터를 한 에폭 안쪽으로 읽힌다.

어닐링

믹스는 학습 내내 같을 필요가 없다. 파라미터를 한 번에 얼마나 옮길지 정하는 배율이 학습률인데, 그 학습률을 0 가까이로 내리는 학습의 마지막 구간에 품질이 높은 데이터의 비중을 올리는 방식을 어닐링이라 부르고, Llama 3를 비롯한 여러 공개 보고가 이런 마무리 단계를 언급한다. 학습률이 낮아 파라미터가 크게 움직이지 않는 구간이라 좋은 데이터가 모델에 마지막 결을 입힌다고 보면 된다. 이 구간에 넣는 고품질 데이터는 나중에 평가할 벤치마크 문제와 겹치기 쉬워서, 벤치마크가 학습 데이터에 섞여 드는 일을 이 단계에서 특히 조심한다.

문서 패킹

걸러진 문서는 토크나이저가 정수 ID 시퀀스로 바꾼다. 토크나이저가 글을 어떤 조각으로 자르는지는 BPE 글에서 다뤘다. 그런데 문서 길이가 제각각이라 컨텍스트 길이 4,096짜리 칸에 문서 하나씩 넣으면 짧은 문서 뒤가 전부 패딩으로 채워지고, 그 패딩에 쓴 계산은 버려진다. 그래서 사전학습에서는 여러 문서를 문서 끝 토큰으로 이어 붙인 뒤 칸 크기대로 자르는 문서 패킹을 쓴다. 한 칸 안에 서로 무관한 문서가 함께 들어가므로 앞 문서가 뒤 문서의 예측에 섞여 들 수 있는데, 문서 경계에서 어텐션을 끊는 마스크로 막는 구현도 있다.

데이터 처리 파이프라인 코드

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")
CONTEXT_LEN = 4096

def pack_documents(texts: list[str]) -> list[list[int]]:
    """여러 문서를 이어 붙여 context_len 크기 청크 생성"""
    # EOS 토큰으로 문서 경계 표시
    eos = tokenizer.eos_token_id
    all_ids = []
    for text in texts:
        all_ids.extend(tokenizer.encode(text))
        all_ids.append(eos)  # 문서 경계

    # CONTEXT_LEN 길이로 분할
    chunks = [
        all_ids[i : i + CONTEXT_LEN]
        for i in range(0, len(all_ids), CONTEXT_LEN)
        if len(all_ids[i : i + CONTEXT_LEN]) == CONTEXT_LEN
    ]
    return chunks

스케일링 법칙과 학습 비용

Chinchilla 법칙

Kaplan 등(2020)은 LLM의 손실이 파라미터 수 NN, 학습 토큰 수 DD, 계산량 CC 의 거듭제곱 꼴로 꽤 정확히 예측된다는 것을 보였다. 계산 예산이 정해져 있을 때 그것을 모델 크기와 데이터 양에 어떻게 나눌지가 다음 질문이었고, Hoffmann 등(2022)의 Chinchilla 논문이 다시 잰 답은 둘을 같은 비율로 키우라는 것이었다. 어림 규칙으로 줄이면 다음과 같다.

Doptimal≈20×ND_{\text{optimal}} \approx 20 \times N

70B 모델이라면 약 1.4T 토큰이 계산 최적이다. 이 기준으로 보면 GPT-3(175B, 300B 토큰)는 크기에 비해 데이터를 덜 읽은 모델이었고, 실제로 Chinchilla(70B, 1.4T 토큰)는 파라미터가 절반에도 못 미치는데 대부분 벤치마크에서 GPT-3를 넘었다. 스케일링 법칙 자체는 스케일링 법칙 글에서 더 자세히 다룬다.

추론까지 본 비용

Chinchilla 비율은 「학습 계산을 가장 효율적으로 쓰는 법」이지 「가장 좋은 모델을 만드는 법」이 아니다. 모델은 한 번 학습하고 수억 번 추론하는데, 추론 비용은 파라미터 수에 비례한다. 그래서 요즘 공개 모델은 일부러 작은 모델에 비율을 훨씬 넘는 토큰을 읽힌다. Meta는 Llama 3를 15조 개가 넘는 토큰으로 학습했다고 밝혔는데, 8B 모델 기준이면 파라미터 하나당 1,800 토큰이 넘어 Chinchilla 비율의 90배를 웃돈다. 학습 계산을 더 써서라도 쓰는 동안 싼 모델을 얻겠다는 선택이다.

학습 비용 계산

트랜스포머 학습에 드는 계산은 토큰 하나당 파라미터 하나에 약 6번의 부동소수점 연산으로 어림한다. 순전파에 2번, 역전파에 그 두 배인 4번이다. 부동소수점 연산 횟수를 FLOPs라 부르면 총 계산량은 다음과 같다.

C≈6⋅N⋅DC \approx 6 \cdot N \cdot D

7B 모델을 2T 토큰으로 학습한다고 하자. 6×7×109×2×1012=8.4×10226 \times 7\times10^{9} \times 2\times10^{12} = 8.4\times10^{22} FLOPs다. H100 한 장의 bf16 행렬 연산 최대 성능은 약 989989 TFLOPS인데, 실제 학습에서는 통신과 메모리 대기 때문에 그 일부만 쓴다. 최대 성능 대비 실제로 쓴 비율을 MFU라 하고, 대규모 학습에서 40% 안팎이면 잘 돌린 편으로 친다. MFU 40%면 장당 초당 약 3.96×10143.96\times10^{14} FLOPs이므로 걸리는 시간은 8.4×1022÷3.96×1014≈2.1×1088.4\times10^{22} \div 3.96\times10^{14} \approx 2.1\times10^{8} 초, 곧 약 5만 9천 GPU-시간이다. GPU 1,024장이면 58시간 남짓, 이틀 반이다. 클라우드 대여료를 장당 시간당 2달러로 잡으면 약 12만 달러가 된다.

같은 식으로 70B 모델을 15T 토큰으로 학습하면 6.3×10246.3\times10^{24} FLOPs, 약 440만 GPU-시간이 나온다. 공개된 모델 카드들이 밝힌 실제 GPU-시간은 이런 추정보다 대개 큰데, MFU가 가정보다 낮은 구간, 장애로 다시 돌린 구간, 본 학습 전의 작은 실험들이 계산에 빠져 있기 때문이다. 그래서 6ND는 예산의 바닥을 잡는 식이지 청구서가 아니다. 대여료 가정이 바뀌면 금액도 비례해 바뀐다는 점도 함께 기억해 둔다.

분산 학습

데이터 병렬과 ZeRO

70B 모델은 GPU 한 장에 올라가지 않는다. 혼합 정밀도로 Adam 옵티마이저를 쓰면 파라미터 하나당 bf16 가중치 2바이트, 그래디언트 2바이트, fp32 원본 가중치와 Adam의 두 이동 평균 12바이트로 약 16바이트가 든다. 그래디언트는 손실을 줄이려면 각 파라미터를 어느 쪽으로 얼마나 옮겨야 하는지 알려 주는 값이고, 옵티마이저는 그 그래디언트로 실제 이동량을 정하는 규칙인데 Adam은 그 규칙을 위해 파라미터마다 상태 둘을 따로 들고 있다. 70B × 16바이트면 1.12TB로, 80GB GPU 열네 장을 상태만으로 채우고 그 위에 활성값이 더 든다.

데이터 병렬은 같은 모델을 GPU마다 복사하고 배치를 나눠 각자 그래디언트를 구한 뒤 평균을 맞추는 방식이다. 가장 단순하고 통신도 한 스텝에 한 번이지만, 모델 전체가 각 GPU에 들어가야 한다는 전제가 있다. 그 전제를 푸는 것이 ZeRO다. 복사본마다 똑같이 들고 있던 옵티마이저 상태, 그래디언트, 가중치를 GPU들이 나눠 들고 필요할 때만 모아 쓴다. 아래 코드의 Accelerate 예제는 데이터 병렬 구성이고, ZeRO나 FSDP를 켜는 것은 설정 파일로 고른다.

# Hugging Face Accelerate로 간단한 분산 학습
from accelerate import Accelerator
from transformers import AutoModelForCausalLM, get_scheduler
import torch

accelerator = Accelerator(mixed_precision="bf16")  # bfloat16 혼합정밀도

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=0.1)

model, optimizer = accelerator.prepare(model, optimizer)

# 학습 루프
for batch in train_dataloader:
    with accelerator.accumulate(model):
        outputs = model(**batch, labels=batch["input_ids"])
        loss = outputs.loss
        accelerator.backward(loss)
        accelerator.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        optimizer.zero_grad()

텐서 병렬

텐서 병렬은 층 하나의 가중치 행렬을 열이나 행으로 잘라 여러 GPU가 한 조각씩 곱하게 하는 방식이다. 층마다 중간 결과를 모아야 해서 통신이 아주 잦으므로, NVLink로 묶인 한 노드 안의 GPU끼리만 쓰는 것이 보통이다. 한 노드가 8장이면 텐서 병렬 폭도 대개 8이 상한이다.

파이프라인 병렬

파이프라인 병렬은 층들을 앞에서부터 묶어 GPU마다 한 구간씩 맡기는 방식이다. 1번 GPU가 앞 층을 계산해 결과를 2번에 넘기는 식이라 통신은 구간 경계에서만 일어나고, 그래서 노드 사이처럼 느린 연결에도 쓸 수 있다. 약점은 앞 구간이 계산하는 동안 뒤 구간이 놀고 있다는 것이다. 이 노는 시간을 파이프라인 버블이라 하고, 배치를 작은 마이크로배치로 잘라 구간들이 서로 다른 마이크로배치를 동시에 처리하게 해서 줄인다.

3D 병렬 조합

셋은 서로를 대신하지 않고 겹쳐 쓴다. 이것이 3D 병렬이다. 고르는 순서는 통신이 잦은 것부터 빠른 연결에 놓는 것이다. 텐서 병렬은 노드 안, 파이프라인 병렬은 모델이 다 올라갈 만큼만 노드 사이, 남은 GPU는 전부 데이터 병렬이다. GPU 1,024장으로 70B를 학습한다면 텐서 8 × 파이프라인 4로 모델 한 벌을 32장에 펴고, 그런 벌을 데이터 병렬 32개로 돌리는 구성이 하나의 예다. 이때 GPU 한 장이 드는 상태는 1.12TB를 32로 나눈 35GB이고, ZeRO로 옵티마이저 상태를 데이터 병렬 축에도 나누면 더 줄어든다.

3D 병렬 배치

학습 안정성

학습률 스케줄

앞에서 본 학습률은 학습 내내 같은 값이 아니다. 학습 초반에는 파라미터가 무작위라 그래디언트가 크고 방향도 들쭉날쭉해서, 처음부터 큰 학습률을 쓰면 발산한다. 그래서 수천 스텝 동안 0에서 목표값까지 천천히 올리는 워밍업을 두고, 이후에는 코사인 곡선을 따라 끝까지 낮춘다. 그래디언트의 크기가 정해 둔 값(흔히 1.0)을 넘으면 그만큼 줄여 쓰는 그래디언트 클리핑도 같은 목적의 안전장치다. 학습 중에는 손실, 그래디언트 크기, 학습률을 W&B나 TensorBoard 같은 도구로 실시간으로 본다.

손실 스파이크

몇 주짜리 학습에서 가장 흔한 사고는 잘 내려가던 손실이 갑자기 치솟는 손실 스파이크다. 잠깐 튀었다가 저절로 돌아오는 경우도 있지만, 그대로 발산해 학습이 망가지는 경우도 있다. 원인은 하나로 정해지지 않는다. 특정 배치의 이상한 데이터, 학습률이 그 순간의 곡면에 비해 너무 큰 것, 어텐션 값이 커져 bf16의 표현 범위를 넘는 수치 문제가 자주 거론된다. 스파이크 직전에는 그래디언트 크기가 먼저 불어나는 일이 많아서 그 지표에 경보를 걸어 둔다.

체크포인트와 롤백

대응의 바탕은 체크포인트, 곧 학습 도중의 파라미터와 옵티마이저 상태를 통째로 저장해 둔 파일이다. 체크포인트가 있으면 스파이크가 났을 때 그 직전 지점으로 되돌아가 다시 돌릴 수 있다. 다만 같은 데이터를 같은 순서로 다시 읽히면 같은 자리에서 또 터지므로, 문제의 구간에 해당하는 배치들을 건너뛰거나 학습률을 잠시 낮춰서 다시 출발한다. PaLM 논문은 스파이크가 시작되기 약 100스텝 전 체크포인트에서 다시 시작하고 배치 200~500개 정도를 건너뛰는 방식을 보고했다. 그 배치가 나쁜 데이터라서라기보다 그 데이터와 그 순간의 파라미터 상태가 맞물린 결과로 보인다는 해석이 붙었다.

그래서 체크포인트 간격은 비용 계산이다. 70B 모델 상태는 1TB가 넘어 저장 한 번에 시간이 들고, 간격이 길면 롤백 때 버리는 계산이 커진다. 수천 장 규모에서는 GPU나 노드 고장도 며칠에 한 번꼴로 일어나므로, 간격을 정할 때는 저장 비용과 고장 빈도를 함께 놓고 잰다.

손실 스파이크 대응 절차

베이스 모델 평가

perplexity의 한계

사전학습을 마친 모델을 베이스 모델이라 부른다. 가장 먼저 보는 지표는 따로 떼어 둔 검증 데이터에서의 perplexity다. 학습 중에 매일 볼 수 있고 손실 곡선과 직접 이어져 있어 학습이 제대로 가는지 판단하기 좋다. 하지만 perplexity가 못 보는 것이 많다. 토크나이저가 다르면 같은 글이 다른 수의 토큰으로 잘리므로 모델끼리 perplexity를 견줄 수 없고, 흔한 문체의 글을 잘 예측하는 능력과 드문 사실을 정확히 아는 능력이 하나의 평균에 섞여 버린다. 사실을 틀리게 이어 써도 문장이 매끄러우면 perplexity는 좋게 나온다.

벤치마크와 오염

그래서 베이스 모델은 지식, 추론, 코드, 수학 벤치마크를 몇 개의 예시를 앞에 붙여 푸는 퓨샷 방식으로 함께 잰다. 아직 지시를 따르도록 학습되지 않았으므로, 문제를 질문으로 던지기보다 예시 몇 개 뒤에 이어 쓰게 하는 형식이 맞다. 여기서 가장 조심할 것이 오염, 곧 벤치마크 문제가 학습 데이터에 섞여 들어간 상태다. 웹에는 유명 벤치마크 문제와 답이 퍼져 있어서 걸러 내지 않으면 모델이 푸는 것이 아니라 외운 것을 꺼내게 되고, 점수가 실력보다 높게 나온다. 학습 데이터와 벤치마크 문항의 겹침을 n-그램으로 검사해 겹친 문항을 따로 보고하는 것이 흔한 대응이다.

베이스 모델의 다음 단계

베이스 모델은 텍스트를 이어 쓰는 데는 뛰어나지만 질문에 답하거나 지시를 따르지는 않는다. 질문을 넣으면 답 대신 비슷한 질문을 이어 쓰기도 하는데, 웹 문서에서 질문 뒤에 자주 오는 것이 또 다른 질문이기 때문이다. 지식은 이미 들어 있고 모자란 것은 「질문 다음에는 답이 온다」는 형식이다. 다음 글에서는 지시와 응답을 짝지은 데이터로 그 형식을 가르치는 인스트럭션 튜닝을 다룬다.


읽어주셔서 감사합니다. 😊

LATEST

LLM·트랜스포머의 최신 글

LLM·트랜스포머2026.08.14

작은 모델을 우리 일에 맞추는 법

파인튜닝이 실제로 고치는 것은 지식이 아니라 행동입니다. 데이터 몇 건이 필요한지, LoRA가 무엇을 바꾸는지, 학습 전에 무엇을 먼저 만들어야 하는지를 정리합니다.

15 MIN
LLM·트랜스포머2026.08.13

작은 모델로 내려도 되는지 판단하는 법

비용·지연·품질은 같은 방향으로 움직이지 않습니다. 폴백을 붙였을 때의 손익분기, 격차가 벌어지는 작업 유형, 그리고 내리기 전에 통과해야 할 네 관문을 정리합니다.

28 MIN
LLM·트랜스포머2026.08.13

작은 모델이 다시 쓸 만해진 이유

10억에서 100억 파라미터 사이의 모델이 다시 실무에 들어오고 있습니다. 무엇이 달라졌는지, 메모리는 어떻게 계산하는지, 무엇을 잘하고 무엇을 못하는지 정리합니다.

32 MIN