LLM 이론 기초: 확률·Transformer·스케일링

개요

LLM은 "다음 토큰의 확률"을 예측하는 모델입니다. 이 단순한 가정이 정보이론, 일반화, 환각 같은 현상으로 연결되고, Transformer 아키텍처와 스케일링 법칙이 실질적인 성능을 결정합니다. 이 페이지는 기초부터 심화까지 핵심 이론을 실무 관점에서 풀어 설명합니다.

확률적 생성의 의미

모델은 정답을 "하나"로 내지 않고, 가능한 답변의 분포를 학습합니다. 따라서 응답은 항상 확률적으로 결정됩니다.

• 온도(temperature): 분포를 넓히거나 좁힘 — 높을수록 다양한 토큰이 선택될 확률 증가
• Top-k/Top-p: 후보 토큰의 범위를 제한하여 불필요한 노이즈 차단
• 샘플링 vs 결정론: 창의성(높은 온도)과 일관성(낮은 온도)의 균형

온도 파라미터의 수학적 효과

온도(T)는 softmax 함수의 분포를 조절합니다. 각 토큰 i의 선택 확률은 다음과 같이 계산됩니다:

# 온도가 적용된 Softmax
P(token_i) = exp(logit_i / T) / ∑ exp(logit_j / T)

# T → 0 : 가장 높은 logit의 토큰만 선택 (결정론적)
# T = 1 : 원래 분포 그대로
# T → ∞ : 균등 분포 (완전 랜덤)

예를 들어 3개 토큰의 logit이 [2.0, 1.0, 0.5]일 때, 온도에 따른 확률 변화는 다음과 같습니다:

# logits = [2.0, 1.0, 0.5]

# T=0.1 (매우 낮음) → 거의 결정론적
P = [1.000, 0.000, 0.000]  # 최고 확률 토큰만 선택

# T=0.7 (낮음) → 안정적이되 약간의 변동
P = [0.757, 0.166, 0.077]  # 1등 토큰에 집중

# T=1.0 (기본) → 원래 분포
P = [0.594, 0.219, 0.133]  # 자연스러운 분포

# T=1.5 (높음) → 평탄한 분포
P = [0.463, 0.281, 0.218]  # 2·3등도 자주 선택됨

Top-p (Nucleus) 샘플링

Top-p 샘플링은 확률을 내림차순으로 정렬한 후, 누적 확률이 p에 도달할 때까지의 토큰만 후보로 남깁니다. 이렇게 하면 확률이 극히 낮은 "노이즈" 토큰을 자연스럽게 제외합니다.

# Top-p=0.9 예시
# 전체 토큰 확률 분포 (내림차순 정렬):
"the"    : 0.35  → 누적 0.35 ✓
"a"      : 0.25  → 누적 0.60 ✓
"this"   : 0.15  → 누적 0.75 ✓
"that"   : 0.10  → 누적 0.85 ✓
"an"     : 0.08  → 누적 0.93 ✓ ← p=0.9 도달, 여기까지 포함
"my"     : 0.04  → 제외
"some"   : 0.02  → 제외
"..."    : 0.01  → 제외

# 결과: 상위 5개 토큰 중에서만 재샘플링
# Top-k와 달리 동적으로 후보 수가 조절되는 것이 장점

상황별 추천 파라미터

수학 기초: 선형대수

LLM의 내부 동작을 이해하려면 최소한의 선형대수와 미적분 직관이 필요합니다. 이 섹션에서는 AI/ML에서 가장 빈번하게 사용되는 수학적 개념들을 다룹니다.

벡터: 단어를 숫자로

벡터는 숫자를 일렬로 나열한 것입니다. LLM에서는 모든 단어나 토큰을 벡터로 표현합니다. 이를 임베딩(embedding)이라고 합니다.

# 토큰 임베딩 예시 (단순화한 4차원)
"고양이"  →  [0.2, -0.5, 1.3, 0.8]
"강아지"  →  [0.3, -0.4, 1.1, 0.7]
"자동차"  →  [-0.9, 0.7, -0.2, 1.5]

# "고양이"와 "강아지"는 숫자가 비슷 → 의미도 유사
# "고양이"와 "자동차"는 숫자가 다름 → 의미도 다름

실제 LLM에서는 차원이 훨씬 높습니다(예: 4096차원). 높은 차원 공간에서 유사한 의미를 가진 단어들이 서로 가까이 위치하게 됩니다.

내적: 유사도를 측정하는 핵심 연산

내적(dot product)은 두 벡터의 유사도를 측정하는 기본 연산입니다.Attention 메커니즘의 핵심이 바로 이 내적 연산입니다.

# 내적 정의
v · w = ∑ v_i × w_i = v₁w₁ + v₂w₂ + ... + vₙwₙ

# 구체적인 계산 예시
[1, 2, 3] · [4, 5, 6] = 1×4 + 2×5 + 3×6 = 4 + 10 + 18 = 32

# 기하학적 해석:
# - 두 벡터가 같은 방향 → 내적 > 0 (양수)
# - 두 벡터가 수직(90°) → 내적 = 0
# - 두 벡터가 반대 방향 → 내적 < 0 (음수)

행렬: 벡터의 모음

행렬은 숫자를 2차원 형태로 나열한 것입니다. LLM에서 행렬은 여러 가지 의미를 가집니다:

• 가중치 행렬: 행과 열이 있는 학습 가능한 파라미터
• 임베딩 행렬: 모든 토큰의 임베딩을 행으로 저장
• 어텐션 스코어 행렬: 토큰 쌍 간 유사도를 저장

# 행렬 예시: 3개의 토큰 임베딩 (각 4차원)
# 각 행 = 하나의 토큰
Embeddings = [
  [0.2, -0.5, 1.3, 0.8],   # 토큰 1: "The"
  [0.1, -0.3, 0.9, 0.5],   # 토큰 2: "cat"
  [-0.1, 0.2, 0.7, 1.2]    # 토큰 3: "sat"
]

