Stanford CME295: Lecture 5 - LLM Tuning (Preference Tuning)

Posted Mar 8, 2026 Updated Mar 9, 2026

By Jeong Mo, Hong

73 min read

원본 강의: YouTube - CME295 Lecture 5

강의 개요

이번 강의에서는 LLM을 인간의 선호도에 맞게 정렬(Alignment)하는 방법을 다룹니다. Pre-training과 SFT 이후의 세 번째 학습 단계인 Preference Tuning을 중심으로, RLHF, PPO, DPO 등의 핵심 기법들을 학습합니다.

강의 목표:

Preference Tuning의 필요성과 개념 이해
Preference Data 수집 방법 파악
RLHF (Reinforcement Learning from Human Feedback) 이해
PPO (Proximal Policy Optimization) 알고리즘 학습
DPO (Direct Preference Optimization) 기법 습득

지난 강의 복습

주제	핵심 내용
Pre-training	방대한 데이터로 언어/코드 이해 학습, 다음 토큰 예측
SFT (Supervised Fine-Tuning)	특정 태스크 수행을 위한 고품질 데이터 학습
LoRA	Low-Rank 행렬로 효율적 파라미터 튜닝

Part 1: Preference Tuning 개요

1. LLM 학습의 세 단계

┌─────────────────────────────────────────────────────────────┐
│ 1. Pre-training                                             │
│    └─ 목표: 언어/코드 이해                                    │
│    └─ 결과: 훌륭한 자동완성기 (도움이 되는 모델은 아님)          │
│              │                                              │
│              ▼                                              │
│ 2. Supervised Fine-Tuning (SFT)                             │
│    └─ 목표: 특정 태스크 수행법 학습                            │
│    └─ 결과: 지시를 따르는 모델                                │
│              │                                              │
│              ▼                                              │
│ 3. Preference Tuning ⭐ (이번 강의)                          │
│    └─ 목표: 인간 선호도에 맞춘 정렬                            │
│    └─ 결과: 더 친절하고, 안전하고, 유용한 모델                  │
└─────────────────────────────────────────────────────────────┘

2. Preference Tuning이 필요한 이유

SFT 모델의 한계:

User: "테디베어와 함께 할 수 있는 새로운 활동을 추천해줘"
SFT 모델 응답: "테디베어와 많은 시간을 보내지 않는 게 좋겠어요."
  → 사실적으로 틀린 건 아니지만, 친절하지 않음!
Preference Tuned 모델 응답: "물론이죠! 테디베어는 훌륭한 친구가 될 수 있어요.
  피크닉을 가거나, 함께 책을 읽거나..."
  → 같은 정보를 더 친절하고 도움이 되는 방식으로 전달

3. SFT vs Preference Tuning

구분	SFT	Preference Tuning
데이터	(Input, Output) 쌍	(Input, Good Output, Bad Output) 쌍
신호	“이것을 생성해라”	“이것이 더 좋다”
난이도	고품질 Output 작성 (어려움)	두 Output 비교 (쉬움)
분포 민감도	매우 민감	덜 민감
네거티브 신호	없음	있음

핵심 차이:

SFT: 모델이 무엇을 생성해야 하는지 가르침
Preference Tuning: 모델이 무엇을 생성하면 안 되는지 가르침 (네거티브 신호)

Part 2: Preference Data 수집

1. 선호도 데이터 유형

유형	설명	난이도	사용 빈도
Pointwise	각 응답에 절대 점수 부여 (예: 0.9, 0.2)	어려움	낮음
Pairwise	두 응답 중 더 나은 것 선택	쉬움	높음
Listwise	N개 응답 순위 매기기	중간	중간

2. Pairwise Preference Data 수집 방법

방법 1: 모델 생성 후 평가

프롬프트 준비 (사용자 로그 또는 원하는 프롬프트 세트)
모델에 동일 프롬프트를 양의 온도(temperature)로 2회 입력
두 개의 다른 응답 생성
평가자가 두 응답 비교

방법 2: 불량 응답 재작성

로그에서 불량 응답 찾기
좋은 응답으로 재작성
(원본, 재작성) 쌍 구성

3. 평가 방법

방법	설명
Human Ratings	사람이 직접 평가 (RLHF의 “H”)
LLM as a Judge	다른 LLM이 평가 (RLAIF)
Rule-based	BLEU, ROUGE 등 자동 메트릭

평가 척도:

Binary: Better / Worse
Nuanced: Much Better / Better / Slightly Better / Slightly Worse / Worse / Much Worse

주의사항:

평가 지침(Guidelines)이 명확해야 함
평가 차원 정의 필요: 유용성(Useful), 친절함(Friendly), 안전성(Safe) 등

Part 3: RLHF (Reinforcement Learning from Human Feedback)

1. RL 기초 개념의 LLM 적용

RL 개념	LLM에서의 의미
Agent	LLM
State ($s_t$)	현재까지의 입력 (프롬프트 + 생성된 토큰들)
Action ($a_t$)	다음 토큰 예측
Policy ($\pi_\theta$)	LLM의 출력 확률 분포
Environment	어휘(Vocabulary) 집합
Reward	Preference Data로부터 학습한 보상

┌─────────────────────────────────────────────────┐
│ LLM (Agent)                                     │
│           │                                     │
│ Input (State) 받음                               │
│           │                                     │
│           ▼                                     │
│ Policy (확률 분포)로 Action 선택                   │
│           │                                     │
│           ▼                                     │
│ 다음 토큰 생성 (Action)                           │
│           │                                     │
│           ▼                                     │
│ Reward 받음 → Policy 업데이트                     │
└─────────────────────────────────────────────────┘

2. RLHF의 두 단계

┌─────────────────────────────────────────────────────────────┐
│ RLHF 파이프라인                                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│ Stage 1: Reward Model 학습                                  │
│   입력: (Prompt, Response)                                   │
│   출력: Score (얼마나 좋은지)                                  │
│   데이터: Preference Pairs (수만 개)                          │
│              │                                              │
│              ▼                                              │
│                                                             │
│ Stage 2: Policy 최적화 (RL)                                  │
│   입력: Prompt                                               │
│   출력: Aligned Response                                     │
│   목표: Reward 최대화 + Base 모델에서 멀어지지 않기              │
│   데이터: 10만+ 개의 프롬프트                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Part 4: Reward Model 학습 (Stage 1)

1. Bradley-Terry Formulation

핵심 공식:

\[P(y_i \succ y_j | x) = \frac{e^{R(x, y_i)}}{e^{R(x, y_i)} + e^{R(x, y_j)}} = \sigma(R(x, y_i) - R(x, y_j))\]

여기서:

$y_i \succ y_j$: $y_i$가 $y_j$보다 좋음
$R(x, y)$: 프롬프트 $x$와 응답 $y$에 대한 보상 점수
$\sigma$: Sigmoid 함수

직관적 이해:

$R_i - R_j$가 크면 → $\sigma$ 값이 1에 가까움 → $i$가 더 좋을 확률 높음
$R_i - R_j$가 작으면 → $\sigma$ 값이 0에 가까움 → $j$가 더 좋을 확률 높음

Bradley-Terry Formulation 상세

Bradley-Terry Formulation 설명

핵심 공식

\[P(y_i \succ y_j | x) = \sigma(R(x, y_i) - R(x, y_j))\]

의미: “응답 $y_i$가 $y_j$보다 좋을 확률 = 두 보상 점수 차이를 시그모이드에 넣은 값”

시그모이드 함수 복습

\[\sigma(z) = \frac{1}{1 + e^{-z}} = \frac{e^z}{1 + e^z}\]

σ(z)
 1 ┤          ----------
   │        /
0.5 ┤-------·
   │      /
 0 ┤-----/
   └──────┬──────────→ z
          0

핵심 특성:

입력 z를 0과 1 사이로 압축
z가 크면 → 1에 가까움
z가 작으면 → 0에 가까움
z = 0이면 → 0.5

Bradley-Terry 직관적 이해

상황	$R_i - R_j$	$\sigma(R_i - R_j)$	해석
$y_i$가 훨씬 좋음	+5	≈ 0.99	$i$가 좋을 확률 99%
비슷함	0	0.5	반반
$y_j$가 훨씬 좋음	-5	≈ 0.01	$i$가 좋을 확률 1%

예시:

프롬프트: "테디베어 세탁법?"
응답 A (점수 3.0): "손세탁이 좋아요!"
응답 B (점수 1.0): "세탁기에 넣으세요."

