ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Huấn luyện & Alignment

AI Researcher

RLHF - Học tăng cường từ phản hồi con người

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kỹ thuật huấn luyện AI phù hợp với giá trị con người thông qua phản hồi và mô hình thưởng.

lesson98 minHuấn luyện & AlignmentAI Researcher

Dự đoán

GPT-3 (2020) rất giỏi viết văn nhưng hay nói bậy, bịa đặt, không nghe lời. OpenAI biến nó thành ChatGPT (2022) chủ yếu bằng cách nào?

RLHF (Reinforcement Learning from Human Feedback) là bước nhảy vọt từ GPT-3 → ChatGPT. Con người dạy AI biết thế nào là 'helpful, honest, harmless', rồi RL giúp mô hình liên tục cải thiện.

Ẩn dụ: đầu bếp và giám khảo

Hãy tưởng tượng bạn đang dạy một đầu bếp trẻ tài năng nhưng "hoang dã". Đầu bếp này có kỹ thuật cực tốt (GPT-3 base), nhưng không hiểu thực khách muốn gì — nấu món quá cay, quá mặn, có khi còn chửi khách.

Bạn dạy đầu bếp qua 3 giai đoạn:

  1. Dạy công thức chuẩn (SFT): đưa 100 công thức mẫu của đầu bếp sao Michelin để đầu bếp bắt chước. Sau đó đầu bếp biết nấu "đúng format" — món ra đĩa gọn gàng, có đủ thành phần.
  2. Thuê giám khảo (Reward Model): bạn không thể đứng nếm từng món suốt ngày, nên thuê một giám khảo AI học gu của bạn. Bạn đưa cho giám khảo 1000 cặp món "cái này ngon hơn cái kia" — giám khảo học cách chấm điểm thay mặt bạn.
  3. Luyện tập với giám khảo (PPO): đầu bếp nấu → giám khảo chấm → đầu bếp điều chỉnh → lặp lại hàng triệu lần. Quan trọng: không cho đầu bếp đi quá xa công thức gốc (KL penalty) — nếu không, đầu bếp sẽ phát hiện "cho nhiều đường là giám khảo chấm cao" và nấu mọi món đều ngọt lịm.

Khoảnh khắc Aha

RLHF không dạy AI kiến thức mới — nó dạy AI giá trị. Base model (sau pretraining) đã có đủ tri thức. RLHF chỉ định hình cách mô hình sử dụng tri thức đó — khi nào nên nói, khi nào nên im lặng, cách từ chối lịch sự, khi nào nên làm rõ thay vì đoán.

Và trái tim kỹ thuật: Reward Model thay mặt con người chấm điểm hàng triệu response — biến "phản hồi người" (chậm, đắt) thành một hàm số đạo hàm được (nhanh, rẻ). Đây là cây cầu giúp RL cổ điển áp dụng được cho LLM.

Thử thách

Mô hình phát hiện rằng câu trả lời DÀI luôn được RM cho điểm cao hơn, nên bắt đầu viết rất dài dù không cần thiết. Hiện tượng này tên là gì?

Reward hacking xảy ra khi policy tìm cách tối đa điểm thưởng mà không thực sự cải thiện chất lượng. KL penalty, RM ensemble, cập nhật RM định kỳ, và reward shaping là các giải pháp.

Bạn tăng β (KL coefficient) từ 0.02 lên 1.0. Tác động dự kiến?

β lớn → KL penalty nặng → policy bị 'kéo ghì' về SFT. Reward không tăng được nhiều. Ngược lại β quá nhỏ → policy drift xa, dễ reward hacking. Chọn β là trade-off trung tâm của RLHF (thường 0.01–0.2).

Động lực huấn luyện theo β

β nhỏ (0.01)

Policy tự do → reward model score tăng nhanh. Nhưng có thể bị hack: mô hình nịnh, xả văn, trả lời off-topic. Cần giám sát kỹ.

β vừa (0.05–0.2)

Sweet spot. Policy cải thiện rõ trên preference eval, KL với SFT vừa phải (~5–15), chất lượng thực tế tăng ổn định.

β lớn (>0.5)

Policy gần như = SFT. Reward không tăng được. Lãng phí compute. Bằng chứng: eval win-rate vs SFT chỉ nhỉnh hơn 50/50.