# 행렬의 크기: 3행 × 4열 = 3×4 행렬

행렬 곱셈과 Attention의 연결

Attention에서 Q(Query)와 K(Key)의 유사도를 한꺼번에 구할 때 행렬 곱셈을 사용합니다. 내적을 모든 토큰 쌍에 대해 동시에 계산하는 것입니다.

# 행렬 곱셈: Q(2×3) × K^T(3×2) = Score(2×2)
# Q: 2개 토큰의 Query (각 3차원)
Q = [[1, 0, 2],
     [0, 1, 1]]

# K: 2개 토큰의 Key (각 3차원) → 전치하여 3×2
K = [[1, 2, 0],
     [0, 1, 3]]
K^T = [[1, 0],
        [2, 1],
        [0, 3]]

# 행렬 곱셈 수행
QK^T = [[1×1+0×2+2×0, 1×0+0×1+2×3],
        [0×1+1×2+1×0, 0×0+1×1+1×3]]
     = [[1, 6],
        [2, 4]]

# 결과 해석:
# QK^T[0][1] = 6 → 첫 번째 Query와 두 번째 Key가 매우 유사
# QK^T[1][0] = 2 → 두 번째 Query와 첫 번째 Key의 유사도

행렬의 기하학적 해석: 공간 변환

행렬은 벡터 공간을 변환하는 도구로 이해할 수 있습니다. LLM에서 가중치 행렬은 입력 벡터를 새로운 공간으로 변환하여 "의미 있는 특성"을 추출합니다.

# 2D 회전 행렬 (반시계 방향 45°)
Rotation(45°) = [
  [ cos(45°), -sin(45°) ],
  [ sin(45°),  cos(45°) ]
] ≈ [
  [ 0.707, -0.707 ],
  [ 0.707,  0.707 ]
]

# 벡터 [1, 0] (x축 단위 벡터)에 적용
[0.707, -0.707] × [1] + [0.707, 0.707] × [0]
= [0.707, 0.707]

# 결과: 45° 방향으로 회전됨

# 신경망에서의 변환 의미:
# - 회전: 특성 간 관계 재배열
# - 스케일링: 특성 강조/약화
# - 전치: 특성 축 변환

코사인 유사도

임베딩 벡터 간의 의미적 유사도를 측정할 때 코사인 유사도를 사용합니다. 벡터의 크기에 무관하게 방향만으로 비교하므로, 단어·문장 임베딩 비교의 표준 지표입니다.

# 코사인 유사도 공식
cos(θ) = (A · B) / (|A| × |B|)

# |A|: 벡터 A의 크기 (노름)
# |A| = √(A₁² + A₂² + ... + Aₙ²)

# 결과 범위:
# - 1.0: 같은 방향 (완전히 유사)
# - 0.0: 수직 (무관)
# - -1.0: 반대 방향 (완전히 다름)

# 실제 예시:
# "고양이"와 "강아지" → cos ≈ 0.85 (높은 유사도)
# "고양이"와 "자동차" → cos ≈ 0.12 (낮은 유사도)
# "좋다"와 "나쁘다" → cos ≈ -0.3 (반대 의미)

활성화 함수: 비선형성의 핵심

활성화 함수는 신경망에 비선형성(non-linearity)을 도입합니다. 선형 변환만으로는 복잡한 패턴을 학습할 수 없고, 활성화 함수를 통해 복잡한 결정 경계를 만들 수 있습니다.

ReLU (Rectified Linear Unit)

현대 딥러닝에서 가장 널리 사용되는 활성화 함수입니다. 간단하면서도 효과적이며, gradient vanishing 문제를 완화합니다.

# ReLU 함수 정의
ReLU(x) = max(0, x)

# 미분 (Gradient)
d/dx ReLU(x) = 
  1  if x > 0
  0  if x ≤ 0

# 계산 예시
ReLU(3.5) = 3.5    # 양수 → 그대로 통과
ReLU(-1.2) = 0      # 음수 → 0
ReLU(0)   = 0      # 영 → 0

Sigmoid: 확률로의 변환

Sigmoid는 임의의 실수를 0~1 사이의 값으로 압축합니다. 이 특성으로 인해 확률 해석이 필요할 때 유용합니다.

# Sigmoid 함수
σ(x) = 1 / (1 + exp(-x))

# 미분
d/dx σ(x) = σ(x) × (1 - σ(x))

# 계산 예시
σ(0)   = 0.5         # 중앙에서 0.5
σ(2)   ≈ 0.88        # 양수 → 1에 가까움
σ(-2)  ≈ 0.12        # 음수 → 0에 가까움

# 특성:
# - 출력 ∈ (0, 1) → 확률로 해석 가능
# - 미분값이 0~0.25 사이 (최대 0.25)
# - 깊은 네트워크에서 gradient vanishing 발생

Tanh: -1에서 1 사이

Tanh는 Sigmoid와 비슷하지만 출력 범위가 -1에서 1 사이입니다. 평균이 0에 가까워 학습이 더 효율적입니다.

# Tanh 함수
tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))

# 미분
d/dx tanh(x) = 1 - tanh(x)²

# 계산 예시
tanh(0)   = 0
tanh(1)   ≈ 0.76
tanh(-1)  ≈ -0.76

# Sigmoid vs Tanh 비교:
# Sigmoid: 출력 (0, 1) - 양수만 출력
# Tanh: 출력 (-1, 1) - 양수/음수 모두 출력 (평균 0)

미분과 기울기: 학습의 핵심

