Bài 53: RLHF / DPO intuition — alignment với feedback con người

1

Mục tiêu bài học

Sau bài học, bạn sẽ:

Giải thích được vì sao SFT (Bài 52) chưa đủ và cần thêm bước alignment.
Mô tả được pipeline RLHF ba stage (SFT → Reward Model → PPO) và vai trò của KL constraint.
Viết được PPO objective dạng đơn giản và DPO loss; hiểu trực giác đằng sau.
Nêu được lý do DPO bỏ được reward model và PPO mà vẫn implicit optimize cùng mục tiêu.
Biết format preference dataset (prompt, chosen, rejected) và các bộ phổ biến (UltraFeedback, HH-RLHF).
Cài đặt được pipeline DPO cơ bản với trl.DPOTrainer.
Phân biệt được DPO, GRPO, KTO, ORPO và biết khi nào nên chọn cái nào.
Biết các benchmark dùng để evaluate model sau alignment.

2

Alignment problem — SFT không đủ

SFT (supervised fine-tuning) chỉ train model mimic output trong dataset: với mỗi prompt, có đúng một response "đúng" và loss kéo phân phối token tới response đó. Có ba hạn chế:

Không học phân biệt: model không biết một câu trả lời này tốt hơn câu trả lời kia ở chỗ nào — vì SFT chưa bao giờ nhìn thấy pair so sánh.
Không học preference: ý thích của người dùng (chi tiết, ngắn gọn, giọng văn, mức độ thận trọng) không phải lúc nào cũng nằm trong reference output.
Không học tránh: SFT toàn dạy "làm cái gì", không dạy "không làm cái gì" (refuse harmful, không bịa fact). Cũng không có signal mạnh để giảm hallucination.

Alignment là tầng thứ hai của fine-tuning: thay vì học mimic 1 response, model học so sánh giữa nhiều response và ưu tiên loại tốt hơn theo cảm nhận con người. Đây là lý do mọi LLM chat hiện đại (ChatGPT, Claude, Gemini, Llama-Instruct, Qwen-Chat) đều có alignment step sau SFT — không phải chỉ SFT.

3

RLHF là gì

RLHF (Reinforcement Learning from Human Feedback) được Christiano và cộng sự đề xuất năm 2017 ("Deep Reinforcement Learning from Human Preferences", arXiv:1706.03741) cho RL agent chơi Atari, sau đó OpenAI scale lên LLM trong InstructGPT (Ouyang et al., "Training language models to follow instructions with human feedback", arXiv:2203.02155, 2022) và áp dụng vào ChatGPT (2022).

Ý tưởng cốt lõi: người không biết viết ra response tốt nhất, nhưng có thể so sánh hai response A và B và nói cái nào tốt hơn. Từ tập hợp các preference đó, ta train một reward model dự đoán điểm chất lượng, rồi dùng reward này như "thưởng" để fine-tune policy (chính là LLM) bằng RL.

4

Pipeline RLHF ba stage

Pipeline chuẩn của InstructGPT gồm ba stage tách rời:

Stage 1 — SFT: bắt đầu từ base pre-trained model, fine-tune trên instruction dataset (xem Bài 52). Output là SFT model — model đã follow instruction nhưng chưa align.
Stage 2 — Reward Model (RM): thu thập pair preference (prompt + response A + response B + label "A tốt hơn B"), train classifier dự đoán scalar score sao cho score(chosen) > score(rejected).
Stage 3 — RL với PPO: dùng reward model làm signal, optimize SFT model bằng PPO (Proximal Policy Optimization — Schulman et al., arXiv:1707.06347, 2017). Có thêm KL penalty để policy không drift quá xa SFT.

Output cuối: RLHF model — đây là "ChatGPT" hoặc "Claude" mà người dùng cuối tương tác. Mỗi stage cần dataset riêng, code riêng, hyper-param riêng — phức tạp hơn nhiều so với SFT đơn thuần.

5

Stage 2 — Reward Model

Reward model là một LLM (thường khởi tạo từ SFT model) thay layer output bằng một head trả về scalar:

Input: prompt + response (ghép thành một chuỗi).
Output: scalar score (càng cao = càng tốt theo human preference).
Training: dữ liệu là pair $ (x, y_w, y_l) $ — prompt $ x $, chosen response $ y_w $ (winning), rejected response $ y_l $ (losing). Loss đẩy $ r(x, y_w) $ lớn hơn $ r(x, y_l) $ dùng Bradley-Terry model:

\[ L_{RM} = -\log \sigma\big( r(x, y_w) - r(x, y_l) \big) \]

Trong đó $ \sigma $ là sigmoid. Sau khi train, reward model có thể chấm điểm bất kỳ pair (prompt, response) nào — đây là "human preference" được nén vào weight neural network.

Quy mô: InstructGPT dùng RM ~6B param, train trên ~33K pair preference. Anthropic công bố dataset HH-RLHF ~170K pair.

6

Stage 3 — PPO với KL constraint

Với reward model đã có, ta xem LLM là policy $ \pi_\theta $ (sinh response từ prompt) và optimize bằng RL. Schulman 2017 đề xuất PPO — biến thể policy gradient ổn định cho RL deep learning. Objective tổng quát của RLHF:

\[ \max_{\pi_\theta} \; \mathbb{E}_{x \sim D,\, y \sim \pi_\theta(\cdot \mid x)} \big[ r(x, y) \big] - \beta \cdot D_{KL}\big( \pi_\theta(\cdot \mid x) \;\|\; \pi_{\text{SFT}}(\cdot \mid x) \big) \]

Trong đó:

$ \pi_\theta $: policy đang train (LLM hiện tại).
$ \pi_{\text{SFT}} $: SFT model gốc, frozen — dùng làm reference để policy không trôi quá xa.
$ r(x, y) $: reward từ reward model.
$ D_{KL} $: KL divergence giữa policy hiện tại và SFT reference.
$ \beta $: hệ số phạt KL (thường 0.01-0.1) — kiểm soát mức "tự do" so với SFT.

Tại sao cần KL? Nếu chỉ tối đa hoá reward, policy sẽ tìm cách "hack" reward model — sinh ra văn bản kỳ lạ mà RM cho điểm cao nhưng người không thích (reward hacking). KL kéo policy về gần SFT, giới hạn không gian cập nhật trong vùng văn bản "tự nhiên".

7

Vì sao RLHF quan trọng — 3H

InstructGPT (2022) so sánh GPT-3 SFT-only và GPT-3 RLHF: model 1.3B sau RLHF được human eval đánh giá cao hơn cả GPT-3 175B SFT-only — khoảng cách rất lớn về preference, dù trên benchmark perplexity gần như giống nhau. Đây là bằng chứng quyết định RLHF mở khoá khả năng chat của LLM.

Anthropic gọi mục tiêu của alignment là 3H — viết tắt cho ba thuộc tính:

Helpful: trả lời đúng ý người hỏi, theo instruction.
Harmless: không sinh nội dung độc hại, từ chối lịch sự khi cần.
Honest: nói thật khi biết, nói "không biết" khi không biết — giảm hallucination.

Difference giữa base model và RLHF model rất rõ: base model viết tiếp văn bản, không refuse, không follow instruction đều đặn; RLHF model thì chat, refuse harmful request, format câu trả lời theo expectation. ChatGPT, Claude, Gemini, Llama-Instruct đều có alignment step — không có pipeline đại trà nào dùng base model trực tiếp ra production.

8

Vấn đề của RLHF

Mặc dù hiệu quả, RLHF có nhiều nhược điểm khiến open-source community tìm cách thay thế:

Pipeline phức tạp: ba stage nối tiếp, mỗi stage có thể fail riêng. Lỗi RM sẽ propagate sang PPO; lỗi PPO không hiển nhiên nếu loss không giảm.
Compute hungry: PPO cần lưu cả policy, reference policy, reward model, và critic trong VRAM cùng lúc — gấp 2-4 lần SFT cùng size. Mỗi step PPO cũng generate sample mới (rollout) — chậm hơn supervised loss.
Unstable: PPO trên LLM nhạy với hyper-parameter (learning rate, $ \beta $, clip range). Train hỏng thường biểu hiện qua mode collapse (output ngắn cụt, lặp đi lặp lại) hoặc divergence.
Reward hacking: policy tìm cách "lừa" RM thay vì cải thiện thực sự — vd lạm dụng từ khoá RM thích, format Markdown thừa, độ dài tăng.
Cost label: thu thập 100K pair preference từ human annotator có thể tốn $100K-1M. Anthropic, OpenAI, Google đầu tư mạnh — startup hoặc cá nhân khó theo.
Reproducibility: kết quả RLHF khó tái tạo giữa các team vì depend vào seed, batch order, sample distribution.

