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

GRPO - Tối ưu hóa chính sách theo nhóm

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

Phương pháp alignment hiệu quả, sử dụng phần thưởng nhóm thay vì reward model riêng biệt.

lesson98 minHuấn luyện & AlignmentAI Researcher

Dự đoán

RLHF truyền thống cần reward model (tốn kém). DPO cần dữ liệu cặp sở thích do người gán (khó thu thập ở quy mô lớn). Có cách alignment nào tránh được CẢ HAI nút cổ chai đó không?

GRPO: cho prompt x, mô hình sinh G phản hồi y_1…y_G; chấm điểm bằng reward function (VD: verifier toán học); lấy mean nhóm làm baseline; advantage = (r − mean) / std. Không cần reward model, không cần preference pair. Đây là cách DeepSeek-R1 đạt kết quả reasoning ngang o1 với ngân sách rất khác biệt.

Phép so sánh trong lớp

Hãy tưởng tượng một lớp giải toán: thay vì thuê một chuyên gia chấm 1-1 (reward model), thầy giáo cho cả lớp cùng làm MỘT đề. Ai trả lời bằng đáp án đúng thì được cộng điểm, ai sai thì trừ (verifier đơn giản). Sau đó tất cả nhìn lên bảng: "lớp mình trung bình đang được 0.6 điểm". Học sinh làm hơn trung bình → khen nhiều hơn; dưới trung bình → nhắc nhở. Không cần giám khảo trọng tài — lớp tự so với chính mình. Đó là tinh thần GRPO.

Khoảnh khắc Aha

GRPO thay thế giám khảo chuyên nghiệp (reward model + critic) bằng so sánh trong nhóm: cho mô hình sinh 8–64 bài, bài nào vượt trung bình thì khen, dưới thì giảm. Baseline không phải một mạng thần kinh — mà chính là mean của chính nhóm đó. Nhờ vậy GRPO bỏ được critic, giữ nguyên tinh thần trust-region của PPO, và vẫn ổn định nhờ clipping + KL.

Thử thách

GRPO sinh 8 phản hồi cho prompt '15 × 7 = ?'. Rewards: [1, 0, 1, 1, 0, 1, 0, 1]. Mean = 0.625, std ≈ 0.484. Phản hồi nào có advantage DƯƠNG?

Â_i = (r − 0.625) / 0.484. r = 1 → Â ≈ +0.77 (dương, tăng P). r = 0 → Â ≈ −1.29 (âm, giảm P). 5 phản hồi đúng được tăng, 3 sai bị giảm xác suất trong bước gradient.

Với G = 32 phản hồi, TOÀN BỘ đều sai (reward = 0 cho cả 32). Lúc này bước cập nhật GRPO cho group này làm gì?

Khi mọi reward bằng nhau, group mất tín hiệu phân biệt. Implementation chuẩn thêm ε ~ 1e-8 vào std để tránh chia 0, và thực tế thường filter-out những prompt quá khó ở bước curriculum. Đây là lý do prompt selection / khó vừa phải quan trọng với GRPO.

Thiết lập và group advantage

GRPO (Group Relative Policy Optimization, DeepSeek 2024) là biến thể PPO tối ưu cho fine-tune LLM, đặc biệt cho các bài toán có verifiable reward. Nó là bước tiến quan trọng sau RLHF và DPO, và là công thức huấn luyện của nhiều reasoning model hiện đại như DeepSeek-R1.

Thiết lập. Cho prompt xx, chính sách cũ πold\pi_{\text{old}} sinh G phản hồi {y1,…,yG}\{y_1, \dots, y_G\}. Một hàm reward R(x,y)R(x, y) cho điểm mỗi phản hồi (có thể là verifier toán, test code, rule-based, hay reward model — bất kể nguồn).

Bước 1 — Group advantage. Tính mean và std trong nhóm, rồi chuẩn hoá:

A^i  =  ri−mean({r1,…,rG})std({r1,…,rG})+ε\hat{A}_i \;=\; \frac{r_i - \text{mean}(\{r_1,\dots,r_G\})}{\text{std}(\{r_1,\dots,r_G\}) + \varepsilon}

Chú ý A^i\hat{A}_i phụ thuộc HOÀN TOÀN vào group — không có value network V(s) học song song, khác với PPO.

Policy objective

Bước 2 — Policy objective. Dùng PPO-style clipped objective, nhưng với advantage theo group:

JGRPO(θ)=Ex,{yi}[1G∑i=1Gmin⁡(ρi(θ)A^i,  clip(ρi(θ),1−ϵ,1+ϵ)A^i)]−β DKL ⁣(πθ ∥ πref)\mathcal{J}_{\text{GRPO}}(\theta) = \mathbb{E}_{x, \{y_i\}} \left[ \frac{1}{G}\sum_{i=1}^{G} \min\left( \rho_i(\theta) \hat{A}_i, \; \text{clip}\left(\rho_i(\theta), 1-\epsilon, 1+\epsilon\right) \hat{A}_i \right) \right] - \beta \, D_{\text{KL}}\!\left( \pi_\theta \,\|\, \pi_{\text{ref}} \right)

Trong đó ρi(θ)=πθ(yi∣x)πold(yi∣x)\rho_i(\theta) = \frac{\pi_\theta(y_i|x)}{\pi_{\text{old}}(y_i|x)} là importance ratio; ϵ\epsilon ≈ 0.2; β\beta ≈ 0.02–0.1. Mục tiêu tổng: khuyến khích phản hồi có advantage dương, nhưng không cho chính sách thay đổi quá mạnh trong một bước (clipping) và phải giữ gần mô hình reference (KL).

Verifiable reward và bỏ critic

Code mẫu

grpo_core.py — pseudocode ngắn gọn

import torch
import torch.nn.functional as F

def grpo_step(
    prompt_batch,          # list of prompts
    policy,                # π_θ, sinh + log-prob
    policy_old,            # π_old (lưu tạm trước step)
    policy_ref,            # π_ref (mô hình SFT) — KL anchor
    reward_fn,             # reward(prompt, response) -> float
    G: int = 16,           # group size
    epsilon: float = 0.2,
    beta: float = 0.04,
    eps_std: float = 1e-8,
):
    """Một bước GRPO."""
    loss_total = 0.0
    for prompt in prompt_batch:
        # 1) Rollout G phản hồi từ π_old
        responses = policy_old.generate(prompt, num_return=G,
                                         temperature=0.9, top_p=0.95)

        # 2) Chấm reward
        rewards = torch.tensor(
            [reward_fn(prompt, y) for y in responses], dtype=torch.float32
        )

        # 3) Group advantage
        mean_r = rewards.mean()
        std_r = rewards.std() + eps_std
        advantages = (rewards - mean_r) / std_r   # (G,)

        # 4) Log-prob mới / cũ (tính ở token-level, ở đây vắn tắt)
        logp_new = policy.log_prob(prompt, responses)       # (G,)
        logp_old = policy_old.log_prob(prompt, responses)   # (G,)
        logp_ref = policy_ref.log_prob(prompt, responses)   # (G,)

        # 5) Importance ratio + clipped objective
        rho = torch.exp(logp_new - logp_old)
        unclipped = rho * advantages
        clipped = torch.clamp(rho, 1 - epsilon, 1 + epsilon) * advantages
        ppo_term = torch.min(unclipped, clipped).mean()

        # 6) KL penalty (unbiased estimator)
        log_ratio_ref = logp_new - logp_ref
        kl = (torch.exp(log_ratio_ref) - log_ratio_ref - 1).mean()

        loss = -(ppo_term - beta * kl)   # minimize -J
        loss_total = loss_total + loss

    loss_total = loss_total / len(prompt_batch)
    loss_total.backward()
    # optimizer.step(); optimizer.zero_grad() ở bên ngoài

    return loss_total.detach().item()

Verifiable reward thực tế — toán và code