LLM 학습은 결국 손실 함수의 기울기를 계산하고, 그 기울기를 반대로 따라가며 파라미터를 업데이트하는 반복입니다. 이 섹션은 미분 직관부터 학습률, 배치 전략, AdamW까지 한 번에 연결해 설명합니다.

미분: 변화율의 측정

미분(differentiation)은 "입력을 아주 조금 바꾸면 출력이 얼마나 바뀌는가"를 수치화합니다. 모델 학습에서는 이 값이 업데이트 방향의 나침반 역할을 합니다.

# 미분의 정의
f'(x) = lim[h→0] (f(x+h) - f(x)) / h

# 직관: x를 아주 조금 증가시켰을 때 f(x)의 증가 속도

# 예시: f(x) = x^2
# f'(x) = 2x
# x=3이면 f'(3)=6 → x가 0.01 변하면 f(x)는 약 0.06 변함

# 자주 쓰는 형태
# d/dx x^n = n*x^(n-1)
# d/dx e^x = e^x
# d/dx log(x) = 1/x

경사 하강법: 손실을 줄이는 법

경사 하강법(Gradient Descent)은 손실 함수의 기울기(∇L)를 이용해 파라미터를 최소값 방향으로 이동시키는 방법입니다.

# 기본 업데이트
θ_new = θ_old - η * ∇L(θ_old)

# θ: 파라미터(가중치)
# η: 학습률(learning rate)
# ∇L(θ): 해당 지점의 손실 기울기

# 1차원 예시: L(θ) = (θ-3)^2
# 도함수: dL/dθ = 2(θ-3)
# 초기값 θ0 = 0, η = 0.1

# step 0
g0 = 2*(0-3) = -6
θ1 = 0 - 0.1*(-6) = 0.6

# step 1
g1 = 2*(0.6-3) = -4.8
θ2 = 0.6 - 0.1*(-4.8) = 1.08

# step 2
g2 = 2*(1.08-3) = -3.84
θ3 = 1.08 - 0.1*(-3.84) = 1.464

# 반복하면 θ -> 3으로 수렴

Batch, SGD, Mini-batch 차이

실제 LLM 학습은 전체 데이터를 한 번에 쓰는 대신 미니배치(mini-batch)를 사용합니다. 계산 비용과 기울기 안정성의 균형이 가장 좋기 때문입니다.

# 미니배치 손실
L_batch(θ) = (1/B) * Σ_i L_i(θ)
g_t = ∇L_batch(θ_t)
θ_(t+1) = θ_t - η_t * g_t

# 배치 크기 B가 너무 작으면:
# - 기울기 분산 증가 (학습 불안정)
# - 일반화에 유리할 수 있으나 수렴이 느려질 수 있음

# 배치 크기 B가 너무 크면:
# - 업데이트 횟수 감소
# - 메모리 부담 증가, 평탄하지 않은 최소값으로 갈 위험

연쇄 법칙과 역전파

LLM은 층이 매우 깊기 때문에 단일 미분이 아니라 연쇄 법칙(chain rule)으로 각 층의 기여도를 분해해 계산합니다. 이 계산 절차가 역전파(backpropagation)입니다.

# 합성함수 y = f(g(x))
dy/dx = (dy/dg) * (dg/dx)

# 신경망의 한 층
z = W*x + b
a = φ(z)
L = loss(a, y_true)

# 역전파 핵심
∂L/∂W = (∂L/∂a) * (∂a/∂z) * (∂z/∂W)
∂L/∂b = (∂L/∂a) * (∂a/∂z)

# 깊은 네트워크에서는 위 곱셈이 층 수만큼 반복됨

옵티마이저: SGD, Momentum, AdamW

경사 하강법의 핵심은 같지만, 실제로는 더 빠르고 안정적으로 수렴하기 위해 옵티마이저를 사용합니다. LLM 실무에서는 AdamW가 사실상 표준입니다.

# SGD
θ = θ - η * g

# Momentum SGD
v = β*v + (1-β)*g
θ = θ - η*v

# AdamW (핵심 아이디어)
m = β1*m + (1-β1)*g
v = β2*v + (1-β2)*(g*g)
m_hat = m / (1-β1^t)
v_hat = v / (1-β2^t)
θ = θ - η * m_hat / (sqrt(v_hat) + ε) - η*λ*θ

# m: 1차 모멘트(평균 기울기)
# v: 2차 모멘트(기울기 제곱 평균)
# λ: weight decay 계수

학습률 스케줄: Warmup + Decay

LLM은 보통 초반 워밍업(warmup)으로 학습을 안정화한 뒤, 점진적으로 학습률을 낮춰 미세 조정합니다.

# 선형 warmup + cosine decay 예시
if step < warmup_steps:
    lr = max_lr * (step / warmup_steps)
else:
    progress = (step - warmup_steps) / (total_steps - warmup_steps)
    lr = min_lr + 0.5*(max_lr - min_lr)*(1 + cos(pi*progress))

# 실무 관찰 포인트
# - warmup 부족: 초반 loss 스파이크, NaN 위험
# - decay 없음: 후반 미세 수렴이 어려움
# - min_lr 과소: 학습 정체

기울기 소실·폭발과 대응

깊은 네트워크에서는 기울기 크기가 층을 거치며 급격히 작아지거나 커질 수 있습니다. 이는 학습 정체 또는 발산의 직접 원인입니다.

# 기울기 소실 (Vanishing)
# 예: 0.25를 100번 곱하면 0.25^100 ≈ 10^-60
# 앞단 층은 거의 업데이트되지 않음

# 기울기 폭발 (Exploding)
# 예: 1.5를 50번 곱하면 1.5^50 ≈ 10^9
# 손실 NaN, 파라미터 inf/NaN 발생

# 공통 대응
# 1) Residual 구조 사용
# 2) LayerNorm/정규화 적용
# 3) gradient clipping
# 4) 학습률/워밍업 조정