P(A > B) = σ(3.0 - 1.0) = σ(2) ≈ 0.88
→ A가 더 좋을 확률 88%

시그모이드는 점수 차이를 “확률”로 바꿔주는 역할을 합니다. 이렇게 하면 Reward Model을 학습할 때 MLE(최대우도추정)를 적용할 수 있게 됩니다.

Sigmoid 함수 상세 및 사용하는 이유

시그모이드 함수의 의미와 사용 이유

1. 수학적 정의

\[\sigma(z) = \frac{1}{1 + e^{-z}}\]

2. 핵심 역할: “아무 숫자 → 확률로 변환”

입력 z: -∞ ~ +∞ (어떤 실수든 가능)
    ↓
    시그모이드
    ↓
출력: 0 ~ 1 (확률로 해석 가능)

입력 z	출력 σ(z)
-10	0.00005 (거의 0)
-2	0.12
0	0.5
+2	0.88
+10	0.99995 (거의 1)

3. 왜 시그모이드를 쓰는가?

이유 1: 확률로 해석 가능

모델이 출력한 점수(score)는 범위가 정해지지 않은 숫자입니다. 이를 “할 확률”로 바꾸려면 0~1 사이로 압축해야 합니다.

Reward Model 점수: R = 2.5 (이게 뭔 의미?)
    ↓
    σ(2.5) = 0.92 (92% 확률로 좋다!)

이유 2: 미분 가능 (학습에 필수)

시그모이드는 부드러운 곡선이라 미분이 가능합니다. 딥러닝은 gradient descent로 학습하므로 미분 가능해야 합니다.

\[\frac{d\sigma}{dz} = \sigma(z)(1 - \sigma(z))\]

이유 3: 비교를 확률로 변환 (Bradley)

두 응답의 점수 차이를 “이길 확률”로 자연스럽게 변환합니다.

응답 A 점수: 3.0
응답 B 점수: 1.0
차이: 3.0 - 1.0 = 2.0

σ(2.0) = 0.88 → "A가 B보다 좋을 확률 88%"

4. 직관적 비유

체스 ELO 레이팅과 비슷합니다:

선수 A: 레이팅 1600
선수 B: 레이팅 1400
차이: 200점

→ 이 차이를 시그모이드 같은 함수에 넣으면
→ "A가 이길 확률 76%"로 변환

Bradley-Terry도 같은 원리입니다. Reward 점수 차이 → 승률(선호 확률)로 변환합니다.

5. 요약

특성	설명
입력	모든 실수 ($-\infty$ ~ $+\infty$)
출력	0 ~ 1 (확률)
미분	가능 (학습 OK)
용도	이진 분류, 확률 변환, 선호도 모델링

시그모이드는 “점수를 확률로 바꾸는 변환기”라고 생각하면 됩니다.

2. Reward Model 손실 함수

유도 과정:

1. MLE (Maximum Likelihood Estimation) 적용
   → max ∏ P(y_w ≻ y_l | x)
2. Log 취하기 (수치 안정성)
   → max Σ log σ(R(x, y_w) - R(x, y_l))
3. 최소화 문제로 변환
   → min -Σ log σ(R(x, y_w) - R(x, y_l))

최종 손실 함수:

\[\mathcal{L}_{RM} = -\mathbb{E}_{(x, y_w, y_l) \sim D}\left[\log \sigma(R(x, y_w) - R(x, y_l))\right]\]

Reward Model 손실 함수 상세

Reward Model 손실 함수 상세 설명

1. 목표: Reward Model이 뭘 배워야 하는가?

데이터: 선호도 쌍 (prompt, 좋은 응답, 나쁜 응답)

x = "테디베어 세탁법?"
y_w (winner) = "손세탁이 좋아요! 테디가 다칠 수 있거든요."
y_l (loser) = "세탁기에 넣으세요."

목표: $R(x, y_w) > R(x, y_l)$ 이 되도록 학습 → 좋은 응답에 높은 점수, 나쁜 응답에 낮은 점수

2. 손실 함수 유도 과정

Step 1: Bradley-Terry로 확률 정의

\[P(y_w \succ y_l | x) = \sigma(R(x, y_w) - R(x, y_l))\]

“좋은 응답이 이길 확률 = 점수 차이를 시그모이드에 넣은 값”

Step 2: MLE (최대우도추정) 적용

아이디어: 데이터에서 관찰된 결과의 확률을 최대화

데이터: [(x_1, y_w_1, y_l_1), (x_2, y_w_2, y_l_2), ...]

우리가 관찰한 것: 매번 y_w가 y_l를 이김 (사람이 선택했으니까)

목표: 이 결과가 일어날 확률을 최대화!

\[\max \prod_i P(y_{w_i} \succ y_{l_i} | x_i)\]

Step 3: Log 취하기

곱셈은 계산이 불안정하므로 log를 취해 덧셈으로 변환:

\[\max \sum_i \log P(y_{w_i} \succ y_{l_i} | x_i)\]

Bradley-Terry 대입:

\[\max \sum_i \log \sigma(R(x_i, y_{w_i}) - R(x_i, y_{l_i}))\]

Step 4: 최소화 문제로 변환

딥러닝은 손실을 최소화하는 방식이므로 부호를 뒤집음:

\[\min - \sum_i \log \sigma(R(x_i, y_{w_i}) - R(x_i, y_{l_i}))\]

3. 최종 손실 함수

\[\mathcal{L}_{RM} = -\mathbb{E}_{(x, y_w, y_l)} \left[\log \sigma(R(x, y_w) - R(x, y_l))\right]\]

기대값($\mathbb{E}$)은 “평균”이라고 생각하면 됩니다.

4. 직관적 이해

손실 함수가 하는 일

상황	$R_w - R_l$	$\sigma(\cdots)$	$\log \sigma$	손실 $-\log \sigma$
잘 학습됨 (좋은 응답 점수 높음)	+5	0.99	-0.01	0.01 (낮음 ✓)
비슷함	0	0.5	-0.69	0.69 (중간)
잘못 학습됨 (나쁜 응답 점수 높음)	-5	0.01	-4.6	4.6 (높음 ✗)

핵심:

좋은 응답 점수가 높으면 → 손실 낮음 → OK!
나쁜 응답 점수가 높으면 → 손실 높음 → 벌칙!

5. 그림으로 이해

[학습 전]
y_w: "손세탁이 좋아요!"    → R = 0.5
y_l: "세탁기에 넣으세요"    → R = 0.8  ← 나쁜 응답이 점수 높음!

차이: 0.5 - 0.8 = -0.3
σ(-0.3) = 0.43
손실: -log(0.43) = 0.84 (높음!)

        ↓ 학습 ↓

[학습 후]
y_w: "손세탁이 좋아요!"    → R = 2.5  ← 점수 올라감!
y_l: "세탁기에 넣으세요"    → R = 0.3  ← 점수 내려감!

차이: 2.5 - 0.3 = 2.2
σ(2.2) = 0.90
손실: -log(0.90) = 0.11 (낮음!)

6. 요약

구성 요소	역할
$R(x, y_w) - R(x, y_l)$	좋은 응답과 나쁜 응답의 점수 차이
$\sigma(\cdots)$	차이를 0~1 확률로 변환
$\log(\cdots)$	수치 안정성 + 곱셈→덧셈 변환
$-(\cdots)$	최대화→최소화 문제로 변환

한 문장 요약: “좋은 응답이 나쁜 응답보다 높은 점수를 받을 확률”을 최대화하도록 학습합니다.

최종 손실 함수 쉽게 이해하기

최종 손실 함수 완전 분해

\[\mathcal{L}_{RM} = -\mathbb{E}_{(x, y_w, y_l)} \left[ \log \sigma(R(x, y_w) - R(x, y_l)) \right]\]

안쪽부터 바깥쪽으로 하나씩 뜯어봅시다.

Layer 1: 가장 안쪽 - 점수 차이

\[R(x, y_w) - R(x, y_l)\]

R(x, y_w) = Reward Model이 "좋은 응답"에 준 점수
R(x, y_l) = Reward Model이 "나쁜 응답"에 준 점수

예시:
  R("테디 세탁법?", "손세탁 추천!") = 2.5
  R("테디 세탁법?", "세탁기 넣어") = 0.3

  차이 = 2.5 - 0.3 = 2.2

의미: 좋은 응답이 얼마나 더 높은 점수를 받았는가?

Layer 2: 시그모이드 - 확률로 변환

\[\sigma(R(x, y_w) - R(x, y_l))\]

점수 차이 2.2
  ↓