import re, subprocess, tempfile, os

# ── Toán: trích xuất <answer>…</answer>, so khớp đáp án số ──
def math_reward(prompt, response, ground_truth: str) -> float:
    m = re.search(r"<answer>(.*?)</answer>", response, re.S)
    if not m:
        return 0.0
    pred = m.group(1).strip().replace(",", "")
    # reward chính + reward format nhỏ
    base = 1.0 if pred == ground_truth.strip() else 0.0
    fmt = 0.1  # có <answer>…</answer>
    return base + fmt

# ── Code: lưu file, chạy pytest với test có sẵn ──
def code_reward(prompt, response, test_code: str, timeout: int = 5) -> float:
    # Trích code block
    m = re.search(r"```python(.*?)```", response, re.S)
    if not m:
        return 0.0
    code = m.group(1)
    with tempfile.TemporaryDirectory() as d:
        open(os.path.join(d, "sol.py"), "w").write(code)
        open(os.path.join(d, "test_sol.py"), "w").write(test_code)
        try:
            r = subprocess.run(
                ["pytest", "-q", d],
                capture_output=True, timeout=timeout, text=True,
            )
            return 1.0 if r.returncode == 0 else 0.0
        except subprocess.TimeoutExpired:
            return -0.1   # phạt nhẹ nếu bị treo

# Reward tổng có thể cộng dồn: đúng + format + length penalty + ...
def combined_reward(prompt, response, meta):
    r = math_reward(prompt, response, meta["gt"])
    # Phạt câu trả lời dài hơn 2k tokens
    if len(response.split()) > 2000:
        r -= 0.2
    return r

PPO chuẩn để so sánh