실전 학습 루프 관점

경사 하강법은 수식 하나지만, 실제 훈련 루프에서는 데이터 로딩, 혼합 정밀도, 그래디언트 누적, 클리핑이 함께 돌아갑니다.

# PyTorch 스타일 의사 코드
for step, batch in enumerate(loader):
    with autocast():
        logits = model(batch["input_ids"])
        loss = cross_entropy(logits, batch["labels"])

    scaler.scale(loss).backward()

    # 그래디언트 누적 사용 시 조건부 업데이트
    if (step + 1) % grad_accum == 0:
        scaler.unscale_(optimizer)
        clip_grad_norm_(model.parameters(), max_norm=1.0)
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad(set_to_none=True)
        scheduler.step()

확률론 기초: 불확실성의 수학

LLM은 본질적으로 확률 모델입니다. 출력이 확률 분포에서 샘플링되고, 학습은 확률을 최대화하는 방향으로 진행됩니다.

확률 분포

확률 분포는 각 가능한 결과가 나타날 확률을 정의합니다. LLM에서는 다음 토큰이 될 수 있는 모든 단어에 확률을 할당합니다.

# 확률 분포의 조건
# 1) 모든 확률은 0 이상: P(x) ≥ 0
# 2) 확률의 합은 1: Σ P(x) = 1

# LLM의 다음 토큰 확률 분포 예시
# 입력: "서울의"
next_token_probs = {
  "수": 0.35,    # "서울의 수"
  "수도": 0.25,    # "서울의 수도"
  "날씨": 0.15,    # "서울의 날씨"
  "맛": 0.10,     # "서울의 맛"
  "...   0.15     # 다른 단어들
}
# 합계: 1.0 ✓

Softmax: 로짓을 확률로

LLM의 마지막 층은 로짓(logit)이라는 점수를 출력합니다. Softmax 함수가 이 점수를 확률로 변환합니다.

# Softmax 함수
softmax(z_i) = exp(z_i) / Σⱼ exp(z_j)

# z: 로짓 (LLM 출력 점수)
# exp(): 지수 함수 (양수)

# 구체적인 예
z = [2.0, 1.0, 0.5]  # 로짓

# exp(z)
exp_z = [7.39, 2.72, 1.65]

# 합계
sum_exp = 7.39 + 2.72 + 1.65 = 11.76

# Softmax (확률)
P = [7.39/11.76, 2.72/11.76, 1.65/11.76]
  = [0.63, 0.23, 0.14]

# 검증: 0.63 + 0.23 + 0.14 = 1.0 ✓

크로스엔트로피: 학습의 손실 함수

LLM의 학습은 크로스엔트로피(Cross-Entropy) 손실 함수를 사용합니다. 이것은 "예측 확률 분포"와 "진짜 확률 분포"의 차이를 측정합니다.

# 크로스엔트로피
H(p, q) = - Σ p(x) × log(q(x))

# p(x): 실제 분포 (원-핫: 정답만 1, 나머지는 0)
# q(x): 모델 예측 분포 (softmax 출력)

# 구체적인 예
# 정답: "수" (원-핫 인코딩)
p = [1, 0, 0]  # "수"=1, others=0

# 모델 예측
q = [0.63, 0.23, 0.14]

# 크로스엔트로피 계산
# H = -[1×log(0.63) + 0×log(0.23) + 0×log(0.14)]
# H = -log(0.63) ≈ 0.46

# 해석:
# - 정답 확률이 높으면 (0.99) → loss ≈ 0.01 (작음)
# - 정답 확률이 낮으면 (0.01) → loss ≈ 4.61 ( 큼)

음성 로그 우도: 크로스엔트로피의 다른 표현

실제 구현에서는 음성 로그 우도(Negative Log-Likelihood, NLL)를 더 자주 사용합니다. 원-핫 인코딩에서는 두 값이 같습니다.

# 음성 로그 우도 (NLL)
NLL = -log(q[target])

# 위 예시에서:
# target = "수" (index 0)
# q[0] = 0.63
# NLL = -log(0.63) ≈ 0.46

# 왜 로그를 사용할까?
# - 확률의 곱 → 로그의 합 (계산 편리)
# - 0~1 사이 값 → 로그 후 음수 (손실로 적합)
# - 정답 확률 1.0 → log(1) = 0 (손실 0) ✓
# - 정답 확률 0.1 → log(0.1) ≈ -2.3 (큰 손실)

정보이론 관점

LLM의 학습과 평가는 정보이론 지표로 측정됩니다.

• 엔트로피(H): 불확실성의 정도. 가능한 토큰이 많을수록 높아짐
• 크로스엔트로피(H(p,q)): 모델 예측(q)과 실제 분포(p)의 차이
• 퍼플렉서티(PPL): 크로스엔트로피를 직관적으로 변환한 지표

엔트로피 직관: 불확실성의 척도

엔트로피는 "결과를 예측하기 얼마나 어려운가"를 수치화합니다. 일상적인 예시로 이해해 봅시다:

# 공정한 동전 던지기: 2가지 결과, 각각 50%
H = -(0.5 × log₂(0.5) + 0.5 × log₂(0.5)) = 1.0 bit

# 공정한 주사위: 6가지 결과, 각각 16.7%
H = -6 × (0.167 × log₂(0.167)) ≈ 2.58 bits

# 편향된 동전 (앞면 90%): 거의 예측 가능
H = -(0.9 × log₂(0.9) + 0.1 × log₂(0.1)) ≈ 0.47 bits

# LLM에서의 의미:
# - 엔트로피가 높은 위치 = 다음 토큰이 불확실 (여러 후보 가능)
# - 엔트로피가 낮은 위치 = 거의 확정적 ("서울의 수도는" → "한국")

# 크로스엔트로피
H(p, q) = - ∑ p(x) log q(x)