Năm 2023, các nhóm bắt đầu hỏi: liệu có cách align mà bỏ được RM và PPO?

9

DPO — bỏ reward model và PPO

DPO (Direct Preference Optimization) — Rafailov et al., "Direct Preference Optimization: Your Language Model is Secretly a Reward Model" (arXiv:2305.18290, 2023) — là phát hiện then chốt cho open-source alignment.

Tác giả chứng minh: với objective RLHF dạng có KL (mục 6), nghiệm tối ưu $ \pi^* $ có dạng closed-form theo reward $ r $ và reference $ \pi_{\text{ref}} $. Đảo lại: có thể viết $ r $ theo $ \pi^* $ và $ \pi_{\text{ref}} $. Thay biểu thức này vào loss của Bradley-Terry (mục 5), reward model "biến mất" — còn lại một loss chỉ phụ thuộc vào policy và reference. Đó là DPO loss.

Hệ quả: thay vì 3 stage, chỉ cần 1 stage sau SFT. Không cần train RM, không cần PPO rollout. Loss là supervised-like, train ổn định như fine-tuning thông thường.

10

DPO loss

Với pair preference $ (x, y_w, y_l) $, DPO loss:

\[ L_{DPO}(\pi_\theta) = -\log \sigma\!\left( \beta \log \frac{\pi_\theta(y_w \mid x)}{\pi_{\text{ref}}(y_w \mid x)} \;-\; \beta \log \frac{\pi_\theta(y_l \mid x)}{\pi_{\text{ref}}(y_l \mid x)} \right) \]

Trong đó:

$ y_w $: chosen (winning) response.
$ y_l $: rejected (losing) response.
$ \pi_\theta $: current policy (model đang train).
$ \pi_{\text{ref}} $: reference policy (thường là SFT model, frozen).
$ \beta $: hệ số ứng với KL strength (0.1-0.5 phổ biến).
$ \sigma $: sigmoid.

Mỗi $ \pi(y \mid x) $ là xác suất sinh chuỗi $ y $ cho prompt $ x $ — tính bằng tích các xác suất token (hoặc log-sum log-prob trên các token của $ y $). Có thể implement chỉ bằng forward pass của hai model (policy + reference).

11

Trực giác về DPO

Gọi $ \Delta_w = \log \pi_\theta(y_w \mid x) - \log \pi_{\text{ref}}(y_w \mid x) $ (policy chosen "vượt" reference bao nhiêu trên chosen) và tương tự $ \Delta_l $ cho rejected. DPO tối thiểu hoá:

\[ L = -\log \sigma\big( \beta (\Delta_w - \Delta_l) \big) \]

Mục tiêu: $ \Delta_w > \Delta_l $ — policy phải "kéo" chosen tăng nhiều hơn rejected so với reference. Tức là:

Tăng prob $ y_w $ so với reference ($ \Delta_w $ lớn), và/hoặc
Giảm prob $ y_l $ so với reference ($ \Delta_l $ âm).

$ \beta $ đóng vai trò "nhiệt độ": nhỏ → đẩy nhẹ, model gần reference; lớn → đẩy mạnh, model có thể drift xa hơn. Trong thực tế $ \beta \in [0.1, 0.5] $ là dải an toàn.

Không cần reward model rời rạc — phần "reward implicit" được encode trực tiếp vào ratio $ \pi_\theta / \pi_{\text{ref}} $ của hai model. Đó là ý nghĩa của tiêu đề paper: "Your Language Model is Secretly a Reward Model".

12

DPO vs RLHF — đối chiếu

                  RLHF (PPO)              DPO
Stage sau SFT      2 (RM + PPO)            1
Reward model       Cần train               Không cần (implicit)
RL rollout         Cần (sample mỗi step)   Không (offline)
Loss               Policy gradient + KL    Supervised-like
Stability          Nhạy hyper-param        Ổn định
Compute            2-4x SFT                ~ SFT (gấp đôi vì 2 forward)
Code complexity    Cao                     Thấp (1 trainer)
Reward hacking     Có thể xảy ra           Không có RM rời rạc để hack
Performance        Strong (frontier)       Comparable hoặc tốt hơn nhiều benchmark

