LLM 핸드북 2: 학습·정렬

개요

LLM 파이프라인은 대규모 사전학습 → 지도학습(SFT) → 정렬(RLHF/DPO) → 추론 최적화로 이어집니다. 제품의 성격에 따라 일부 단계는 생략되거나 경량화됩니다.

LLM 제작 로드맵

1. 문제 정의 및 타겟 도메인 결정
2. 데이터 수집/정제/라이선스 검토
3. 모델 규모·아키텍처 결정
4. 프리트레이닝(또는 기존 모델 선택)
5. SFT/정렬 데이터 준비
6. 정렬 학습(RLHF/DPO)
7. 추론 최적화 및 배포
8. 평가/모니터링/개선 반복

컴퓨트/예산 계획

• GPU 전략: A100/H100 등급, 클러스터 규모
• 학습 시간: 배치 크기, 시퀀스 길이, 스텝 수에 비례
• 예산 산정: 데이터 준비 + 학습 + 검증 + 추론 비용 합산

아키텍처 선택

• 모델 크기: 파라미터 수와 목표 성능의 균형
• 시퀀스 길이: 컨텍스트 요구사항에 맞는 길이
• 모델 형태: Decoder-only가 일반적, 특수 목적은 Encoder/Encoder-Decoder 고려

프리트레이닝

웹 문서, 코드, 대화 로그 등 대규모 데이터로 다음 토큰 예측을 반복합니다. 이 단계가 모델의 일반 지식을 형성합니다.

• 데이터 품질: 필터링·중복 제거·노이즈 제거가 성능에 직접 영향
• 스케일: 파라미터 수와 데이터량의 균형이 중요
• 컴퓨트 예산: 학습 비용은 대부분 이 단계에서 발생

데이터 큐레이션

LLM 성능의 절반은 데이터 품질에서 결정됩니다. 운영 환경에서 사용할 데이터라면 법적·보안 요구까지 함께 고려해야 합니다.

• 정제: 중복 제거, 스팸 필터, 포맷 통일
• 도메인 균형: 코드/문서/대화 비율을 목표에 맞게 설계
• 민감정보 제거: 개인정보/저작권 위험 데이터 제거

데이터 파이프라인 상세

1. 수집: 웹/코드/대화 데이터 확보
2. 정제: 중복 제거, 노이즈/스팸 필터링
3. 정렬: 언어/도메인 기준으로 분류
4. 샘플링: 목표 분포에 맞게 비율 조정
5. 검증: 품질 샘플링 및 통계 확인

데이터 체크리스트

• 출처 명확성: 데이터 라이선스 확인
• 정합성: 중복/오류/빈 텍스트 제거
• 민감정보: PII/PHI 자동 마스킹 여부
• 버전 관리: 데이터셋 버전 고정

정렬: SFT, RLHF, DPO

사용자 의도에 맞는 답변 스타일을 학습시키는 단계입니다. 생산 환경에서는 빠르고 안정적인 정렬이 중요합니다.

• SFT: 원하는 답변을 직접 지도 데이터로 학습
• RLHF: 인간 선호도를 보상 모델로 반영
• DPO: 선호도 쌍 데이터를 직접 최적화하여 안정적 정렬

정렬 기법 선택 가이드

• SFT: 빠르게 도메인 지식을 주입하고 싶을 때
• RLHF: 미묘한 선호도 조정이 필요할 때
• DPO: 안정성과 재현성이 중요할 때

정렬 데이터 템플릿

# 선호도 쌍 템플릿
prompt: {사용자 질문}
better: {더 좋은 응답}
worse: {덜 좋은 응답}
note: {판단 근거}

학습 스택 구성

• 분산 학습: 데이터 병렬/모델 병렬
• 체크포인트: 중간 저장으로 재학습 비용 절감
• 실험 관리: 실험 파라미터와 결과 기록

학습 설정 예시

아래는 대략적인 형태의 설정 예시입니다. 실제 값은 모델 규모/데이터/예산에 따라 달라집니다.

# 학습 설정 예시 (의사 코드)
model_size: "8B"
sequence_length: 8192
batch_size: 256
learning_rate: 2e-4
warmup_steps: 2000
optimizer: "AdamW"
gradient_checkpointing: true
mixed_precision: "bf16"

학습 최적화 핵심 메커니즘

LLM 학습의 본질은 단순합니다. 손실 함수의 기울기를 계산하고, 그 반대 방향으로 파라미터를 이동시키는 과정을 반복합니다. 실무에서는 이 과정을 안정화하기 위해 워밍업, 클리핑, 누적 배치를 함께 사용합니다.

# 경사 하강법 관점
θ_(t+1) = θ_t - η_t * ∇L(θ_t)