# 퍼플렉서티
PPL = exp(H(p, q))

# 직관적 관계
낮은 크로스엔트로피 → 높은 예측 정확도 → 낮은 퍼플렉서티

학습 손실: NLL (Negative Log-Likelihood)

LLM은 다음 토큰을 예측하는 방식으로 학습합니다. 학습 손실 함수는 크로스엔트로피와 직접 연결됩니다.

# NLL Loss (다음 토큰 예측의 손실 함수)
L = - ∑ log p(y_t | y_{<t}, x)

# y_t : 실제 다음 토큰
# y_{<t} : 이전까지의 토큰 시퀀스
# x : 입력 컨텍스트
# 이 손실이 낮아질수록 모델의 예측이 정확해짐

퍼플렉서티 실무 해석

퍼플렉서티는 "모델이 매 토큰을 예측할 때 평균적으로 몇 개의 후보 사이에서 고민하는가"로 직관적으로 해석됩니다.

일반화와 과적합

LLM은 학습 데이터와 다른 입력에도 답해야 합니다. 일반화가 좋으면 새로운 입력에 안정적으로 대응합니다.

• 일반화: 보지 못한 입력에 대한 성능 — LLM의 실제 가치
• 과적합: 학습 데이터에만 강하고 새로운 입력에 취약
• 데이터 분포: 학습 데이터가 실제 사용자 입력과 일치해야 일반화 향상

학습·검증·배포 분포 불일치

모델의 일반화 실패는 대부분 분포 불일치(distribution shift)에서 비롯됩니다. 학습 데이터, 검증 데이터, 실제 배포 환경의 입력이 각각 다른 특성을 가질 수 있습니다.

• 학습-검증 불일치: 검증 데이터가 학습 데이터와 너무 유사하면 과적합을 발견하지 못함
• 검증-배포 불일치: 벤치마크에서는 우수하지만 실제 사용자 입력에서는 성능 저하
• 시간적 불일치: 학습 이후 세계가 변화 — 최신 사건, 신기술에 대한 지식 부재

LLM의 제로샷 일반화

대규모 사전학습 모델은 학습 중 명시적으로 접하지 않은 태스크에서도 놀라운 성능을 보입니다. 이것이 제로샷(zero-shot) 일반화이며, LLM의 가장 독특한 특성 중 하나입니다.

# 제로샷 일반화 예시
# 학습 시: "다음 토큰 예측"만 수행
# 배포 시: 아래와 같은 태스크를 별도 학습 없이 수행

"이 리뷰의 감정을 판별하세요: '정말 맛있었어요!'"
→ 긍정  # 감정 분류를 학습한 적 없지만 수행 가능

"Translate to English: 오늘 날씨가 좋습니다"
→ The weather is nice today  # 번역 태스크도 패턴으로 학습

환각(허위 응답)의 원인

• 확률적 생성: 낮은 확률의 토큰이 선택될 수 있음 — 그럴듯하지만 사실이 아닌 내용 생성
• 지식 공백: 학습 데이터에 없는 정보를 패턴으로 "채우려" 시도
• 프롬프트 불명확: 조건이 모호한 질문은 모델의 추측 범위를 넓힘

환각 발생 메커니즘

환각은 모델의 확률 분포 관점에서 이해할 수 있습니다. 모델이 다음 토큰을 예측할 때, 학습 데이터에서 본 패턴을 기반으로 확률을 할당합니다. 문제는 이 확률이 "사실 여부"가 아닌 "통계적 패턴"을 반영한다는 점입니다.

# 환각 발생 과정 (개념적)
입력: "알베르트 아인슈타인이 노벨상을 받은 연도는"

# 모델 내부 확률 분포:
"1921"  → P = 0.45  # 정답 (물리학상)
"1905"  → P = 0.25  # 특수상대성이론 발표 연도 (오답이지만 관련)
"1915"  → P = 0.15  # 일반상대성이론 발표 연도 (오답)
"1922"  → P = 0.10  # 수상 발표/수령 연도 혼동

# 온도가 높으면 오답이 선택될 확률 증가
# "1905"가 선택되면 → 그럴듯하지만 사실이 아닌 환각

환각의 주요 유형

사실적 환각(Factual Hallucination): 존재하지 않는 사실을 만들어내는 경우입니다.

# 사실적 환각 사례: 존재하지 않는 논문 인용
사용자: "Transformer의 attention 효율성에 관한 논문을 추천해주세요"

모델 응답 (환각):
"Smith et al. (2023) 'Efficient Sparse Attention for
 Long-Range Dependencies' - Journal of Machine Learning"

# 문제: 저자, 제목, 저널 모두 그럴듯하지만
# 실제로 존재하지 않는 논문
# 학술 형식 패턴을 학습했기 때문에 형식은 완벽함

논리적 환각(Logical Hallucination): 각 단계는 그럴듯하지만 추론 체인이 잘못된 경우입니다.

# 논리적 환각 사례: 잘못된 추론 체인
사용자: "서울에서 부산까지 빛의 속도로 이동하면 몇 초?"

모델 응답 (환각):
"서울-부산 거리: 약 325km
 빛의 속도: 약 300,000km/s
 계산: 325 / 300,000 = 약 0.001초"  ✓ 정답

하지만 유사 질문에서:
"서울-부산 거리: 약 325km
 빛의 속도: 약 30만km/s
 계산: 325 × 30 = 약 9,750초"  ✗ 곱셈/나눗셈 혼동

# 원인: 토큰 단위 생성이므로 수식의 논리적 일관성을 보장하지 않음

환각 완화 전략 비교

환각 감지 기법