σ(2.2) = 0.90
  ↓
"좋은 응답이 이길 확률 90%"

의미: 점수 차이를 “좋은 응답이 선택될 확률”로 변환

Layer 3: 로그 - 수치 안정화

\[\log \sigma(\ldots)\]

확률 0.90
  ↓
log(0.90) = -0.105

왜 log를 쓰는가?

이유	설명
수치 안정성	작은 확률의 곱셈 → 0에 가까워짐 방지
곱셈 → 덧셈	$\log(a \times b) = \log a + \log b$
그래디언트	확률이 낮을수록 더 큰 페널티

Layer 4: 마이너스 - 최소화 문제로

\[-\log \sigma(\ldots)\]

log(0.90) = -0.105
  ↓
-(-0.105) = 0.105  ← 이게 손실!

왜 마이너스?

원래 목표: 확률 최대화 (좋은 응답이 이길 확률↑)
딥러닝 프레임워크: 최소화만 함
해결: 부호 뒤집기 → 최소화 = 원래 확률 최대화

Layer 5: 기대값 - 평균

\[\mathbb{E}_{(x, y_w, y_l)}[\ldots]\]

데이터셋에 1000개 쌍이 있다면:

손실 = (손실₁ + 손실₂ + ... + 손실₁₀₀₀) / 1000

즉, 모든 데이터에 대한 평균 손실

의미: 전체 데이터에 대해 평균적으로 손실을 계산

전체 흐름 요약

(x, y_w, y_l) = ("테디 세탁법?", "손세탁!", "세탁기!")
         ↓
R(x, y_w) - R(x, y_l) = 2.5 - 0.3 = 2.2
  → 점수 차이 계산
         ↓
σ(2.2) = 0.90
  → 확률로 변환 (좋은 응답이 이길 확률 90%)
         ↓
log(0.90) = -0.105
  → 로그 취함
         ↓
-(-0.105) = 0.105
  → 부호 뒤집어서 손실로
         ↓
E[...] = 모든 데이터 쌍에 대해 평균
  → 최종 손실

한 문장 정리

“모든 데이터에 대해, 좋은 응답의 점수가 나쁜 응답보다 높을 확률의 (마이너스) 로그 평균”

손실이 낮아지면 → 좋은 응답이 높은 점수를 받을 확률이 올라갑니다.

3. Reward Model의 특징

특성	설명
학습 방식	Pairwise (쌍으로 비교하며 학습)
추론 방식	Pointwise (하나의 (prompt, response)만 입력해도 점수 출력)
출력	연속적인 점수 (예: 0.8, -2.0 등)
모델 구조	Decoder-only LLM + Classification Head 또는 BERT + CLS

┌─────────────────────────────────────────────────┐
│ Reward Model 학습 vs 추론                        │
├─────────────────────────────────────────────────┤
│                                                 │
│ [학습 시] - Pairwise                             │
│ (x, y_w) → RM → R_w ─┐                         │
│                       ├→ Loss 계산               │
│ (x, y_l) → RM → R_l ─┘                         │
│                                                 │
│ [추론 시] - Pointwise                            │
│ (x, y) → RM → Score (단일 점수)                  │
│                                                 │
└─────────────────────────────────────────────────┘

Part 5: Policy 최적화 (Stage 2) - PPO

1. 목표: 두 가지 균형

최대화하고 싶은 것:
Reward (보상)
Base 모델과의 유사성 유지

왜 Base 모델에서 멀어지면 안 되는가?
Catastrophic Forgetting: Pre-training에서 배운 지식 손실
Reward Hacking: 불완전한 Reward Model 악용
Training Instability: 학습 불안정

2. Reward Hacking 예시

비유: 강의 품질 최적화
  목표: 강의를 최대한 유익하게 만들기
  보상: 강의 끝 박수 소리 크기
  문제:
    - 박수 소리를 최대화하려고 농담만 하게 됨
    - 박수는 크지만 → 강의는 유익하지 않음
    - 보상(박수)은 목표(유익함)의 불완전한 대리 지표
  → 이것이 Reward Hacking!

3. PPO 손실 함수 개요

\[\mathcal{L}_{PPO} = \mathbb{E}\left[R(x, y)\right] - \beta \cdot D_{KL}(\pi_\theta \| \pi_{ref})\]

항	의미	역할
$R(x, y)$	Reward	높이고 싶음
$D_{KL}$	KL Divergence	낮추고 싶음 (Base 모델과 가깝게)
$\beta$	균형 계수	두 목표 사이 균형 조절 (보통 ~0.1)

4. KL Divergence

\[D_{KL}(P \| Q) = \sum_i P_i \log \frac{P_i}{Q_i}\]

특성:

항상 ≥ 0 (Jensen’s Inequality)
P = Q일 때만 = 0
두 확률 분포의 “거리” 측정 (엄밀한 거리는 아님)

KL Divergence(Kullback-Leibler Divergence) 상세

KL Divergence (Kullback-Leibler Divergence) 완전 정복

1. 한 줄 정의

“두 확률 분포가 얼마나 다른지”를 측정하는 값

2. 수학적 정의

이산 분포 (Discrete)

\[D_{KL}(P \| Q) = \sum_x P(x) \log \frac{P(x)}{Q(x)}\]

연속 분포 (Continuous)

\[D_{KL}(P \| Q) = \int p(x) \log \frac{p(x)}{q(x)} dx\]

3. 수식 분해

\[D_{KL}(P \| Q) = \sum_x P(x) \log \frac{P(x)}{Q(x)}\]

부분	의미
$P(x)$	기준이 되는 분포 (보통 “진짜” 분포)
$Q(x)$	비교 대상 분포 (보통 “모델” 분포)
$\frac{P(x)}{Q(x)}$	두 분포의 비율
$\log \frac{P(x)}{Q(x)}$	비율의 로그 (차이 측정)
$P(x) \cdot (\ldots)$	P 기준으로 가중 평균

4. 직관적 이해

비유: 두 주사위 비교

주사위 P (공정한 주사위):
  1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6

주사위 Q (조작된 주사위):
  1: 1/12, 2: 1/12, 3: 1/12, 4: 1/12, 5: 1/12, 6: 7/12

KL Divergence가 측정하는 것:

P라고 생각했는데 실제로 Q였다면, 얼마나 “놀라운가”?
두 분포가 같으면 → $D_{KL} = 0$
다르면 → $D_{KL} > 0$

5. 계산 예시

간단한 예: 동전 던지기

P: 공정한 동전 (앞면 0.5, 뒷면 0.5)
Q: 편향된 동전 (앞면 0.8, 뒷면 0.2)

\[D_{KL}(P \| Q) = P(\text{앞}) \log \frac{P(\text{앞})}{Q(\text{앞})} + P(\text{뒤}) \log \frac{P(\text{뒤})}{Q(\text{뒤})}\] \[= 0.5 \log \frac{0.5}{0.8} + 0.5 \log \frac{0.5}{0.2}\] \[= 0.5 \times (-0.47) + 0.5 \times (0.92)\] \[= -0.235 + 0.46 = 0.225\]

해석: 두 동전 분포의 차이는 약 0.225

6. KL Divergence의 특성

특성	설명
항상 ≥ 0	두 분포가 같을 때만 0
비대칭	$D_{KL}(P \| Q) \neq D_{KL}(Q \| P)$
거리 아님	삼각부등식 성립 안 함

비대칭성 예시

D_KL(P || Q): "P 관점에서 Q가 얼마나 다른가"
D_KL(Q || P): "Q 관점에서 P가 얼마나 다른가"

→ 두 값이 다름!

7. LLM에서의 KL Divergence

PPO 손실 함수에서의 역할

\[\mathcal{L}_{PPO} = \mathbb{E}[R(x, y)] - \beta \cdot D_{KL}(\pi_\theta \| \pi_{ref})\]

π_θ   = 학습 중인 모델의 출력 분포
π_ref = Reference 모델 (SFT 모델)의 출력 분포

D_KL(π_θ || π_ref) = 학습 모델이 기준 모델에서 얼마나 벗어났는가

왜 필요한가?

┌─────────────────────────────────────┐
│        KL Penalty 없이 학습          │
├─────────────────────────────────────┤
│                                     │
│ 목표: Reward 최대화만!               │
│                                     │
│ 문제점:                              │
│ 1. Reward Hacking (보상 함수 악용)   │
│ 2. Catastrophic Forgetting (기존 지식 망각) │
│ 3. 이상한 응답 생성 (분포가 너무 달라짐) │
│                                     │
└─────────────────────────────────────┘