# 대규모 LLM 학습의 실전형 형태
g_t = ∇L_batch(θ_t)
g_t = clip(g_t, max_norm=1.0)   # 기울기 폭발 방지
θ_(t+1) = AdamW(θ_t, g_t, lr_t, beta1, beta2, weight_decay)

# lr_t는 보통 warmup 이후 cosine/linear decay 적용

평가·레드팀·안전 정렬 절차

1. 오프라인 평가셋으로 품질/일관성 확인
2. 레드팀 시나리오로 정책 위반/오용 가능성 점검
3. 안전 정렬 데이터 보강 및 재학습
4. 온라인 A/B 테스트로 실제 성능 검증

배포 전 최종 체크리스트

• 품질: 목표 태스크에서 기준 충족
• 안전: 금지/민감 주제 차단 테스트 통과
• 비용: 예상 비용이 예산 범위 내
• 지연: p95 응답 시간 기준 만족
• 모니터링: 로그/알림/대시보드 준비 완료

학습 파이프라인 의사 코드

// 실전형: 누적 배치 + 클리핑 + 스케줄러 + 체크포인트
function train(loader, model, optimizer, scheduler) {
  const gradAccum = 8;
  let step = 0;

  for (const batch of loader) {
    const loss = model.forward(batch) / gradAccum;
    loss.backward();

    if ((step + 1) % gradAccum === 0) {
      clipGradNorm(model.parameters(), 1.0);
      optimizer.step();
      scheduler.step();
      optimizer.zeroGrad();
    }

    if (step % 1000 === 0) {
      saveCheckpoint(model, { step, loss: loss.item() });
    }
    step += 1;
  }
}

SFT/RLHF/DPO 워크플로우 다이어그램

안전 정책 예시

# 안전 정책 샘플
금지: 개인정보 요청, 불법 행위, 자해 관련 안내
제한: 의료/법률 조언은 일반 정보만 제공
허용: 공개 정보 요약, 교육 목적 설명
응답 톤: 사실 기반, 과장 금지

데이터 파이프라인 자동화 예시

// ETL/검증 의사 코드
function pipeline(sources) {
  const raw = collect(sources);
  const cleaned = clean(raw, { dedupe: true, piiMask: true });
  const sampled = sample(cleaned, { domainMix: "target" });
  validate(sampled, { minLength: 50, lang: "ko" });
  writeDataset(sampled, "train.jsonl");
}

정렬 데이터 수집/라벨링 프로세스

1. 대표 시나리오 정의(질문 유형/도메인)
2. 기본 응답 생성(SFT 또는 기존 모델)
3. 라벨러가 “좋은 응답/나쁜 응답”을 선택
4. 검수 단계에서 불일치/편향 제거
5. 정렬 데이터셋 버전 고정

학습 실패/불안정성 대응

• 손실 발산: 학습률 감소, 배치 크기 축소
• 오버피팅: 정규화, 데이터 증강, 조기 종료
• 모드 붕괴: 데이터 다양성 확대, 샘플링 재조정
• 정렬 실패: 선호도 데이터 재검수, 기준 강화

증상별 즉시 조치 플레이북

# 긴급 안정화 체크 순서
# 1) lr를 30~50% 줄이고 warmup_steps 증가
# 2) clip_grad_norm(max_norm=1.0) 적용
# 3) 배치 축소 + gradient accumulation 증가
# 4) 데이터 이상치(초장문/깨진 토큰) 제거

실험 추적 템플릿

# 실험 카드
실험명: sft-v2-kr
데이터 버전: v1.3
모델 크기: 8B
학습 설정: lr=2e-4, seq=8k
평가 결과: 정확도 0.82, p95 1.4s
결론: 채택/보류/폐기

안전 정렬 데이터셋 설계 가이드

• 금지: 불법 행위, 자해/폭력 조장, 개인정보 요청
• 제한: 의료/법률/금융 조언은 일반 정보 수준
• 허용: 교육 목적 설명, 공개 정보 요약
• 엣지 케이스: 우회 요청, 모호한 질문 포함

품질 회귀 테스트 스위트

정기적으로 실행해 품질 저하를 조기에 감지합니다.

• 기본 세트: 요약, 번역, 분류, 질의응답
• 도메인 세트: 코드 리뷰, 정책 문서, 고객지원
• 안전 세트: 금칙어/유해 요청 대응

평가 자동화 파이프라인 예시

// 배치 평가 → 리포트 생성
function runEval(model, evalSet) {
  const results = [];
  for (const sample of evalSet) {
    const output = model.generate(sample.input);
    results.push({ id: sample.id, score: score(output, sample.gold) });
  }
  writeReport(results, "eval-report.json");
}

RLHF/DPO 구체 단계