• 자기일관성 검사: 같은 질문을 여러 번 질문하여 답변 간 일치도를 측정 — 답변이 자주 바뀌면 환각 가능성이 높음
• 외부 검증: 모델의 주장을 검색 엔진, 데이터베이스, API로 교차 확인
• 불확실성 표현 감지: 모델이 "아마도", "~일 수 있습니다" 같은 헤지 표현을 사용할 때 해당 부분을 집중 검증

불확실성 다루기

• 자기검증: 모델이 스스로 근거를 재점검하도록 유도
• 근거 제공: 출처를 명시하도록 프롬프트 설계
• RAG (Retrieval-Augmented Generation): 외부 지식으로 보강하여 사실성 향상
• 도구 호출: 계산·검색·API 호출로 정확한 정보 획득

자기검증 프롬프트 패턴

모델이 자신의 답변을 스스로 검증하도록 유도하는 프롬프트 기법입니다:

# 자기검증 프롬프트 예시
System: "답변 후 다음 형식으로 자기검증을 수행하세요:
 [검증] 위 답변에서 사실 확인이 필요한 부분:
 - 확인 필요 1: ...
 - 확인 필요 2: ...
 [확신도] 상/중/하"

User: "한국의 GDP 순위는?"

Assistant: "한국은 2024년 기준 세계 GDP 약 13위입니다.
 [검증]
 - 확인 필요 1: 정확한 순위는 측정 기관(IMF/World Bank)마다 다름
 - 확인 필요 2: 2024년 최신 데이터가 반영되지 않았을 수 있음
 [확신도] 중"

전략별 효과 비교

복합 전략 조합

실무에서는 단일 전략보다 여러 전략을 조합할 때 가장 효과적입니다:

# 복합 전략 파이프라인 예시

# 1단계: RAG로 관련 문서 검색
context = retrieve(query, top_k=5)

# 2단계: 검색 결과를 포함한 프롬프트 + 자기검증 요청
prompt = f"""다음 참고 자료를 바탕으로 답변하세요:
{context}
질문: {query}
답변 후 [검증] 섹션에서 근거를 확인하세요."""

# 3단계: 수치 계산이 필요하면 도구 호출
if needs_calculation(response):
    result = calculator(expression)

# 효과: RAG(사실성) + 자기검증(논리성) + 도구(정확성)

Transformer 직관

현대 LLM의 기반이 되는 Transformer 아키텍처의 핵심 구성요소를 살펴봅니다.

• Self-Attention: 모든 토큰의 관계를 동시에 고려 — 순환 구조 없이 병렬 처리 가능
• Residual Connection + LayerNorm: 깊은 네트워크에서도 안정적인 학습을 보장
• Position Encoding: 토큰의 순서 정보를 벡터로 주입 (Transformer 자체는 순서를 모름)
• Feed-Forward Network: 각 토큰의 표현을 비선형 변환으로 풍부하게 함

Multi-Head Attention: 여러 관점으로 보기

단일 Attention 헤드는 하나의 관계 유형만 포착합니다. Multi-Head Attention은 여러 개의 독립적인 Attention을 병렬로 수행하여, 동시에 여러 관계를 학습합니다.

# Multi-Head Attention 직관
# "The cat sat on the mat"에서 "sat"을 처리할 때:

Head 1 (주어 관계):  "sat" → "cat"에 강하게 주목   # 누가?
Head 2 (위치 관계):  "sat" → "on"에 강하게 주목    # 어디?
Head 3 (구문 관계):  "sat" → "mat"에 강하게 주목   # 무엇 위?

# 각 헤드의 결과를 연결(concatenate)한 후 선형 변환
MultiHead = Concat(Head_1, Head_2, ..., Head_h) × W_O

# GPT-3: 96개 헤드, Claude/GPT-4: 더 많은 헤드
# 헤드가 많을수록 다양한 언어적 관계를 포착

왜 Transformer인가: RNN/LSTM과의 비교

Transformer 이전에는 RNN(순환 신경망)과 LSTM이 주류였습니다. Transformer가 이들을 대체한 핵심 이유는 병렬 처리입니다.

• RNN/LSTM: 토큰을 순차적으로 처리 — t번째 토큰의 결과가 나와야 t+1번째를 처리할 수 있음. 긴 시퀀스에서 학습 속도가 급격히 저하
• Transformer: 모든 토큰 쌍의 관계를 동시에 계산 — GPU의 병렬 처리 능력을 최대한 활용. 수천 토큰도 한 번에 처리 가능
• 장거리 의존성: RNN은 긴 문장에서 앞부분 정보를 "잊는" 문제가 있지만, Attention은 거리에 관계없이 직접 참조 가능

Layer Normalization: 학습 안정화의 핵심

Layer Normalization은 각 샘플 내에서 활성화 값들을 정규화합니다. Batch Normalization과 달리 배치 크기에 의존하지 않아 Online 학습이나 순환 신경망에서 유리합니다.

# Layer Normalization 공식
LayerNorm(x) = γ × (x - μ) / σ + β

# μ (mu): 평균
μ = (1/d) × Σ x_i

# σ (sigma): 표준편차
σ = √[(1/d) × Σ (x_i - μ)²]

# γ (gamma): 학습 가능한 스케일 파라미터
# β (beta): 학습 가능한 이동 파라미터

# 구체적인 계산 예시 (단순화)
x = [2.0, 4.0, 6.0]

# 평균
μ = (2+4+6) / 3 = 4.0

# 표준편차
σ = √[((2-4)² + (4-4)² + (6-4)²) / 3]
  = √[8/3] ≈ 1.63

# 정규화 (γ=1, β=0 가정)
(x - μ) / σ = [-1.23, 0, 1.23]

Position Encoding: 순서의 수학적 표현

Transformer는 본질적으로 순열 불변(permutation invariant)합니다. "고양이가 강아지를 물었다"와 "강아지가 고양이를 물었다"는 완전히 다른 의미인데, 위치 정보를 주입하지 않으면 이를 구분할 수 없습니다.