Trong thực tế, các lab như OpenAI và Anthropic dùng thêm adaptive KL control — β thay đổi theo KL thực đo được, đảm bảo KL nằm trong khoảng mục tiêu (thường 6–12 nats).

Pipeline SFT → Reward Model → PPO

RLHF (Reinforcement Learning from Human Feedback) là một pipeline 3 giai đoạn được giới thiệu bởi Christiano et al. (2017) và áp dụng thành công vào LLM bởi InstructGPT (Ouyang et al., 2022). Mục tiêu: biến một mô hình ngôn ngữ lớn đã pretrain thành một trợ lý hữu ích, trung thực, và an toàn — phù hợp với preference của con người. Ba giai đoạn:

  1. SFT (Supervised Fine-Tuning): fine-tune base model trên dữ liệu demo (prompt, response mẫu) bằng cross-entropy loss. Kết quả: π_SFT, mô hình biết trả lời theo format mong muốn.
  2. Reward Model (RM): huấn luyện một mô hình R_φ dự đoán preference của con người dựa trên preference pairs (prompt, chosen, rejected). Loss Bradley-Terry:
LRM(ϕ)=−E(x,yw,yl)∼D[log⁡σ(Rϕ(x,yw)−Rϕ(x,yl))]\mathcal{L}_{\text{RM}}(\phi) = -\mathbb{E}_{(x, y_w, y_l) \sim D} \left[ \log \sigma\left( R_\phi(x, y_w) - R_\phi(x, y_l) \right) \right]

trong đó y_w là chosen, y_l là rejected.

  1. PPO (Proximal Policy Optimization): tối ưu policy π_θ để tối đa reward từ R_φ, với một ràng buộc KL để giữ gần π_SFT.

Hàm mục tiêu của bước PPO (core equation của RLHF):

max⁡πθ  Ex∼D, y∼πθ(⋅∣x)[Rϕ(x,y)  −  β⋅log⁡πθ(y∣x)πSFT(y∣x)]\max_{\pi_\theta} \; \mathbb{E}_{x \sim D, \, y \sim \pi_\theta(\cdot \mid x)} \left[ R_\phi(x, y) \;-\; \beta \cdot \log \frac{\pi_\theta(y \mid x)}{\pi_{\text{SFT}}(y \mid x)} \right]

Thành phần KL penalty (β · log π_θ/π_SFT) tương đương β⋅DKL(πθ∥πSFT)\beta \cdot D_{\text{KL}}(\pi_\theta \| \pi_{\text{SFT}}) khi lấy kỳ vọng. Đây là reward shaping per-token: reward thực tế mỗi token là R_φ (ở token cuối) minus β · KL cục bộ. β kiểm soát trade-off giữa "tối đa reward" và "giữ gần SFT".

reward_model_training.py

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import AutoModel, AutoTokenizer

class RewardModel(nn.Module):
    """
    Reward Model: base LLM + một head tuyến tính cho ra scalar reward.
    """

    def __init__(self, base_model_name: str):
        super().__init__()
        self.backbone = AutoModel.from_pretrained(base_model_name)
        hidden = self.backbone.config.hidden_size
        self.value_head = nn.Linear(hidden, 1, bias=False)

    def forward(self, input_ids, attention_mask):
        out = self.backbone(input_ids, attention_mask=attention_mask)
        last_hidden = out.last_hidden_state
        # Lấy hidden state của token cuối cùng (cuối response)
        lengths = attention_mask.sum(dim=1) - 1
        last = last_hidden[torch.arange(last_hidden.size(0)), lengths]
        reward = self.value_head(last).squeeze(-1)  # (batch,)
        return reward


def rm_loss(reward_chosen, reward_rejected):
    """Bradley-Terry loss: khuyến khích reward(chosen) > reward(rejected)."""
    return -F.logsigmoid(reward_chosen - reward_rejected).mean()


# Training loop
def train_step(rm, tokenizer, batch, optimizer):
    # batch gồm danh sách (prompt, chosen, rejected)
    chosen_texts = [p + c for p, c, _ in batch]
    rejected_texts = [p + r for p, _, r in batch]

    chosen_enc = tokenizer(chosen_texts, padding=True, truncation=True,
                           return_tensors="pt").to("cuda")
    rejected_enc = tokenizer(rejected_texts, padding=True, truncation=True,
                             return_tensors="pt").to("cuda")

    r_chosen = rm(**chosen_enc)
    r_rejected = rm(**rejected_enc)

    loss = rm_loss(r_chosen, r_rejected)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item(), (r_chosen > r_rejected).float().mean().item()