1. 기본 모델로 후보 응답 생성
2. 사람이 선호도 쌍 라벨링
3. 보상 모델 학습(RLHF)
4. 정책 모델 업데이트(RLHF) 또는 DPO 최적화
5. 평가셋으로 품질 검증

선호도 데이터 포맷 예시

{"prompt": "이 기능을 설명해줘", "chosen": "명확한 요약", "rejected": "모호한 설명"}

스케일링 법칙과 목표 설정

• 모델 크기 vs 데이터: 균형이 깨지면 수렴이 느려짐
• 목표 지표: 도메인별 정확도/지연/비용의 최적점
• 반복 학습: 작은 모델에서 검증 후 확장

아키텍처별 학습 차이

• Decoder-only: 대화/생성에 강점, 대부분의 LLM 표준
• Encoder-Decoder: 입력-출력 변환에 강점(번역/요약)
• Encoder: 분류/검색에서 효율적

추론 서빙 최적화 심화

• 캐시 전략: KV 캐시 + 응답 캐시를 병행
• 스케줄링: 요청 큐 우선순위와 배치 최적화
• 멀티 GPU: 텐서 병렬/파이프라인 병렬 조합

레드팀 시나리오 템플릿

# 레드팀 시나리오
목표: 금칙어 우회 요청 탐지
시나리오: 단계적 질문으로 민감정보 유도
성공 기준: 정책 위반 응답 차단
실패 기준: 금지 정보 제공

학습 인프라/데브옵스 구성 예시

• 스토리지: 대용량 객체 스토리지 + 데이터 캐시
• 실험 추적: 실험 로그와 체크포인트 관리
• GPU 오케스트레이션: 스케줄러로 학습 자원 관리
• 모니터링: 학습 손실/성능 지표 대시보드

멀티모달 학습/추론

• 비전-언어: 이미지 캡션, 문서 OCR, 멀티모달 QA
• 오디오-언어: 음성 전사, 음성 요약
• 데이터 준비: 이미지/오디오 정제와 메타데이터 정렬

모델 라이프사이클 운영

1. 모델 버전 관리 및 배포 기록
2. 사용량/품질 분석 후 개선 계획 수립
3. 신규 데이터 확보 및 재학습
4. 구버전 모델 폐기/마이그레이션

LLM 제작 비용 산정 상세

• 데이터 비용: 수집, 정제, 라벨링, 검수
• 학습 비용: GPU, 스토리지, 전력
• 검증 비용: 평가셋 구축, 레드팀
• 서빙 비용: 추론 서버, 캐시, 관찰성
• 인건비: 연구, 엔지니어링, 운영

파인튜닝 vs LoRA/어댑터

• 전체 파인튜닝: 최고 성능, 높은 비용
• LoRA/어댑터: 적은 비용, 빠른 실험
• 선택 기준: 데이터 규모, 운영 비용, 유지보수 용이성

LoRA/QLoRA 심층 가이드

LoRA (Low-Rank Adaptation)는 원본 가중치를 고정하고 저랭크 행렬만 학습하여 파인튜닝 비용을 대폭 줄이는 기법입니다. QLoRA는 여기에 4비트 양자화를 결합하여 소비자급 GPU에서도 대형 모델을 파인튜닝할 수 있게 합니다.

LoRA 원리

기존 가중치 행렬 W₀ ∈ ℝ^(d×k)에 대해, LoRA는 업데이트를 두 저랭크 행렬의 곱으로 분해합니다.

# LoRA 업데이트: h = W₀x + ΔWx = W₀x + BAx
# W₀: 고정된 원본 가중치 (d×k)
# B: 저랭크 행렬 (d×r), A: 저랭크 행렬 (r×k), r ≪ min(d,k)
# 학습 파라미터 수: r*(d+k) vs d*k (기존)
# 예: d=4096, k=4096, r=16 → 131K vs 16.7M (1/128)

# alpha: 스케일링 계수 (보통 r과 같거나 2배)
# 최종 출력: h = W₀x + (alpha/r) * BAx

QLoRA 실전 코드 (Python + HuggingFace)

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, TaskType
import torch

# 1. 4비트 양자화 설정 (QLoRA)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",          # NormalFloat4
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,      # 이중 양자화로 추가 절약
)

# 2. 모델 로드
model_id = "meta-llama/Llama-3.1-8B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

# 3. LoRA 설정
lora_config = LoraConfig(
    r=16,                           # 랭크 (작을수록 파라미터 적음)
    lora_alpha=32,                   # 스케일링: alpha/r = 2
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 6,815,744 || all params: 8,036,564,992 || trainable%: 0.085%

SFTTrainer로 학습 (TRL)

from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

dataset = load_dataset("json", data_files="train.jsonl", split="train")

training_args = SFTConfig(
    output_dir="./qlora-output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,   # 유효 배치 = 16
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.1,
    max_seq_length=2048,
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
    dataset_text_field="text",
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)
trainer.train()

학습 완료 후 병합 및 저장

from peft import PeftModel

# LoRA 가중치를 원본에 병합 (추론 오버헤드 제거)
base_model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto"
)
model = PeftModel.from_pretrained(base_model, "./qlora-output/checkpoint-best")
merged = model.merge_and_unload()
merged.save_pretrained("./merged-model")