# Sinusoidal Position Encoding 공식
# 짝수 차원 (sin):
PE(pos, 2i)   = sin(pos / 10000^(2i/d_model))

# 홀수 차원 (cos):
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

# 매개변수:
# pos: 토큰 위치 (0, 1, 2, ...)
# i: 차원 인덱스 (0, 1, 2, ...)
# d_model: 임베딩 차원

# 계산 예시 (d_model=4, pos=0,1)
# i=0: 10000^(0/4) = 1
# i=1: 10000^(2/4) = 10000^0.5 = 10

PE(0) = [sin(0/1)=0,  cos(0/1)=1,  sin(0/10)=0, cos(0/10)=1]
        = [0, 1, 0, 1]

PE(1) = [sin(1/1)=0.84, cos(1/1)=0.54, sin(1/10)=0.10, cos(1/10)=0.99]
        = [0.84, 0.54, 0.10, 0.99]

Attention 수학적 직관

# Scaled Dot-Product Attention
Attention(Q, K, V) = softmax(QK^T / sqrt(d)) × V

# Q (Query)  : "내가 찾고 싶은 정보"
# K (Key)    : "내가 가진 정보의 라벨"
# V (Value)  : "실제 정보 내용"
# d          : 임베딩 차원 (스케일링용)

# Softmax: 점수를 0~1 사이 확률로 변환
softmax(z_i) = exp(z_i) / ∑ exp(z_j)

Q, K, V는 각각 질의/키/값이며, 유사도가 높은 키에 더 큰 가중치를 부여합니다. 마치 도서관에서 질문(Q)과 가장 관련된 책 제목(K)을 찾고, 그 책의 내용(V)을 가져오는 것과 같습니다.

Attention 계산 단계별 예시

# 1단계: 입력 임베딩 (단순화된 2차원 예시)
Q = [[1.0, 0.5],   # "I"
     [0.8, 1.2],   # "love"
     [1.5, 0.3]]   # "AI"

K = Q  # Self-Attention에서는 Q=K=V (단순화)
V = Q

# 2단계: 유사도 계산 (QK^T = 내적으로 유사도 측정)
QK^T = [[1.25, 1.60, 1.65],   # "I"와 각 토큰의 유사도
        [1.60, 2.08, 1.56],   # "love"와 각 토큰의 유사도
        [1.65, 1.56, 2.34]]   # "AI"와 각 토큰의 유사도

# 3단계: 스케일링 (sqrt(d) = sqrt(2) ≈ 1.41)
# → 내적 값이 너무 커지면 softmax가 극단적이 됨, 이를 방지
Scaled = QK^T / 1.41
       = [[0.89, 1.13, 1.17],
          [1.13, 1.47, 1.11],
          [1.17, 1.11, 1.66]]

# 4단계: Softmax (각 행의 합 = 1, 확률 분포로 변환)
Attention_Weights = [[0.31, 0.35, 0.34],   # "I"가 각 토큰에 주목하는 비율
                     [0.30, 0.41, 0.29],   # "love"가 각 토큰에 주목
                     [0.30, 0.28, 0.42]]   # "AI"가 각 토큰에 주목

# 5단계: 가중합 (Attention_Weights × V)
Output = [[1.13, 0.63],   # "I"의 새로운 표현 (주변 문맥 반영)
          [1.08, 0.68],   # "love"의 새로운 표현
          [1.21, 0.57]]   # "AI"의 새로운 표현

# 결과 해석:
# - "love"는 자기 자신(0.41)과 "I"(0.30)에 많이 주목
# - "AI"는 자기 자신(0.42)에 가장 많이 주목
# - 각 토큰의 출력은 문맥을 반영하여 풍부해짐

스케일링 법칙

LLM의 성능은 세 가지 축의 상호작용으로 결정됩니다.

• 모델 크기(N): 파라미터 증가 시 성능 개선 (멱법칙적 관계)
• 데이터(D): 학습 데이터가 충분하지 않으면 큰 모델도 한계
• 컴퓨트(C): 일정 수준까지는 스케일이 성능을 주도

모델 크기별 성능 비교

In-Context Learning

모델이 추가 학습(가중치 업데이트) 없이도 프롬프트 내 예시를 통해 작업을 수행하는 현상입니다.

• Few-shot: 예시 2~5개로 학습 효과 — 별도 파인튜닝 불필요
• 패턴 추론: 예시의 규칙을 컨텍스트에서 즉석 추론
• 컨텍스트 길이: 더 긴 컨텍스트는 더 복잡한 패턴 학습 가능

Few-shot 프롬프트 실전 예시

감정 분류 태스크에서 Few-shot ICL이 어떻게 동작하는지 살펴봅시다:

# Few-shot 감정 분류 프롬프트
System: "리뷰의 감정을 '긍정', '부정', '중립'으로 분류하세요."

# 예시 1 (긍정)
리뷰: "배송도 빠르고 품질이 정말 좋아요!"
감정: 긍정

# 예시 2 (부정)
리뷰: "일주일 만에 고장났습니다. 환불 요청합니다."
감정: 부정

# 예시 3 (중립)
리뷰: "보통이에요. 가격 대비 적당합니다."
감정: 중립

# 실제 질문
리뷰: "디자인은 예쁜데 기능이 좀 아쉬워요."
감정:
# → 모델이 패턴을 파악하여 "중립" 또는 "부정"으로 분류

Zero-shot vs Few-shot vs Many-shot

제공하는 예시의 수에 따라 ICL의 성격이 달라집니다:

• Zero-shot: 예시 없이 지시만 제공. 모델의 사전학습 지식에만 의존하며, 간단한 태스크에 적합
• Few-shot (2~5개): 소수의 예시로 출력 형식과 기준을 전달. 대부분의 실무 시나리오에서 최적
• Many-shot (10개+): 많은 예시로 복잡한 패턴 전달. 정확도는 높아지지만 컨텍스트를 많이 소비