┌─────────────────────────────────────┐
│        KL Penalty 있으면             │
├─────────────────────────────────────┤
│                                     │
│ "Reward 높이되, 원래 모델에서 너무 멀어지지 마!" │
│                                     │
│ 효과:                                │
│ 1. 안정적인 학습                     │
│ 2. 기존 능력 유지                    │
│ 3. 자연스러운 응답 유지              │
│                                     │
└─────────────────────────────────────┘

8. LLM에서 KL 계산 방법

토큰 단위 계산

\[D_{KL}(\pi_\theta \| \pi_{ref}) = \sum_t \sum_{v \in V} \pi_\theta(v | x_{<t}) \log \frac{\pi_\theta(v | x_{<t})}{\pi_{ref}(v | x_{<t})}\]

각 위치 t에서:
  - 모든 가능한 토큰 v에 대해
  - 두 모델의 확률 분포 비교
  - 가중 평균 계산

실제 구현 (간소화)

  
# 생성된 토큰에 대해서만 계산 (근사)
kl = (log_prob_policy - log_prob_ref).mean()

9. $\beta$ (베타) 하이퍼파라미터

\[\mathcal{L} = \mathbb{E}[R] - \beta \cdot D_{KL}\]

$\beta$ 값	효과
$\beta$ 큼	KL 페널티 강함 → 보수적 학습 (원래 모델 유지)
$\beta$ 작음	KL 페널티 약함 → 공격적 학습 (Reward 추구)
$\beta$ = 0	KL 무시 → 위험! (Reward Hacking 가능)

10. 시각적 이해

  확률
  │
  │ ┌┐
  │ ││    ┌┐
  │ ││ P  ││ Q
  └─┴┴────┴┴──────→ 토큰
   "안녕"   "ㅋㅋ"

D_KL가 크면: P와 Q의 모양이 많이 다름
D_KL가 작으면: P와 Q의 모양이 비슷함
D_KL = 0: P와 Q가 완전히 같음

11. 요약

항목	내용
정의	두 확률 분포의 차이 측정
수식	$D_{KL}(P \| Q) = \sum P(x) \log \frac{P(x)}{Q(x)}$
범위	0 이상 (같으면 0)
LLM 용도	학습 모델이 기준 모델에서 벗어나는 정도 제한
효과	안정적 학습, Reward Hacking 방지

한 문장: KL Divergence는 “새 모델이 원래 모델에서 얼마나 달라졌는지”를 측정해서, 너무 이상해지지 않도록 제동을 거는 역할을 합니다.

5. Advantage 함수

정의: 현재 행동이 평균 대비 얼마나 좋은지

\[A(s, a) = Q(s, a) - V(s)\]

$Q(s, a)$: State-Action Value (이 상태에서 이 행동의 기대 보상)
$V(s)$: Value Function (이 상태의 평균 기대 보상)

왜 Advantage를 사용하는가?

Reward 직접 사용 시 분산(Variance)이 큼
Baseline(평균) 대비 상대적 값 사용 → 분산 감소 → 학습 안정화

6. Value Function

정의: 현재 상태에서 Policy를 따랐을 때의 기대 보상

┌─────────────────────────────────────────────────┐
│ Value Function 개념                              │
├─────────────────────────────────────────────────┤
│                                                 │
│ Reward Model:                                   │
│   입력: Prompt + 완전한 Response                  │
│   출력: 전체 응답의 점수                           │
│                                                 │
│ Value Function:                                  │
│   입력: Prompt + 부분 Response (토큰 레벨)         │
│   출력: 계속 생성했을 때의 예상 Reward              │
│                                                 │
└─────────────────────────────────────────────────┘

학습: Policy와 함께 Joint Training

Value Function 상세

Value Function 완전 정복

1. 핵심 차이: Reward Model vs Value Function

Reward Model: “완성된 답의 점수”

입력: "테디 세탁법?" + "손세탁이 좋아요! 부드럽게 해주세요."
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                      완성된 전체 응답
출력: 2.5점

Value Function: “지금까지 잘 가고 있나?”

입력: "테디 세탁법?" + "손세탁이"
                      ^^^^^^^^
                      아직 생성 중 (부분 응답)
출력: "이대로 계속 가면 약 2.3점 받을 것 같아"

2. 비유로 이해하기

마라톤 비유

┌─────────────────────────────────────┐
│           마라톤 경기                 │
├─────────────────────────────────────┤
│                                     │
│ Reward Model = 결승선 심판           │
│   → 완주 후에만 점수 줌              │
│   → "총 2시간 30분, 85점!"          │
│                                     │
│ Value Function = 중간 코치           │
│   → 달리는 중간에 예측               │
│   → "지금 페이스면 약 83점 나올 것 같아" │
│   → "10Km 지점인데 잘 가고 있어!"    │
│                                     │
└─────────────────────────────────────┘

3. LLM 토큰 생성에서의 역할

프롬프트: "테디베어 세탁법?"

생성 과정:

┌ 토큰 1: "손"
│     V("손") = 1.8  ← "이 방향 괜찮아, 계속 가면 1.8 예상"
│
├ 토큰 2: "손세탁"
│     V("손세탁") = 2.1  ← "오 좋아지고 있어!"
│
├ 토큰 3: "손세탁이"
│     V("손세탁이") = 2.2  ← "계속 좋아!"
│
├ 토큰 4: "손세탁이 좋아요"
│     V("손세탁이 좋아요") = 2.4
│
├ ... 완성 ...
│ "손세탁이 좋아요! 부드럽게 해주세요."
│     R(완성) = 2.5  ← 실제 Reward (최종 점수)
└

4. 수학적 정의

\[V(s_t) = \mathbb{E} \left[ \sum_{k=0}^{T-t} R_{t+k} \mid s_t, \pi \right]\]

쉽게 풀면:

기호	의미
$V(s_t)$	현재 상태 $s_t$의 가치
$s_t$	프롬프트 + 지금까지 생성한 토큰들
$\pi$	현재 Policy (LLM)
$\mathbb{E}[\ldots]$	기대값 (평균적으로)
$R$	미래에 받을 보상

“지금 상태에서 현재 Policy대로 끝까지 생성하면 평균적으로 받을 점수”

5. 왜 Value Function이 필요한가?

문제: Reward는 마지막에만 나옴

토큰 1 생성 → 보상? 없음
토큰 2 생성 → 보상? 없음
토큰 3 생성 → 보상? 없음
...
토큰 100 생성 (완료) → 보상 = 2.5

문제: 어떤 토큰이 좋은 선택이었는지 어떻게 알지?
      토큰 37이 잘한 건가? 못한 건가?

해결: Advantage 계산에 사용

\[A_t = R_t - V(s_t)\]

Advantage = 실제 결과 - 예상했던 결과

A > 0: "예상보다 잘했네!" → 이 행동 강화
A < 0: "예상보다 못했네..." → 이 행동 약화
A = 0: "예상대로네" → 변화 없음

6. Advantage 예시

상황: 토큰 "좋아요"를 생성하는 순간

V(이전 상태) = 2.0  ← "여기까지 오면 보통 2.0점 받아"

실제로 "좋아요" 생성 후 최종 점수 = 2.5

Advantage = 2.5 - 2.0 = +0.5

해석: "좋아요"는 좋은 선택이었다! (예상보다 0.5점 높음)
      → 다음에도 비슷한 상황에서 "좋아요" 생성 확률 ↑

다른 상황: 토큰 "몰라요"를 생성하는 순간

V(이전 상태) = 2.0  ← "여기까지 오면 보통 2.0점 받아"

실제로 "몰라요" 생성 후 최종 점수 = 0.5

Advantage = 0.5 - 2.0 = -1.5

해석: "몰라요"는 나쁜 선택이었다! (예상보다 1.5점 낮음)
      → 다음에 비슷한 상황에서 "몰라요" 생성 확률 ↓

7. Value Function 학습 (Joint Training)

┌─────────────────────────────────────┐
│           PPO 학습 루프              │
├─────────────────────────────────────┤
│                                     │
│ 1. Policy로 응답 생성                │
│                                     │
│ 2. Reward Model로 최종 점수 받음 (R = 2.5) │
│                                     │
│ 3. Value Function 업데이트:          │
│    "내가 예측한 V(s)가 실제 R과 가까워지도록 학습" │
│                                     │
│    Loss_V = (V(s) - R)²             │
│                                     │
│ 4. Policy 업데이트:                  │
│    Advantage = R - V(s) 사용해서 업데이트 │
│                                     │
│ → Policy와 Value Function이 함께(Joint) 학습됨! │
│                                     │
└─────────────────────────────────────┘