# Ollama에서 사용하려면 GGUF로 변환
# python llama.cpp/convert_hf_to_gguf.py ./merged-model --outtype q4_k_m

PEFT 기법 비교

Parameter-Efficient Fine-tuning(PEFT) 기법들을 실무 관점에서 비교합니다.

# LoRA 랭크(r)별 성능-비용 트레이드오프 가이드
# r=4:  매우 빠름, 성능 제한 - 빠른 프로토타이핑
# r=8:  균형점 - 대부분의 도메인 적응에 적합
# r=16: 표준 권장값 - 복잡한 태스크
# r=64: 전체 파인튜닝에 가까운 성능 - 고품질 필요 시
# r=128: 특수 도메인 대규모 데이터셋

커리큘럼 학습과 데이터 믹싱

훈련 데이터의 순서와 비율을 설계하는 전략입니다. 무작위 섞기보다 체계적인 커리큘럼이 수렴 속도와 최종 성능을 향상시킵니다.

데이터 믹싱 전략

import random
from datasets import concatenate_datasets, load_dataset

# 비율 기반 데이터 믹싱
DOMAIN_MIX = {
    "general": 0.5,    # 일반 지식 50%
    "code": 0.3,       # 코드 30%
    "domain": 0.2,     # 특화 도메인 20%
}

def build_mixed_dataset(total_size: int):
    datasets = []
    for domain, ratio in DOMAIN_MIX.items():
        ds = load_dataset(f"data/{domain}", split="train")
        n = int(total_size * ratio)
        ds = ds.select(range(min(n, len(ds))))
        datasets.append(ds)
    mixed = concatenate_datasets(datasets)
    return mixed.shuffle(seed=42)

운영 리포트 템플릿

# 월간 운영 리포트
요약: 품질/비용/안전 요약
품질: 정확도, 사용자 만족도
비용: 총 토큰 비용, 캐시 히트율
안전: 정책 위반 건수, 차단율
개선 계획: 다음 달 개선 항목

데이터 저작권/라이선스 리스크

• 출처 불명 데이터: 법적 리스크가 가장 큼
• 오픈소스 코드: 라이선스 의무(상업 사용 제한 등) 확인
• 사용자 데이터: 이용약관/개인정보보호법 준수

모델 검증 벤치마크 설계

• 기본 벤치마크: 요약, 분류, 질문응답
• 도메인 벤치마크: 실제 고객 데이터 기반 테스트
• 안전 벤치마크: 금지 요청, 우회 시도

모델 폐기 및 데이터 삭제 절차

1. 폐기 대상 모델 버전 고정 및 백업
2. 데이터 보존 정책에 따른 삭제
3. 운영 시스템에서 모델 엔드포인트 제거
4. 감사 로그에 폐기 기록 남김

도메인별 파인튜닝 데이터 예시

• 코딩: 코드 리뷰 코멘트, 리팩터링 전/후 쌍
• 문서: 정책 요약, 표준 문서 Q&A
• 지원: 티켓 요약, FAQ 응답 템플릿

모델 성능 드리프트 감지

• 지표 모니터링: 정확도, 안전 위반율, 재질문 비율
• 데이터 분포: 입력 길이/도메인 분포 변화 감지
• 경보: 임계값 초과 시 재평가 트리거

SLA/SLO 템플릿

# 서비스 수준 목표
가용성: 99.9%
지연: p95 < 2.0s
품질: 평가셋 정확도 0.8 이상
안전: 정책 위반율 < 0.1%

모델/데이터 윤리 가이드라인

• 공정성: 편향된 데이터 분포 감시
• 투명성: 모델 한계/오류 가능성 명시
• 책임성: 피해 발생 시 대응 절차 마련
• 프라이버시: 개인 정보 최소 수집

예산 계산 사례

조직 내 역할 분담

• 리서치: 모델/학습 전략 수립
• ML 엔지니어: 학습 파이프라인 구현
• 플랫폼: 서빙/인프라 운영
• 보안/법무: 데이터/정책 검토

추론·RAG·도구 사용 분리 안내

학습·정렬 이후 단계인 추론 최적화, RAG 파이프라인, 도구 사용 패턴, 제공자별 API 연동 내용은 LLM 핸드북 4: 추론·RAG·도구사용으로 분리했습니다.

참고자료

• 프롬프트 기본
• MCP란?
• Ollama 고급 활용