Rafailov 2023 so sánh DPO với PPO trên IMDB sentiment, Reddit TL;DR summarization và Anthropic HH-RLHF: DPO bằng hoặc tốt hơn PPO trên cả ba, với chi phí compute và code thấp hơn đáng kể.

Trên benchmark MT-Bench và AlpacaEval, các model open-source sau 2023 (Zephyr 7B của HF, Tulu 2 của Allen AI) dùng DPO đều đạt mức gần GPT-3.5 — chứng minh DPO không phải compromise so với PPO.

13

Preference dataset

Cả RLHF và DPO đều cần dataset format pair preference. JSON tối thiểu:

{
  "prompt": "What's the capital of France?",
  "chosen": "The capital of France is Paris.",
  "rejected": "Paris is a city."
}

Các bộ preference công khai phổ biến:

UltraFeedback (Cui et al., arXiv:2310.01377, 2023) — ~64K pair, response được GPT-4 chấm điểm theo nhiều tiêu chí. Tốt cho general-purpose chat.
Anthropic HH-RLHF (Bai et al., arXiv:2204.05862, 2022) — ~170K pair, hai split "helpful" và "harmless". Human-labeled, chất lượng cao.
Argilla DPO mix / DPO-7K — mix nhiều nguồn, đã làm sạch, dễ dùng cho DPO research.
OpenAssistant Conversations (OASST) — preference tree do community label.
SHP (Stanford Human Preferences) — preference từ Reddit threads dựa trên upvote.

Quy tắc làm dataset: đa dạng prompt, chosen và rejected khác nhau rõ ràng (không quá gần), không leak reference vào prompt, có instruction policy về harmless.

14

Code DPO với trl

Thư viện trl (Bài 52) cung cấp DPOTrainer với cùng pattern như SFTTrainer. Pipeline tối giản — load SFT model làm cả policy và reference, dataset có ba field prompt / chosen / rejected, gọi trainer.train():

from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
from trl import DPOTrainer, DPOConfig

SFT_MODEL = "./sft-llama-3.2-1b"   # output của Bài 52

tokenizer = AutoTokenizer.from_pretrained(SFT_MODEL)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# Policy (sẽ train) và reference (frozen) — cùng khởi tạo từ SFT
model = AutoModelForCausalLM.from_pretrained(SFT_MODEL)
ref_model = AutoModelForCausalLM.from_pretrained(SFT_MODEL)

# UltraFeedback subset, format đã có prompt/chosen/rejected
dataset = load_dataset(
    "argilla/ultrafeedback-binarized-preferences-cleaned",
    split="train[:5000]",
)

training_args = DPOConfig(
    output_dir="./dpo-out",
    beta=0.1,                    # KL strength
    learning_rate=5e-7,          # DPO cần LR nhỏ hơn SFT
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    bf16=True,
    logging_steps=20,
    save_strategy="epoch",
    max_length=1024,
    max_prompt_length=512,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer,
)
trainer.train()
trainer.save_model("./dpo-final")

Lưu ý:

learning_rate=5e-7 nhỏ hơn SFT (2e-5) khoảng 30-50 lần — DPO cập nhật nhỏ, train quá lâu sẽ over-fit và drift.
beta=0.1 mặc định an toàn; tăng $ \beta $ nếu thấy model bám reference quá chặt, giảm nếu drift.
Có thể kết hợp với LoRA/QLoRA (Bài 49-50) — chỉ train adapter, ref model là base + adapter version cũ. DPOTrainer hỗ trợ peft_config.
VRAM tối thiểu: 2 lần SFT cùng size (policy + reference forward đồng thời), trừ khi dùng option ref_model=None để dùng disabled adapter làm reference (giảm VRAM cho LoRA setup).

15

GRPO — DeepSeek-R1

GRPO (Group Relative Policy Optimization) được DeepSeek đề xuất trong DeepSeekMath (Shao et al., arXiv:2402.03300, 2024) và dùng làm RL stage chính cho DeepSeek-R1 (arXiv:2501.12948, 2025). Ý tưởng:

Với mỗi prompt, sample N response (vd N=8) từ policy hiện tại.
Tính reward cho mỗi response (vd: đúng/sai cho math, pass test cho code — không cần reward model).
Tính relative advantage trong group: response nào có reward cao hơn mean của group thì advantage dương.
Update policy theo advantage này, vẫn có KL constraint với reference.