8. 전체 그림: PPO의 4개 모델

┌─────────────────────────────────────┐
│       PPO에 필요한 4개 모델          │
├─────────────────────────────────────┤
│                                     │
│ ┌─────────────┐ ┌─────────────────┐ │
│ │ Policy (π_θ)│ │ Value Function  │ │
│ │ "다음 토큰은?"│ │ "예상 점수는?"   │ │
│ │ [학습 O]     │ │ [학습 O]        │ │
│ └──────┬──────┘ └────────┬────────┘ │
│        │                 │          │
│        └────────┬────────┘          │
│                 │                   │
│          Joint Training             │
│     (함께 학습, Advantage 계산)      │
│                 │                   │
│ ┌─────────────┐ ┌─────────────────┐ │
│ │ Reward Model│ │ Reference Model │ │
│ │"완성본 점수는?"│ │ "원래 확률은?"   │ │
│ │ [Frozen]     │ │ [Frozen]        │ │
│ └─────────────┘ └─────────────────┘ │
│                                     │
└─────────────────────────────────────┘

9. 요약 비교표

구분	Reward Model	Value Function
입력	완성된 응답	부분 응답 (생성 중)
출력	실제 점수	예상 점수
시점	생성 완료 후	생성 중 매 토큰
학습	미리 학습 (Frozen)	Policy와 함께 학습
용도	최종 평가	Advantage 계산

10. 최종 요약

Value Function = “지금까지 이 방향으로 가면 최종적으로 몇 점 받을지 예측하는 모델”

이게 있어야:

각 토큰의 기여도를 알 수 있음 (Advantage)
좋은 토큰은 강화, 나쁜 토큰은 약화
효율적인 Policy 학습 가능

Part 6: PPO 변형들

1. PPO-Clip

목표: 한 번의 업데이트가 너무 크지 않도록 제한

\[\mathcal{L}^{CLIP} = \min\left(r(\theta) \cdot A, \text{clip}(r(\theta), 1-\epsilon, 1+\epsilon) \cdot A\right)\]

여기서:

$r(\theta) = \frac{\pi_\theta(a s)}{\pi_{\theta_{old}}(a s)}$ : Policy 비율 (현재 / 이전 iteration)
$\epsilon$ : 클리핑 범위 (보통 0.1~0.2)
$A$ : Advantage

주의: $r(\theta)$는 Reward가 아니라 확률 비율!

직관적 이해:

A > 0 (좋은 행동일 때):
  → r을 높이고 싶지만 1+ε까지만!

A < 0 (나쁜 행동일 때):
  → r을 낮추고 싶지만 1-ε까지만!

PPO-Clip 상세

PPO-Clip 완전 정복

1. 먼저 기본 개념 복습

Policy Gradient의 기본 아이디어

좋은 행동 → 그 행동 확률 높이기
나쁜 행동 → 그 행동 확률 낮추기

문제점: 너무 급격한 업데이트

"이 토큰이 좋았어!"
  ↓
확률 10% → 90%로 급상승?!
  ↓
모델이 망가짐 (학습 불안정)

2. PPO-Clip의 핵심 아이디어

“좋은 행동이든 나쁜 행동이든, 한 번에 변화할 수 있는 양을 제한하자”

3. 수식 완전 분해

\[\mathcal{L}^{CLIP} = \mathbb{E} [\min (r(\theta) \cdot A, \text{clip}(r(\theta), 1 - \epsilon, 1 + \epsilon) \cdot A)]\]

Step 1: 확률 비율 $r(\theta)$

\[r(\theta) = \frac{\pi_\theta(a|s)}{\pi_{old}(a|s)}\]

기호	의미
$\pi_\theta(a \mid s)$	새 모델이 상태 s에서 행동 a를 할 확률
$\pi_{old}(a \mid s)$	이전 모델이 상태 s에서 행동 a를 할 확률
$r(\theta)$	두 확률의 비율

예시:

이전 모델: "좋아요" 생성 확률 = 20%
새 모델:   "좋아요" 생성 확률 = 30%

r(θ) = 0.30 / 0.20 = 1.5

→ 새 모델이 이 행동을 1.5배 더 자주 함

$r(\theta)$ 값의 의미:

$r(\theta)$ 값	의미
r = 1.0	변화 없음
r = 1.5	새 모델이 50% 더 자주 선택
r = 2.0	새 모델이 2배 더 자주 선택
r = 0.5	새 모델이 절반만 선택
r = 0.1	새 모델이 거의 안 선택

Step 2: Advantage $A$

\[A = R - V(s)\]

A > 0: 예상보다 좋았음 → 이 행동 더 하자!
A < 0: 예상보다 나빴음 → 이 행동 줄이자!
A = 0: 예상대로 → 그대로 유지

예시:

상황: 토큰 "좋아요" 생성

예상 점수 V(s) = 2.0
실제 점수 R = 2.8

A = 2.8 - 2.0 = +0.8 (예상보다 좋았음!)

Step 3: Clip 함수

\[\text{clip}(r, 1 - \epsilon, 1 + \epsilon)\]

보통 $\epsilon = 0.2$ 사용

clip(r, 0.8, 1.2) 의 작동:

r = 0.5  → clip 후: 0.8  (너무 낮으면 0.8로 제한)
r = 0.9  → clip 후: 0.9  (범위 안이면 그대로)
r = 1.0  → clip 후: 1.0  (범위 안이면 그대로)
r = 1.1  → clip 후: 1.1  (범위 안이면 그대로)
r = 1.5  → clip 후: 1.2  (너무 높으면 1.2로 제한)
r = 3.0  → clip 후: 1.2  (너무 높으면 1.2로 제한)

Step 4: min 함수

\[\min (r(\theta) \cdot A, \text{clip}(r(\theta), 1 - \epsilon, 1 + \epsilon) \cdot A)\]

왜 min을 쓰는가?

“두 값 중 더 보수적인(덜 낙관적인) 것을 선택”

4. 경우의 수 분석

Case 1: A > 0 (좋은 행동)

A > 0: "이 행동 좋았어! 확률 높이고 싶어!"

목표: r(θ) × A 를 최대화 → r을 높이고 싶음

하지만 clip이 제한:

  ┌─────────────────────────────────────────┐
  │ r = 1.5, A = 1.0 일 때:                │
  │                                         │
  │ 항목 1: r × A = 1.5 × 1.0 = 1.5       │
  │ 항목 2: clip(r) × A = 1.2 × 1.0 = 1.2 │
  │                                         │
  │ min(1.5, 1.2) = 1.2 ← 이걸 사용!       │
  │                                         │
  │ 효과: r이 1.2 넘어가도 이득 없음        │
  │   → "너무 급하게 확률 높이지 마!"       │
  └─────────────────────────────────────────┘

그래프로 이해:

손실(최대화 목표)

1.2 ┤        ●──────────── (clip으로 제한됨)
1.0 ┤       /
0.8 ┤      /
    ┤     /
    ├──┬──┬──┬──┬──┬──→ r(θ)
      0.8 1.0 1.2 1.5 2.0

    r이 1.2 넘어가면 더 이상 이득 없음!

Case 2: A < 0 (나쁜 행동)

A < 0: "이 행동 나빴어! 확률 낮추고 싶어!"

목표: r(θ) × A 를 최대화 → r을 낮추고 싶음 (A가 음수니까)

하지만 clip이 제한:

  ┌─────────────────────────────────────────────────┐
  │ r = 0.5, A = -1.0 일 때:                       │
  │                                                 │
  │ 항목 1: r × A = 0.5 × (-1.0) = -0.5           │
  │ 항목 2: clip(r) × A = 0.8 × (-1.0) = -0.8     │
  │                                                 │
  │ min(-0.5, -0.8) = -0.8 ← 이걸 사용!            │
  │                                                 │
  │ 효과: r이 0.8 아래로 내려가도 이득 없음          │
  │   → "너무 급하게 확률 낮추지 마!"               │
  └─────────────────────────────────────────────────┘

그래프로 이해:

손실(최대화 목표)
                          → r(θ)
       0.5 0.8 1.0 1.2
        ┤   ┤   ┤   ┤
            \
-0.8 ┤──────● (clip으로 제한됨)
-1.0 ┤       \

    r이 0.8 아래로 내려가도 더 이상 이득 없음!

5. 전체 요약 표