Lời giải đóng của objective RLHF

Objective RLHF max_π E[R − β · log(π/π_SFT)] có lời giải đóng (closed form) khi tối ưu trên không gian phân phối:

π∗(y∣x)=1Z(x)πSFT(y∣x)⋅exp⁡ ⁣(1βRϕ(x,y))\pi^*(y \mid x) = \frac{1}{Z(x)} \pi_{\text{SFT}}(y \mid x) \cdot \exp\!\left( \frac{1}{\beta} R_\phi(x, y) \right)

trong đó Z(x) là hệ số chuẩn hóa (partition function). Đây chính là softmax distribution với temperature 1/β. Lời giải này gợi ý:

  • Khi β → ∞: π* → π_SFT (KL penalty chiếm ưu thế).
  • Khi β → 0: π* → argmax R_φ (reward chiếm ưu thế).
  • PPO chỉ là một cách xấp xỉ π* bằng gradient ascent — vì Z(x) intractable.
  • DPO (Rafailov et al., 2023) khai thác closed form này để bỏ hoàn toàn RM + PPO — tối ưu trực tiếp trên preference pairs.

Reward hacking và code mẫu

ppo_rlhf_with_trl.py

# Dùng thư viện TRL (Hugging Face) — abstraction phổ biến cho RLHF.
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer
import torch

# 1. Load policy (π_θ) — khởi tạo từ π_SFT
policy = AutoModelForCausalLMWithValueHead.from_pretrained("sft-model")
ref_model = AutoModelForCausalLMWithValueHead.from_pretrained("sft-model")
ref_model.eval()  # ref_model = π_SFT, đóng băng để tính KL

tokenizer = AutoTokenizer.from_pretrained("sft-model")
reward_model = load_reward_model("rm-model")

# 2. Cấu hình PPO
config = PPOConfig(
    model_name="sft-model",
    learning_rate=1e-5,
    batch_size=64,
    mini_batch_size=8,
    ppo_epochs=4,
    init_kl_coef=0.05,     # β ban đầu
    adap_kl_ctrl=True,     # adaptive KL control
    target=6.0,            # target KL (nats)
    cliprange=0.2,         # PPO clip range
    cliprange_value=0.2,
    vf_coef=0.1,
    gamma=1.0,
    lam=0.95,
)

trainer = PPOTrainer(
    config=config,
    model=policy,
    ref_model=ref_model,
    tokenizer=tokenizer,
)

# 3. Training loop
for epoch in range(num_epochs):
    for batch in prompt_dataloader:
        prompts = batch["prompt"]
        prompt_tensors = [tokenizer.encode(p, return_tensors="pt")[0] for p in prompts]

        # (a) Policy sinh response
        response_tensors = [
            trainer.generate(p, max_new_tokens=200, do_sample=True, top_p=0.9)[0]
            for p in prompt_tensors
        ]
        responses = [tokenizer.decode(r) for r in response_tensors]

        # (b) Reward model chấm
        rewards = [
            torch.tensor(reward_model.score(p, r))
            for p, r in zip(prompts, responses)
        ]

        # (c) PPO update — tự động áp dụng KL penalty với ref_model
        stats = trainer.step(prompt_tensors, response_tensors, rewards)

        # (d) Log
        print(f"reward={stats['ppo/mean_scores']:.3f}, "
              f"KL={stats['objective/kl']:.2f}, "
              f"β={stats['objective/kl_coef']:.4f}")

So sánh với các phương pháp alignment khác

RLHF không phải lựa chọn duy nhất. Dưới đây là các biến thể và lựa chọn thay thế phổ biến:

  • RLAIF (RL from AI Feedback, Anthropic): thay annotator con người bằng một LLM khác chấm điểm theo nguyên tắc (constitution). Rẻ hơn, scale tốt hơn, dùng trong Claude.
  • DPO (Direct Preference Optimization): bỏ RM + PPO, tối ưu policy trực tiếp trên preference pairs bằng closed-form loss. Đơn giản hơn, ổn định hơn, hiệu quả tương đương hoặc hơn RLHF.
  • IPO / KTO: biến thể của DPO với loss khác, khắc phục overfitting trên preference.
  • GRPO (DeepSeekMath): bỏ value network của PPO, dùng group-relative advantage. Giảm bộ nhớ, tốt cho reasoning model.
  • Constitutional AI: RLAIF với SL-CAI (tự phê bình theo nguyên tắc) + RL-CAI. Cách Anthropic scale an toàn.
  • RLVR (Reinforcement Learning with Verifiable Rewards): dùng kiểm tra khách quan (unit test, toán học đúng/sai) thay vì RM. Nền tảng của các reasoning model như o1, DeepSeek-R1.