Ưu điểm: không cần reward model rời rạc — verifier rule-based (regex match đáp số, run test) là đủ. Phù hợp cực kỳ cho reasoning task có ground truth (math, code, logic). DeepSeek-R1 cho thấy GRPO + verifiable reward đẩy được khả năng reasoning của LLM lên rất cao mà không cần huge preference dataset.

Trade-off: cần sample N response mỗi step → chậm hơn DPO. Phù hợp khi có verifier tự động (rẻ); ít phù hợp cho task chat open-ended (cần reward model lại).

16

KTO và ORPO

Hai phương pháp 2024 đáng biết:

KTO (Kahneman-Tversky Optimization) — Ethayarajh et al., arXiv:2402.01306, 2024. Lấy ý tưởng từ prospect theory: con người không so sánh tuyến tính giữa gain và loss. KTO chỉ cần label binary (response này tốt / response này tệ) — không cần pair. Phù hợp khi label pair khó (vd: chỉ có thumb up/down từ user), data hơi lệch.
ORPO (Odds Ratio Preference Optimization) — Hong et al., arXiv:2403.07691, 2024. Ghép SFT loss và preference loss thành một stage duy nhất:

\[ L_{ORPO} = L_{SFT}(y_w) + \lambda \cdot L_{OR}(y_w, y_l) \]

Trong đó $ L_{OR} $ là log odds ratio giữa chosen và rejected. ORPO bỏ luôn được giai đoạn SFT riêng — train trực tiếp từ base model trên preference dataset. Đơn giản hơn DPO, kết quả benchmark gần như DPO (so sánh nội bộ paper). Đang được dùng nhiều cho fine-tune model nhỏ 1B-7B.

Cả KTO và ORPO đều có sẵn trong trl như KTOTrainer và ORPOTrainer — switch trainer là chuyển phương pháp được, code phần dataset gần như không đổi.

17

Constitutional AI và self-rewarding

Nút thắt lớn nhất của alignment là thu thập preference label. Hai hướng giảm phụ thuộc human label:

Constitutional AI / RLAIF (Anthropic, Bai et al., arXiv:2212.08073, 2022): thay vì human, dùng một AI (vd Claude phiên bản trước) để label preference dựa trên một bộ constitution — danh sách principles (vd "không khuyến khích bạo lực", "ưu tiên câu trả lời ngắn gọn, chính xác"). AI generate critique cho mỗi response và chọn cái tốt hơn. RLAIF = Reinforcement Learning from AI Feedback. Anthropic dùng cách này cho Claude.
Self-rewarding (Yuan et al., arXiv:2401.10020, 2024): model tự sinh response và tự chấm điểm theo prompt evaluation định sẵn — sau đó dùng pair (chosen, rejected) của chính mình làm DPO data. Lặp lại nhiều iteration, model improve dần. Hữu ích khi muốn iterate fast mà không có annotation budget.

Cả hai đều có limitation: model evaluator có thể inherit bias riêng — alignment kết quả phản ánh AI judge thay vì human judge. Thường được dùng kết hợp với một lớp human eval ở cuối để verify.

18

Evaluation post-alignment

Sau alignment, model cần đánh giá ở nhiều chiều — không chỉ accuracy:

AlpacaEval (2.0): chấm helpfulness bằng GPT-4 judge so với baseline GPT-4 / Davinci. Win-rate là số phổ biến.
MT-Bench: multi-turn conversation 80 câu hỏi, GPT-4 chấm 1-10. Đo khả năng giữ context và follow instruction qua nhiều turn.
TruthfulQA: đo honesty — model có né được câu hỏi đánh lừa và không lặp lại misconception phổ biến không.
ToxicChat / RealToxicityPrompts: harmlessness — model có refuse prompt độc hại và không sinh output độc hại không.
Chatbot Arena (LMSYS): leaderboard human pairwise voting trực tiếp — ELO rating. Là benchmark "vàng" cho human preference real-world.
IFEval: instruction-following — kiểm tra model có tuân thủ chính xác constraint trong prompt không (vd "trả lời bằng 3 câu", "kết thúc với dấu chấm than").