상황	r 범위	효과
A > 0, r < 1.2	허용	확률 높이기 가능
A > 0, r > 1.2	제한	더 높여도 이득 없음
A < 0, r > 0.8	허용	확률 낮추기 가능
A < 0, r < 0.8	제한	더 낮춰도 이득 없음

6. 왜 이렇게 설계했나?

PPO-Clip의 철학

"Trust Region" 개념:

● 현재 Policy 주변의 "신뢰 구역" 안에서만 업데이트
● r이 0.8 ~ 1.2 범위 = 신뢰 구역
● 이 범위를 벗어나면 → 예측이 불확실해짐
● 불확실한 영역에서 급격한 변화 = 위험!

        신뢰 구역
      ←──────────→
      0.8   1.0   1.2
            현재 Policy
             ●
          여기서만 안전

7. 실제 예시로 전체 과정

프롬프트: "테디베어 세탁법?"
생성된 토큰: "손세탁"

Step 1: 확률 계산
  이전 모델 π_old("손세탁") = 0.15 (15%)
  새 모델 π_θ("손세탁") = 0.25 (25%)
  r(θ) = 0.25 / 0.15 = 1.67

Step 2: Advantage 계산
  실제 Reward R = 2.5
  예상 Value V = 2.0
  A = 2.5 - 2.0 = +0.5 (좋은 행동!)

Step 3: Clip 적용
  clip(1.67, 0.8, 1.2) = 1.2

Step 4: 손실 계산
  항목 1: r × A = 1.67 × 0.5 = 0.835
  항목 2: clip(r) × A = 1.2 × 0.5 = 0.6
  min(0.835, 0.6) = 0.6 ← 최종 손실

해석:
  "손세탁"은 좋은 선택이었지만,
  확률을 1.67배나 높이려는 건 너무 급해!
  1.2배까지만 허용할게.

8. PPO-Clip vs KL Penalty 비교

측면	PPO-Clip	KL Penalty
제한 방식	비율 r을 하드하게 자름	거리에 비례해서 벌점
수식	$\min(r \cdot A, \text{clip}(r) \cdot A)$	$R - \beta \cdot D_{KL}$
구현	간단	KL 계산 필요
하이퍼파라미터	$\epsilon$ (보통 0.2)	$\beta$ (튜닝 필요)
사용 빈도	더 많이 사용	가끔 사용

9. 코드로 이해하기 (의사코드)

  
def ppo_clip_loss(old_probs, new_probs, advantages, epsilon=0.2):
    # Step 1: 확률 비율 계산
    r = new_probs / old_probs

    # Step 2: Clip 적용
    r_clipped = torch.clamp(r, 1 - epsilon, 1 + epsilon)

    # Step 3: 두 항 계산
    term1 = r * advantages
    term2 = r_clipped * advantages

    # Step 4: 보수적인 것 선택 (min)
    loss = torch.min(term1, term2)

    # 최대화 목표이므로 음수 붙여서 반환
    return -loss.mean()

10. 최종 요약

항목	내용
목적	급격한 Policy 변화 방지
방법	확률 비율 r을 [1-ε, 1+ε] 범위로 제한
효과	좋은 행동도, 나쁜 행동도 “적당히만” 조절
장점	안정적 학습, 구현 간단
ε 값	보통 0.1 ~ 0.2

한 문장:

PPO-Clip은 “확률 변화를 20% 이내로 제한해서” 모델이 한 번에 너무 급격하게 바뀌는 것을 막는 안전장치입니다.

2. PPO-KL Penalty

\[\mathcal{L}^{KL} = r(\theta) \cdot A - \beta \cdot D_{KL}(\pi_{\theta_{old}} \| \pi_\theta)\]

현대적 사용:

old 대신 ref (SFT 모델) 사용
Clip과 KL Penalty를 함께 사용하기도 함

3. PPO에서 필요한 모델들

┌─────────────────────────────────────────────────┐
│ PPO에 필요한 4개의 모델                           │
├─────────────────────────────────────────────────┤
│                                                 │
│ 1. Policy (π_θ) - 학습 대상                      │
│ 2. Value Function - Advantage 계산용             │
│ 3. Reward Model - 보상 계산용 (Frozen)            │
│ 4. Reference Model - KL 계산용 (Frozen)          │
│                                                 │
│ → 메모리와 계산 비용이 매우 높음!                   │
└─────────────────────────────────────────────────┘

Part 7: RL 기반 접근법의 도전과제

도전과제	설명
2단계 프로세스	Reward Model → Policy 순서, 의존성 문제
많은 하이퍼파라미터	β, ε, GAE 파라미터 등 튜닝 필요
학습 불안정성	제약을 걸어도 불안정할 수 있음
모니터링 어려움	Average Reward로 모니터링하지만 불완전
탐색 필요	다양한 Completion 생성을 위한 Exploration 필요
RL 전문성 필요	RL에 익숙하지 않으면 어려움

On-Policy vs Off-Policy

유형	설명	예시
On-Policy	현재 모델이 생성한 데이터로 학습	PPO
Off-Policy	다른 모델이 생성한 데이터로 학습	SFT

PPO는 On-Policy:

매 iteration마다 현재 Policy로 생성
생성된 결과로 Policy 업데이트
SFT보다 신호가 Sparse함

Part 8: Best-of-N (BoN)

1. 개념

아이디어: RL 학습 없이 Reward Model만 활용

┌─────────────────────────────────────────────────┐
│ Best-of-N 방법                                   │
├─────────────────────────────────────────────────┤
│                                                 │
│ 1. 프롬프트 입력                                  │
│                                                 │
│ 2. SFT 모델로 N개의 응답 생성                     │
│    (높은 Temperature로 다양성 확보)                │
│                                                 │
│ 3. 각 응답을 Reward Model로 점수화               │
│    Response 1: 0.8                               │
│    Response 2: -2.0                              │
│    Response 3: 0.3                               │
│                                                 │
│ 4. 가장 높은 점수의 응답 반환                      │
│    → Response 1 선택!                            │
│                                                 │
└─────────────────────────────────────────────────┘

2. 장단점

장점	단점
RL 학습 불필요	추론 비용 N배 증가
구현 간단	대규모 서비스에 부적합
학습 불안정성 없음	모델 자체 개선 없음

적합한 상황:

추론 트래픽이 적을 때
빠른 프로토타이핑이 필요할 때

Part 9: DPO (Direct Preference Optimization)

1. 동기

RLHF의 문제점:

4개의 모델 필요 (Policy, Value, Reward, Reference)
2단계 학습 (Reward → Policy)
학습 불안정
많은 하이퍼파라미터

DPO의 아이디어: RL 없이 직접 Preference 최적화!

2. DPO 유도 과정

Step 1: PPO 목표 함수

\[\max_\pi \mathbb{E}[R(x, y)] - \beta \cdot D_{KL}(\pi \| \pi_{ref})\]

Step 2: 최적 Policy 도출

\[\pi^*(y|x) = \frac{1}{Z(x)} \pi_{ref}(y|x) \exp\left(\frac{R(x,y)}{\beta}\right)\]

Step 3: Reward를 Policy로 표현

\[R(x, y) = \beta \log \frac{\pi^*(y|x)}{\pi_{ref}(y|x)} + \beta \log Z(x)\]

Step 4: Bradley-Terry에 대입

\[P(y_w \succ y_l | x) = \sigma\left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\]

3. DPO 손실 함수

\[\mathcal{L}_{DPO} = -\mathbb{E}_{(x, y_w, y_l)}\left[\log \sigma\left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\right]\]

4. DPO의 핵심 인사이트

“Your Language Model is Secretly a Reward Model”

Reward를 명시적으로 학습하지 않음
Policy 자체가 암묵적으로 Reward를 인코딩
Reward Model이 사라지고 Policy만 남음!

5. DPO vs RLHF 비교

측면	RLHF (PPO)	DPO
필요 모델 수	4개	2개 (Policy, Reference)
학습 단계	2단계	1단계
Reward Model	필요	불필요
학습 방식	On-Policy (RL)	Supervised
구현 복잡도	높음	낮음
성능	약간 더 좋음	거의 비슷
하이퍼파라미터	많음	적음 (β 정도)