Ứng dụng, pitfalls và chi phí

  • ChatGPT (OpenAI): RLHF gốc. InstructGPT → ChatGPT → GPT-4 đều có giai đoạn RLHF với hàng triệu preference.
  • Claude (Anthropic): Constitutional AI + RLAIF — dùng LLM làm annotator dựa trên "hiến pháp" 60+ nguyên tắc.
  • Gemini (Google DeepMind): RLHF + safety fine-tuning + RL với verifiable rewards.
  • LLaMA-2 Chat (Meta): SFT + 2 reward models (helpful + safety) + RLHF với rejection sampling + PPO.
  • InstructGPT paper (2022): RLHF giúp mô hình 1.3B parameter vượt GPT-3 175B về preference của người dùng — bằng chứng alignment > scale.
  • Ngoài LLM: Image generation (Imagen, DALL·E 3), code generation (Codex, Copilot), robotics (RT-2), tất cả đều dùng human feedback ở dạng nào đó.
  • RM overfitting: RM có thể memorize pattern của dataset preference (ví dụ: câu nào dài hơn thắng). Cross-validation, hold-out evaluator LLM, diversity trong training preferences.
  • β cố định: Fix β suốt training không tối ưu — dùng adaptive KL control để β tự điều chỉnh theo KL thực đo.
  • Reward hacking không phát hiện: Nếu chỉ đánh giá bằng chính RM, hack sẽ không lộ ra. Luôn dùng held-out evaluator (người khác, LLM khác) để đánh giá policy cuối.
  • Distribution mismatch: Prompt dùng trong PPO khác với prompt thực tế người dùng nhập → policy tối ưu sai domain. Nên lấy prompt từ distribution gần production.
  • Mất khả năng: RLHF quá mạnh có thể làm mô hình mất khả năng ngôn ngữ / toán / code. Giám sát các benchmark base (MMLU, HumanEval) song song với preference eval.
  • Annotator bias: Nếu annotator thiên về một văn hóa / quan điểm, RM sẽ thiên theo. Đa dạng hóa pool, đo inter-annotator agreement, và minh bạch về composition của annotator.

Trong thực tế: RLHF là kỹ thuật tốn kém (hàng triệu USD (ước lượng theo nguồn bài, chưa kiểm chứng) cho preference annotation + compute), nhưng là con đường đã được chứng minh là hiệu quả để biến base LLM thành trợ lý hữu ích. DPO và các biến thể đơn giản hơn đang dần thay thế PPO trong nhiều pipeline — nhưng ý tưởng cốt lõi "học từ preference của con người" vẫn là trung tâm của mọi công nghệ alignment hiện đại.

Tóm tắt

  • Pipeline 3 giai đoạn: SFT (học format từ demo) → Reward Model (học preference con người) → PPO (tối ưu policy theo RM + KL penalty).
  • RM thay mặt con người chấm điểm hàng triệu response — giải quyết nút cổ chai tốc độ của human feedback. Loss Bradley-Terry trên preference pairs (chosen vs rejected).
  • Objective PPO cốt lõi: max E[R_φ(x, y) − β · KL(π_θ ‖ π_SFT)]. β kiểm soát trade-off giữa tối đa reward và trung thành với SFT.
  • KL penalty là phanh chống reward hacking — nếu không có, policy sẽ tìm ngóc ngách của RM (nịnh bợ, xả văn, off-topic) để thổi điểm.
  • RLHF không dạy kiến thức mới — nó dạy giá trị (helpful, honest, harmless). Mã hóa giá trị qua preference pairs của annotator.
  • Biến thể: RLAIF (AI annotator), DPO (bỏ RM+PPO), GRPO (bỏ value net), Constitutional AI (hiến pháp + RLAIF), RLVR (verifiable rewards). DPO đang dần phổ biến do đơn giản hơn.

Continue the module

Lesson 1 of 11