Pattern thường gặp: model sau DPO/RLHF có MT-Bench, AlpacaEval cao hơn SFT-only 2-5 điểm; TruthfulQA và ToxicChat cải thiện rõ; Chatbot Arena ELO tăng nếu preference data đủ chất lượng. Bài 54 (Module 9) sẽ đi sâu vào vì sao evaluate LLM khó và các benchmark này hoạt động ra sao.

19

Cost comparison

Method        Compute (vs SFT)   Stages    Data needed              Stability
SFT only      1x                 1         (instruction)            High
RLHF (PPO)    2-4x SFT           3         pair + rollout           Low
DPO           ~SFT (2x forward)  1         pair (chosen/rejected)   High
ORPO          ~SFT (1 forward+)  1         pair                     High
KTO           ~SFT               1         binary good/bad          High
GRPO          1.5-2x SFT         1         prompt + verifier rule   Medium

Ví dụ thực tế (Llama 3 8B, dataset 50K pair, 1 epoch, A100 80GB):

SFT: 3-5 giờ.
DPO: 5-8 giờ (2 forward pass: policy + reference).
RLHF PPO: 12-24 giờ + 4-8 giờ train RM riêng.
GRPO: 8-16 giờ (sample N response mỗi step).

DPO là rẻ nhất cho phần lớn use case — đây là lý do nó dominant trong open-source 2023-2026.

20

Modern workflow 2024-2026

Tóm tắt landscape khi viết bài này:

Default open-source: SFT → DPO. Llama 3 Instruct, Mistral, Qwen, Zephyr, Tulu — phần lớn dùng pipeline này.
Frontier proprietary: GPT, Claude, Gemini vẫn dùng RLHF (PPO) — họ có infra và label budget để chịu được pipeline phức tạp, và RLHF có ceiling cao nhất khi tune đúng.
Reasoning task: SFT → GRPO. DeepSeek-R1, OpenAI o1 (theo speculation), QwQ — leverage verifiable reward cho math, code.
Minimal pipeline: ORPO (1 stage, không cần SFT riêng) — phù hợp model nhỏ, dataset đã được curate.
Binary feedback: KTO khi chỉ có thumb up/down (production user feedback).

Khi bạn bắt đầu: SFT trên instruction dataset → DPO trên UltraFeedback (hoặc preference data riêng của domain). Đây là pattern reproducible và rẻ, đủ để fine-tune Llama 3 1B/3B/8B trên 1 GPU.

21

Bài tập

Bài 1 — Prepare 50 preference pair domain riêng. Chọn một domain (vd: trả lời câu hỏi technical Python). Soạn 50 prompt. Với mỗi prompt, viết 1 chosen response (chi tiết, đúng) và 1 rejected response (cẩu thả, thiếu hoặc sai). Lưu JSONL với schema {prompt, chosen, rejected}.

Bài 2 — Train DPO Llama 3.2 1B. Bắt đầu từ checkpoint SFT của Bài 52 (hoặc meta-llama/Llama-3.2-1B-Instruct nếu chưa có). Train DPOTrainer 1 epoch trên 50 pair của Bài 1 + 2000 pair từ UltraFeedback (cleaned). Log loss và rewards/accuracies mỗi 20 step. Quan sát loss giảm và accuracy tăng dần.

Bài 3 — Compare DPO vs SFT. Build test set 20 prompt (15 trong domain, 5 ngoài). Generate response từ SFT model và DPO model. Đánh giá manual theo rubric: format, độ chi tiết, đúng/sai, refuse hợp lý. Tính accuracy / score trung bình hai model.

Bài 4 — Sweep $ \beta $. Lặp lại Bài 2 với beta $ \in $ {0.05, 0.1, 0.3, 0.5}, fix các hyper-param khác. So sánh trên test set của Bài 3. Vẽ plot quality / drift vs $ \beta $ — tìm sweet spot.

Bài 5 — (optional) ORPO so sánh. Train cùng model ban đầu với ORPOTrainer (bỏ qua SFT stage). So sánh với output Bài 2 (SFT → DPO). Note thời gian training và quality trên test set.

Bài 6 — (optional) Run AlpacaEval. Cài AlpacaEval, run trên 805 prompt official. Compare win-rate của DPO model với SFT model (cùng base) và với gpt-3.5-turbo reference. Cẩn thận cost — GPT-4 judge ~$5-15/run.

22

Tóm tắt