┌─────────────────────────────────────────────────┐
│ RLHF vs DPO 비교                                 │
├─────────────────────────────────────────────────┤
│                                                 │
│ RLHF:                                           │
│ ┌──────────┐    ┌──────────┐                    │
│ │ Reward   │ → │ Policy   │                     │
│ │ Training │    │ Training │                     │
│ └──────────┘    └──────────┘                    │
│  (Stage 1)       (Stage 2)                      │
│  + Value Fn + Reference Model                   │
│                                                 │
│ DPO:                                            │
│ ┌──────────────────────────┐                    │
│ │ Direct Policy Training   │                    │
│ │ (Preference Pairs 직접)   │                   │
│ └──────────────────────────┘                    │
│  + Reference Model only                         │
│                                                 │
└─────────────────────────────────────────────────┘

6. DPO의 한계

한계	설명
Distribution Shift	Preference Data가 모델 분포와 다를 수 있음
Off-Policy	현재 모델이 생성한 데이터가 아님
성능 차이	PPO가 약간 더 좋은 성능을 보이는 경우 있음

해결책:

Preference Data를 SFT로 먼저 학습
직접 모델로 Preference Data 생성 후 평가

DPO (Direct Preference Optimization) 상세

DPO (Direct Preference Optimization) 완전 정복

1. DPO가 나온 이유

RLHF (PPO)의 문제점

┌─────────────────────────────────────────────┐
│           RLHF의 복잡함                     │
├─────────────────────────────────────────────┤
│                                             │
│ Stage 1: Reward Model 학습                  │
│   └ Preference Data로 별도 모델 학습        │
│                                             │
│ Stage 2: PPO로 Policy 학습                  │
│   └ 4개 모델 필요 (Policy, Value, Reward, Reference) │
│   └ 하이퍼파라미터 많음 (β, ε, GAE 등)     │
│   └ 학습 불안정                             │
│                                             │
│ → 너무 복잡하고 비용이 많이 듦!             │
└─────────────────────────────────────────────┘

DPO의 아이디어

“Reward Model 없이, Preference Data로 직접 Policy를 학습하면 안 될까?”

RLHF: Preference Data → Reward Model → Policy
DPO:  Preference Data ──────────────→ Policy  (직접!)

2. 유도 과정 상세 설명

Step 1: PPO 목표 함수에서 시작

\[\max_\pi \mathbb{E}_{y \sim \pi}[R(x, y)] - \beta \cdot D_{KL}(\pi \| \pi_{ref})\]

의미:

Reward $R(x, y)$를 최대화
근데 Reference 모델 $\pi_{ref}$에서 너무 멀어지지 않게 (KL 제한)

Step 2: 이 목표의 최적해 구하기

수학적으로 위 목표를 최대화하는 최적 Policy $\pi^*$를 구하면:

\[\pi^*(y|x) = \frac{1}{Z(x)} \pi_{ref}(y|x) \exp\left(\frac{R(x, y)}{\beta}\right)\]

부분	의미
$\pi_{ref}(y \mid x)$	Reference 모델의 확률
$\exp\left(\frac{R(x,y)}{\beta}\right)$	Reward에 따른 가중치 (높으면 확률 ↑)
$Z(x)$	정규화 상수 (확률 합이 1이 되도록)

직관:

최적 Policy = Reference 모델 × Reward 가중치

Reward 높은 응답 → 확률 높아짐
Reward 낮은 응답 → 확률 낮아짐

Step 3: Reward를 Policy로 표현 (핵심!)

Step 2의 식을 Reward에 대해 풀면:

\[\pi^*(y|x) = \frac{1}{Z(x)} \pi_{ref}(y|x) \exp\left(\frac{R(x, y)}{\beta}\right)\]

양변에 조작을 가하면:

\[R(x, y) = \beta \log \frac{\pi^*(y|x)}{\pi_{ref}(y|x)} + \beta \log Z(x)\]

이게 뭘 의미하나면:

“Reward는 사실 Policy들의 비율로 표현할 수 있다!”

Reward = β × log(최적 Policy / Reference Policy) + 상수

→ Reward Model 없이도 Policy만으로 Reward를 알 수 있다!

Step 4: Bradley-Terry에 대입

Reward Model 학습할 때 썼던 Bradley-Terry:

\[P(y_w \succ y_l | x) = \sigma(R(x, y_w) - R(x, y_l))\]

여기에 Step 3의 Reward 식을 대입:

\[R(x, y_w) - R(x, y_l) = \beta \log \frac{\pi^*(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi^*(y_l|x)}{\pi_{ref}(y_l|x)}\]

$Z(x)$가 사라짐! (같은 x에 대해 상쇄됨)

Step 5: 최종 DPO 손실 함수

$\pi^*$ 대신 학습할 모델 $\pi_\theta$를 넣으면:

\[\mathcal{L}_{DPO} = -\mathbb{E}_{(x, y_w, y_l)} \left[\log \sigma \left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\right]\]

3. DPO 손실 함수 완전 분해

\[\mathcal{L}_{DPO} = -\mathbb{E} \left[\log \sigma \left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\right]\]

안쪽부터 하나씩:

Layer 1: 좋은 응답의 “상대적 확률”

\[\log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)}\]

π_θ(y_w|x) = 학습 모델이 좋은 응답을 생성할 확률
π_ref(y_w|x) = Reference 모델이 좋은 응답을 생성할 확률

비율 > 1: 학습 모델이 더 자주 생성 → log > 0
비율 < 1: Reference가 더 자주 생성 → log < 0
비율 = 1: 동일 → log = 0

Layer 2: 나쁜 응답의 “상대적 확률”

\[\log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\]

같은 방식으로 나쁜 응답에 대해 계산

Layer 3: 두 값의 차이