추론 이론과 한계

• 체인 구조: 긴 추론은 단계마다 오류가 누적될 가능성이 있음
• 샘플링 전략: 동일 질문에 여러 번 샘플링하여 다수결로 정확도 개선 (Self-Consistency)
• 검증 루프: 자기검증/도구 검증을 결합하여 추론 신뢰도 향상

Chain-of-Thought (CoT) 작동 원리

CoT는 모델이 최종 답만 출력하는 대신, 중간 추론 과정을 단계별로 생성하도록 유도합니다. 이렇게 하면 각 단계의 출력이 다음 단계의 컨텍스트가 되어, 복잡한 문제를 작은 단위로 분해하는 효과를 얻습니다.

# CoT 없이 (직접 응답)
Q: "가게에 사과 23개가 있었습니다. 8개를 팔고,
    12개를 새로 입고했습니다. 몇 개가 남았나요?"
A: "27개"

# CoT 적용 (단계별 추론)
Q: "가게에 사과 23개가 있었습니다. 8개를 팔고,
    12개를 새로 입고했습니다. 몇 개가 남았나요?
    단계별로 풀어보세요."
A: "1단계: 처음 사과 수 = 23개
    2단계: 8개를 팔았으므로 = 23 - 8 = 15개
    3단계: 12개를 입고했으므로 = 15 + 12 = 27개
    답: 27개"

# 직접 응답도 맞을 수 있지만, 복잡한 문제에서는
# CoT가 정확도를 크게 높임 (특히 다단계 산술, 논리 문제)

추론 실패 유형

LLM의 추론은 패턴 매칭에 기반하므로, 특정 유형의 논리적 추론에서 체계적인 한계를 보입니다:

• 다단계 산술: 3단계 이상의 연속 계산에서 오류율 급증. 중간 결과를 "기억"하지 못하고 토큰 단위로 생성하기 때문
• 반사실적 추론: "만약 지구의 중력이 2배라면?" 같은 가정적 시나리오에서 학습 데이터의 사실과 혼동
• 부정 논리: "~가 아닌 것은?" 같은 부정 조건이 포함된 문제에서 취약 — 긍정 패턴에 편향된 학습 때문
• 형식적 논리: 삼단논법, 전건부정 등 엄밀한 형식 논리에서 간헐적 실패

Self-Consistency: 다중 샘플링 기법

Self-Consistency는 같은 문제에 대해 여러 번 독립적으로 추론한 뒤, 가장 빈번한 답을 최종 답으로 선택하는 기법입니다.

# Self-Consistency 예시
# 같은 질문을 temperature=0.7로 5회 샘플링

샘플 1: ... → 답: 27
샘플 2: ... → 답: 27
샘플 3: ... → 답: 25  # 중간 계산 오류
샘플 4: ... → 답: 27
샘플 5: ... → 답: 27

# 다수결: 27이 4/5 → 최종 답 = 27 ✓
# 단일 샘플링보다 정확도 향상 (특히 추론 문제에서)
# 비용: N배의 API 호출 필요

학습 단계와 정렬 파이프라인

현대 LLM은 단일 학습이 아니라 단계별 파이프라인으로 품질을 끌어올립니다. 사전학습으로 언어 능력을 만들고, SFT와 선호 정렬로 사용자 의도에 맞춥니다.

이론에서 실전으로

위에서 다룬 이론들이 실무에서 어떻게 연결되는지 정리합니다.

기초 이론 → 실전

• 확률적 생성 → 온도/Top-p 제어로 품질 안정화
• 크로스엔트로피 → 모델 비교 시 퍼플렉서티 활용
• 환각 → RAG/도구 호출로 사실 검증

심화 이론 → 실전

• Attention → 긴 컨텍스트에서 중요한 정보 위치 강조 (시스템 프롬프트 설계)
• ICL → Few-shot 예시로 빠른 태스크 적응 (별도 파인튜닝 없이)
• 스케일링 → 비용 대비 성능 목표 설정 (모델 선택 기준)

케이스 스터디

사례 1: 요약 품질 개선 — 온도 조절

1. 퍼플렉서티가 낮은 모델을 우선 후보로 선정
2. 온도 값을 낮추어 일관성을 강화
3. RAG로 근거 문장을 함께 제공

# 온도 조절 전/후 요약 품질 비교
원문: "2024년 한국의 반도체 수출이 전년 대비 30% 증가하며
       무역수지 흑자 전환에 기여했다."

# Temperature=1.0 (높음) — 불안정한 변동
시도 1: "한국 반도체 수출이 폭발적으로 성장했다"  # "폭발적" 과장
시도 2: "반도체 산업이 경제 회복을 이끌었다"     # 원문에 없는 내용
시도 3: "수출 30% 증가로 무역수지가 개선되었다"  # 적절

# Temperature=0.3 (낮음) — 안정적인 출력
시도 1: "반도체 수출이 30% 증가하며 무역 흑자에 기여"  ✓
시도 2: "반도체 수출 30% 증가, 무역수지 흑자 전환"    ✓
시도 3: "반도체 수출이 30% 늘어 무역 흑자를 달성"    ✓

사례 2: ICL 성능 개선 — Few-shot 수 조절

1. 입력 예시를 2개에서 4개로 늘려 패턴 노출 강화
2. 예시 형식을 출력 형식과 동일하게 맞춤
3. 컨텍스트 길이 한계 내에서 불필요한 텍스트 제거

참고자료

• LLM 핸드북 1: 개념·구조·평가
• LLM 핸드북 2: 학습·정렬
• 프롬프트 기본
• GPT를 밑바닥부터: microgpt.py