Khía cạnhPPO chuẩn
Critic/value netCÓ — network riêng ước lượng V(s)
BaselineV(s) học cùng policy (GAE / TD)
AdvantageA = r + γV(s') − V(s) (GAE)
Bộ nhớ~2× model (policy + critic); + reward model trong RLHF
ExplorationQua stochastic policy; entropy bonus
RewardThường là reward model học từ preference (RLHF)
Chi phí chínhChạy đồng thời policy + critic + RM
Ổn địnhNhạy với critic; cần tune nhiều; dễ drift

Đi sâu: vì sao GRPO ổn định với context dài

Với PPO truyền thống, value network V(s) ở level token thường không ổn định khi context dài: một token sai sớm làm V chệch nhiều token sau. Advantage theo GAE kết hợp nhiều bước, nhiễu tích tụ.

GRPO thay V(s) bằng mean group — ước tính Monte Carlo không lệch của phần thưởng kỳ vọng. Phương sai có thể cao hơn V(s) học tốt, nhưng với G ≥ 8 đã đủ nhỏ. Quan trọng hơn: không còn mạng thần kinh phụ drift → KL chỉ phải kiểm soát một mô hình.

Ngoài ra, DeepSeek dùng reward normalization per prompt group — tức là chia theo std riêng từng group — nên prompt dễ (group có variance nhỏ) không bị khuếch đại bởi gradient lớn. Tính chất này rất hữu ích trong curriculum: các prompt dễ tự nhiên "ngủ yên", prompt khó đóng góp nhiều hơn.

So sánh với REINFORCE, RLOO, DPO và PPO

REINFORCE (Williams 1992): gradient = r · ∇ log π(y|x). Không baseline → phương sai cực cao, không ổn định cho LLM.

RLOO (REINFORCE Leave-One-Out, Ahmadian 2024): baseline = mean của G−1 phản hồi còn lại (không tính phản hồi i). Gần giống GRPO nhưng KHÔNG chuẩn hoá theo std. Thường được so sánh trực tiếp; GRPO ổn định hơn nhờ std normalization + KL anchor.

DPO (Rafailov 2023): supervised trên cặp (y_w, y_l) preference; không RL, không cần reward model tại huấn luyện. Rất đơn giản nhưng yêu cầu dữ liệu preference và không khám phá ngoài phân phối. GRPO bổ sung exploration qua sampling và verifiable reward.

PPO (RLHF gốc): dùng reward model + value network + clipping + KL. Mạnh và tổng quát nhất nhưng tốn bộ nhớ và rất nhạy với tune.

Kinh nghiệm 2024–2025: với reasoning task và verifier rõ ràng, GRPO thường cho sample-efficiency tốt hơn (theo nguồn bài, chưa kiểm chứng) PPO-RLHF ở cùng ngân sách tính toán. Với tác vụ chatty tổng quát (helpful + harmless), RLHF-PPO hoặc DPO + IPO vẫn là pipeline chủ đạo.

Ứng dụng và pitfalls

Ứng dụng thực tế.

  • Reasoning models: DeepSeek-R1, DeepSeek-Math, Qwen2.5-Math — dùng GRPO với verifier toán/code; đạt SOTA trên MATH, AIME, Codeforces.
  • Agent tool-use: huấn luyện agent gọi tool đúng format + hoàn thành task đo được (VD: đúng API, đúng JSON schema, đúng kết quả query).
  • Code generation: reward = pass/fail unit test; đặc biệt mạnh cho competitive programming.
  • Game & simulation: reward trực tiếp từ môi trường — GRPO thay thế PPO trong một số baseline RL mới.
  • Safety & alignment: kết hợp verifier "đúng hướng dẫn" (rule-based check) để fine-tune tuân thủ format / từ chối nội dung nhạy cảm mà không cần dữ liệu preference quy mô lớn.

Pitfalls thường gặp.

  • Reward hacking: mô hình tìm ra đường đi tắt đạt reward mà không giải đúng (VD: luôn in "42", lạm dụng format thưởng). Giảm thiểu bằng verifier chặt + KL đủ lớn + reward shaping đa chiều (đúng + format + length).
  • Reward sparsity: với task khó, hầu hết G sample đều sai → group không có tín hiệu. Dùng curriculum learning từ dễ → khó, hoặc pretrain SFT tốt trước khi RL.
  • Chi phí rollout: G × #prompt × tokens → dễ tốn gấp 10–30 lần SFT. Bắt buộc dùng inference engine tối ưu (vLLM, SGLang, TensorRT-LLM) và có thể fix seed để reproducible.
  • KL drift chậm: β quá nhỏ → policy trôi xa ref, mất ngôn ngữ tự nhiên; β quá lớn → policy không học được. Theo dõi D_KL thực tế theo thời gian và tune.
  • Length bias: phản hồi dài dễ có reward format cao hơn → mô hình viết dài thừa. Thêm length penalty hoặc normalize reward theo token.
  • Group size quá nhỏ: G = 2 làm baseline dao động mạnh, giống REINFORCE. Mặc định G = 8–16, mạnh hơn có thể G = 32–64.

Tóm tắt

  • GRPO sinh G phản hồi cho cùng prompt, chấm reward, rồi dùng mean/std của NHÓM làm baseline — không cần critic/value network.
  • Advantage Â_i = (r_i − mean(r)) / std(r) → mẫu vượt trung bình được tăng P, dưới trung bình bị giảm P.
  • Kế thừa từ PPO: importance ratio ρ = π_new/π_old, clipping ε ≈ 0.2 giữ trust region, KL penalty β neo gần mô hình reference để chống reward hacking.
  • Đặc biệt mạnh với VERIFIABLE REWARD (toán, code, logic) — DeepSeek-R1, DeepSeek-Math dùng GRPO đạt SOTA reasoning mà không cần reward model.
  • Chi phí chính ở giai đoạn ROLLOUT (G × #prompt) — cần inference engine tối ưu (vLLM, SGLang) để ngân sách thực tế.
  • Không phù hợp tác vụ chủ quan, tác vụ mà group dễ toàn sai/toàn đúng (advantage = 0); chọn DPO hoặc PPO-RLHF khi thích hợp hơn.

Continue the module

Lesson 3 of 11