\[\beta \left(\log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\]

이 값이 크다 =
  학습 모델이 좋은 응답 확률은 높이고
  나쁜 응답 확률은 낮췄다!

이 값이 작다 =
  아직 구분을 잘 못함

Layer 4: Sigmoid로 확률 변환

\[\sigma(\ldots)\]

Layer 5: Log 취하고 음수

\[-\log \sigma(\ldots)\]

→ Reward Model Loss와 같은 구조!

4. 실제 동작 예시

데이터

프롬프트 x: "테디베어 세탁법?"
좋은 응답 y_w: "손세탁이 좋아요! 테디가 상할 수 있거든요."
나쁜 응답 y_l: "세탁기에 그냥 넣으세요."

계산 과정

Step 1: 각 모델의 확률 계산

Reference 모델 (고정):
  π_ref(y_w|x) = 0.08  (좋은 응답 생성 확률 8%)
  π_ref(y_l|x) = 0.12  (나쁜 응답 생성 확률 12%)

학습 모델 (현재 상태):
  π_θ(y_w|x) = 0.10  (좋은 응답 생성 확률 10%)
  π_θ(y_l|x) = 0.10  (나쁜 응답 생성 확률 10%)

Step 2: Log 비율 계산

좋은 응답:
  log(π_θ(y_w) / π_ref(y_w)) = log(0.10 / 0.08)
                               = log(1.25) = 0.22

나쁜 응답:
  log(π_θ(y_l) / π_ref(y_l)) = log(0.10 / 0.12)
                               = log(0.83) = -0.19

Step 3: 차이 계산 (β=1 가정)

차이 = 0.22 - (-0.19) = 0.41

해석: 학습 모델이 Reference 대비
      좋은 응답 확률은 높이고 (0.22)
      나쁜 응답 확률은 낮췄다 (-0.19)
      → 좋은 방향! 하지만 아직 부족

Step 4: 손실 계산

σ(0.41) = 0.60
log(0.60) = -0.51
Loss = -(-0.51) = 0.51

→ 손실이 아직 높음, 더 학습 필요!

학습 후 변화

학습 후 모델:

π_θ(y_w|x) = 0.20  (8% → 20%로 증가!)
π_θ(y_l|x) = 0.05  (10% → 5%로 감소!)

새로운 계산:
  좋은 응답: log(0.20/0.08) = log(2.5) = 0.92
  나쁜 응답: log(0.05/0.12) = log(0.42) = -0.87
  차이: 0.92 - (-0.87) = 1.79

σ(1.79) = 0.86
Loss = -log(0.86) = 0.15  (0.51 → 0.15로 감소!)

5. 그림으로 이해하는 DPO

DPO 학습 전:

확률
12% ┤ ■ y_l (나쁜 응답)
10% ┤ ■ π_θ(y_l)    ■ π_θ(y_w)
 8% ┤                ■ y_w (좋은 응답)
    └ 학습모델 ─┘    └ Reference ─┘

문제: 학습 모델이 좋은/나쁜 응답을 비슷하게 취급

              ↓ DPO 학습 ↓

DPO 학습 후:

확률
20% ┤        ■ π_θ(y_w) ← 크게 증가!
12% ┤ ■ π_ref(y_l)
 8% ┤                ■ π_ref(y_w)
 5% ┤ ■ π_θ(y_l) ← 감소!

결과: 좋은 응답 확률 ↑, 나쁜 응답 확률 ↓

6. DPO의 핵심 인사이트

“Your Language Model is Secretly a Reward Model”

전통적 사고:
  "Reward Model이 있어야 좋은 응답을 구분할 수 있다"

DPO의 발견:
  "Policy의 확률 비율 자체가 Reward를 인코딩한다!"

  암묵적 Reward = β × log(π_θ / π_ref)

  → 별도의 Reward Model이 필요 없다!

7. 실제 학습 과정 (알고리즘)

┌─────────────────────────────────────────┐
│           DPO 학습 알고리즘             │
├─────────────────────────────────────────┤
│                                         │
│ 입력:                                   │
│   - Reference 모델 π_ref (SFT 모델, 고정) │
│   - 학습 모델 π_θ (π_ref로 초기화)      │
│   - Preference 데이터 {(x, y_w, y_l)}   │
│                                         │
│ 반복:                                   │
│   1. 배치에서 (x, y_w, y_l) 샘플링      │
│                                         │
│   2. 각 응답의 log 확률 계산:           │
│      - log π_θ(y_w|x), log π_θ(y_l|x)  │
│      - log π_ref(y_w|x), log π_ref(y_l|x) │
│                                         │
│   3. DPO 손실 계산:                     │
│      Loss = -log σ(β × (log π_θ(y_w)/π_ref(y_w) │
│                   - log π_θ(y_l)/π_ref(y_l)))    │
│                                         │
│   4. Gradient descent로 π_θ 업데이트    │
│                                         │
│ 출력: 정렬된 모델 π_θ                   │
└─────────────────────────────────────────┘

8. 의사 코드

  
def dpo_loss(policy_model, ref_model, x, y_w, y_l, beta=0.1):
    # Step 1: 학습 모델의 log 확률
    log_pi_theta_yw = policy_model.log_prob(y_w, given=x)
    log_pi_theta_yl = policy_model.log_prob(y_l, given=x)

    # Step 2: Reference 모델의 log 확률 (gradient 계산 안 함)
    with torch.no_grad():
        log_pi_ref_yw = ref_model.log_prob(y_w, given=x)
        log_pi_ref_yl = ref_model.log_prob(y_l, given=x)

    # Step 3: Log 비율 계산
    log_ratio_w = log_pi_theta_yw - log_pi_ref_yw  # 좋은 응답
    log_ratio_l = log_pi_theta_yl - log_pi_ref_yl  # 나쁜 응답

    # Step 4: DPO 손실
    logits = beta * (log_ratio_w - log_ratio_l)
    loss = -torch.log(torch.sigmoid(logits))

    return loss.mean()

9. DPO vs RLHF 비교

측면	RLHF (PPO)	DPO
단계	2단계 (RM → Policy)	1단계
필요 모델	4개	2개
Reward Model	필요 (별도 학습)	불필요
Value Function	필요	불필요
학습 방식	On-Policy (RL)	Off-Policy (SFT처럼)
구현 복잡도	높음	낮음
하이퍼파라미터	많음 (β, ε, GAE…)	적음 (β 정도)
성능	약간 더 좋음	거의 비슷
안정성	불안정할 수 있음	안정적

10. $\beta$ (베타)의 역할

\[\mathcal{L}_{DPO} = -\log \sigma\left(\beta \cdot (\ldots)\right)\]

β 값	효과
β 큼	Reference에서 크게 벗어나도 됨 (공격적)
β 작음	Reference 근처에 머물러야 함 (보수적)

β가 크면:

선호도 차이에 민감하게 반응
급격한 변화 가능

β가 작으면:

선호도 차이에 둔감
천천히 변화

11. 전체 흐름 요약

┌─────────────────────────────────────────┐
│           DPO 전체 과정                 │
├─────────────────────────────────────────┤
│                                         │
│ 1. SFT 모델 준비 (이게 Reference가 됨)  │
│         │                               │
│         ▼                               │
│ 2. Preference 데이터 수집               │
│    (x, 좋은응답, 나쁜응답) 쌍들          │
│         │                               │
│         ▼                               │
│ 3. 학습 모델을 SFT 모델로 초기화        │
│    π_θ ← π_ref                          │
│         │                               │
│         ▼                               │
│ 4. DPO 손실로 학습                      │
│    "좋은 응답 확률 ↑, 나쁜 응답 확률 ↓" │
│    (Reference 대비 상대적으로)           │
│         │                               │
│         ▼                               │
│ 5. 정렬된 모델 완성!                    │
└─────────────────────────────────────────┘

12. 최종 요약

항목	내용
핵심 아이디어	Reward Model 없이 직접 선호도 최적화
수학적 트릭	PPO의 최적해에서 Reward를 Policy 비율로 표현
손실 함수	좋은 응답의 상대적 확률을 높이도록 학습
장점	간단, 안정적, 모델 2개만 필요
단점	Off-policy라 분포 불일치 가능

한 문장:

DPO는 “Reward Model을 Policy 안에 숨겨서” Preference 데이터만으로 직접 모델을 정렬하는 우아한 방법입니다.

Part 10: 테디베어 예시로 보는 전체 과정

SFT 후:

Q: "테디베어를 세탁기에 넣어도 될까요?"
A: "안 돼요. 손상될 수 있어요. 손세탁하세요."
  → 사실적으로 맞지만, 딱딱함

Preference Tuning 후:

Q: "테디베어를 세탁기에 넣어도 될까요?"
A: "테디베어가 다칠 수 있어요! 부드러운 손세탁이 더 안전해요."
  → 같은 정보를 더 친절하고 공감적으로 전달

핵심 요약

Preference Tuning

LLM 학습의 세 번째 단계
인간 선호도에 맞게 모델 정렬
네거티브 신호 주입 가능

RLHF

Stage 1: Reward Model 학습 (Bradley-Terry)
Stage 2: PPO로 Policy 최적화
4개의 모델 필요, 복잡하지만 성능 좋음

PPO

Reward 최대화 + Base 모델 유지
Clip 또는 KL Penalty로 업데이트 제한
Advantage 함수로 분산 감소

DPO

\[\mathcal{L}_{DPO} = -\mathbb{E}\left[\log \sigma\left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\right]\]

Reward Model 없이 직접 최적화
2개의 모델만 필요, 구현 간단
“Language Model is Secretly a Reward Model”

용어 정리

용어	의미
RLHF	Reinforcement Learning from Human Feedback
RLAIF	Reinforcement Learning from AI Feedback
PPO	Proximal Policy Optimization
DPO	Direct Preference Optimization
Bradley-Terry	Pairwise 비교 확률 모델링 공식
KL Divergence	두 확률 분포 간 차이 측정
Advantage	행동의 상대적 가치 (Q - V)
Value Function	상태의 기대 가치 추정
Reward Hacking	불완전한 Reward Model 악용 현상
On-Policy	현재 Policy로 생성한 데이터로 학습
Off-Policy	다른 Policy로 생성한 데이터로 학습
BoN	Best-of-N (N개 중 최고 선택)

핵심 공식

Bradley-Terry:

\[P(y_i \succ y_j) = \sigma(R_i - R_j)\]

Reward Model Loss:

\[\mathcal{L}_{RM} = -\mathbb{E}\left[\log \sigma(R(x, y_w) - R(x, y_l))\right]\]

PPO Objective:

\[\mathcal{L}_{PPO} = \mathbb{E}[R(x, y)] - \beta \cdot D_{KL}(\pi_\theta \| \pi_{ref})\]

PPO-Clip:

\[\mathcal{L}^{CLIP} = \min(r(\theta) \cdot A, \text{clip}(r(\theta), 1-\epsilon, 1+\epsilon) \cdot A)\]

DPO Loss:

\[\mathcal{L}_{DPO} = -\mathbb{E}\left[\log \sigma\left(\beta \log \frac{\pi_\theta(y_w|x)}{\pi_{ref}(y_w|x)} - \beta \log \frac{\pi_\theta(y_l|x)}{\pi_{ref}(y_l|x)}\right)\right]\]

다음 강의 예고

Lecture 6: Reasoning Models

GRPO (Group Relative Policy Optimization)
DeepSeek-Math
추론 능력 강화를 위한 RL 기법

*Stanford CME295: Transformers & LLMs

Autumn 2025

Lecture 5 정리*

AI, Lecture

This post is licensed under CC BY 4.0 by the author.