SFT chỉ học mimic; alignment dạy model so sánh và ưu tiên response người dùng thích hơn. Không có alignment, không có chat experience hiện đại.
RLHF (Christiano 2017, InstructGPT 2022) là pipeline 3 stage: SFT → Reward Model → PPO. KL constraint giữ policy không drift xa SFT.
PPO objective: $ \mathbb{E}[r(x, y)] - \beta D_{KL}(\pi \| \pi_{\text{SFT}}) $. $ \beta $ cân giữa reward và stability.
RLHF mang lại 3H (Helpful, Harmless, Honest); là kỹ thuật đứng sau ChatGPT, Claude, Gemini, Llama-Instruct.
Vấn đề RLHF: complex, compute hungry (2-4x SFT), unstable, reward hacking, mode collapse, label đắt.
DPO (Rafailov 2023) chứng minh nghiệm RLHF có closed-form và đảo lại thành loss chỉ phụ thuộc policy + reference — bỏ luôn reward model và PPO.
DPO loss: $ -\log \sigma(\beta(\Delta_w - \Delta_l)) $ với $ \Delta = \log(\pi_\theta / \pi_{\text{ref}}) $. Train ổn định như supervised.
Code DPO với trl.DPOTrainer — pattern gần như SFTTrainer. LR ~5e-7, $ \beta $ ~0.1, 1 epoch là đủ cho dataset 5K-50K pair.
Preference dataset chuẩn: pair (prompt, chosen, rejected). Bộ phổ biến: UltraFeedback (64K), HH-RLHF (170K), Argilla DPO mix, OASST.
GRPO (DeepSeek 2024): sample N response/prompt, dùng verifier rule-based, không cần RM. Strong cho reasoning có ground truth (math, code).
KTO (Kahneman-Tversky): chỉ cần binary label good/bad — phù hợp khi không có pair.
ORPO (Hong 2024): single-stage = SFT + odds ratio loss, bỏ luôn SFT riêng.
Constitutional AI / RLAIF (Anthropic): AI tự label preference theo constitution — giảm cost human label. Self-rewarding (Yuan 2024): model tự chấm output của chính mình, iterate.
Evaluation: AlpacaEval (helpful), MT-Bench (multi-turn), TruthfulQA (honest), ToxicChat (harmless), Chatbot Arena (human ELO), IFEval (instruction-follow).
Compute: DPO ~ SFT (rẻ nhất), RLHF 2-4x SFT, GRPO 1.5-2x SFT.
Default workflow 2024-2026: SFT → DPO cho general chat; SFT → GRPO cho reasoning; ORPO cho minimal pipeline.

23

Tổng kết Module 8 — Fine-tuning

Module 8 gồm bảy bài (47-53) đi từ câu hỏi có nên fine-tune không đến lúc bạn có thể align một model 1B-8B trên GPU consumer:

Bài 47 — Khi nào nên fine-tune: đặt fine-tune đúng vị trí trong pipeline (so với prompting và RAG); tiêu chí quyết định.
Bài 48 — Full fine-tuning vs PEFT: ngân sách VRAM, chất lượng so sánh, khi nào cần full FT.
Bài 49 — LoRA: low-rank adaptation, công thức forward, target modules, rank $ r $, scaling $ \alpha $.
Bài 50 — QLoRA: NF4, double quantization, paged optimizer; fit Llama 70B trên 1 A100, Llama 7B trên RTX 3060.
Bài 51 — Instruction tuning dataset: cách build dataset chất lượng, format Alpaca / ShareGPT, dedupe, filter, mix.
Bài 52 — Fine-tune với trl: SFTTrainer, chat template, packing, full training script reproducible.
Bài 53 — RLHF / DPO: alignment step, RLHF pipeline, DPO derivation, GRPO/KTO/ORPO, evaluation, modern workflow.

Sau Module 8, bạn có đủ công cụ để: lựa chọn được giữa prompting/RAG/fine-tuning theo bài toán; build instruction + preference dataset; chạy được pipeline SFT → DPO end-to-end trên Llama 3 1B-8B với GPU consumer; ước lượng cost và VRAM trước khi bắt tay. Câu hỏi tiếp theo: làm sao biết model sau alignment thực sự tốt? Module 9 (bắt đầu Bài 54) sẽ trả lời — vì sao đánh giá LLM khó và các benchmark hoạt động như thế nào.

Danh sách bài viết