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

Evaluating routing across providers.

Start learning
← Học tăng cường

AI Researcher

Actor-Critic

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

Kiến trúc kết hợp mạng chính sách (Actor) và mạng đánh giá (Critic) để học ổn định hơn

lesson120 minHọc tăng cườngAI Researcher

Dự đoán

REINFORCE (Policy Gradient) có variance cao vì chỉ dùng return làm tín hiệu học. DQN chỉ học value, không học policy trực tiếp. Có cách kết hợp ưu điểm cả hai?

Actor-Critic = best of both worlds. Actor học policy (như REINFORCE nhưng variance thấp hơn vì Critic làm baseline). Critic học value function (như DQN nhưng hỗ trợ Actor chứ không chọn action). PPO (variant của Actor-Critic) là thuật toán dùng cho RLHF trong ChatGPT và Claude.

Khoảnh khắc Aha

Actor = diễn viên (hành động). Critic = đạo diễn (đánh giá). Diễn viên học từ feedback của đạo diễn, đạo diễn học từ reward thật của khán giả (environment). Kết hợp tạo ra một system ổn định và hiệu quả: advantage của Critic giảm variance cho Actor, reward thực giữ Critic grounded. PPO — biến thể được sử dụng nhiều nhất — là thuật toán mặc định cho RLHF trong ChatGPT, Claude, và Gemini.

Thử thách

PPO clip ratio trong [0.8, 1.2]. Nghĩa là policy chỉ thay đổi tối đa ~20% mỗi step. Tại sao không cho thay đổi nhiều hơn (50%)?

Trust region: policy landscape phức tạp, thay đổi lớn có thể 'nhảy' từ vùng tốt sang vùng tệ. PPO giới hạn mỗi step → đảm bảo cải thiện dần dần. ε = 0.2 là sweet spot: đủ nhanh để học, đủ nhỏ để ổn định. Đây là lý do PPO là default cho RLHF.

Critic của bạn luôn dự đoán V(s) = 0 (mạng bị stuck). Chuyện gì xảy ra với Actor?

Critic stuck ở 0 = không còn baseline subtract → advantage = return thô → biến Actor-Critic thành REINFORCE cơ bản (variance cao). Debug: kiểm tra loss scale của Critic (hệ số β thường 0.5), learning rate Critic, initialization. Critic phải học trước hoặc song song.

A2C và advantage

Actor-Critic kết hợp policy optimization (Actor) với value estimation (Critic) — ổn định và hiệu quả hơn khi dùng riêng lẻ. Về bản chất, Actor kế thừa ý tưởng từ Policy Gradient, còn Critic học value function tương tự Q-Learning.

Advantage Actor-Critic (A2C) định nghĩa advantage qua TD error:

A(s,a)=r+γV(s′)−V(s)(TD error laˋm advantage estimate)A(s, a) = r + \gamma V(s') - V(s) \quad \text{(TD error làm advantage estimate)}

Actor update dùng advantage để "cân" gradient log-probability:

∇θJ(θ)=E[∇θlog⁡πθ(a∣s)⋅A(s,a)]\nabla_\theta J(\theta) = \mathbb{E}\left[\nabla_\theta \log \pi_\theta(a | s) \cdot A(s, a)\right]

Critic update minimise squared TD error:

Lcritic=(r+γVϕ(s′)−Vϕ(s))2\mathcal{L}_{\text{critic}} = \left(r + \gamma V_\phi(s') - V_\phi(s)\right)^2

Tổng loss thường là tổng trọng số, cộng thêm entropy bonus để giữ exploration:

L=Lactor+cv⋅Lcritic−ce⋅H(πθ)\mathcal{L} = \mathcal{L}_{\text{actor}} + c_v \cdot \mathcal{L}_{\text{critic}} - c_e \cdot H(\pi_\theta)

Hệ số điển hình: c_v = 0.5, c_e = 0.01. Entropy bonus khuyến khích policy giữ "mềm" — tránh collapse sớm vào suboptimal.

PPO

Proximal Policy Optimization (PPO) thêm một bước quan trọng: giới hạn tỉ số xác suất giữa policy mới và cũ để training ổn định. Đặt r_t(θ) = π_θ(a_t|s_t) / π_θ_old(a_t|s_t), PPO tối đa hoá:

LCLIP(θ)=E[min⁡(rt(θ)A^t,clip(rt(θ),1−ϵ,1+ϵ)A^t)]\mathcal{L}^{\text{CLIP}}(\theta) = \mathbb{E}\left[\min\left(r_t(\theta) \hat{A}_t, \text{clip}(r_t(\theta), 1 - \epsilon, 1 + \epsilon) \hat{A}_t\right)\right]

Với ε = 0.2, policy chỉ thay đổi tối đa 20% mỗi update → đảm bảo training ổn định ngay cả khi reuse data cho nhiều epoch (off-policy nhẹ). Đây là lý do PPO là thuật toán mặc định cho RLHF trong ChatGPT, Claude, Gemini.

Các lưu ý

Code mẫu

A2C với PyTorch (discrete actions)

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Categorical

class ActorCritic(nn.Module):
    """Shared trunk, separate policy / value heads."""

    def __init__(self, state_dim: int, action_dim: int, hidden: int = 128):
        super().__init__()
        self.shared = nn.Sequential(
            nn.Linear(state_dim, hidden),
            nn.ReLU(),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
        )
        self.policy_head = nn.Linear(hidden, action_dim)
        self.value_head = nn.Linear(hidden, 1)

    def forward(self, state: torch.Tensor):
        features = self.shared(state)
        logits = self.policy_head(features)
        value = self.value_head(features).squeeze(-1)
        return logits, value

    def act(self, state: torch.Tensor):
        logits, value = self(state)
        dist = Categorical(logits=logits)
        action = dist.sample()
        log_prob = dist.log_prob(action)
        return action, log_prob, value, dist.entropy()


def a2c_update(
    model: ActorCritic,
    optimizer: torch.optim.Optimizer,
    rollout: dict,
    gamma: float = 0.99,
    value_coef: float = 0.5,
    entropy_coef: float = 0.01,
) -> dict:
    """One A2C update from a batch of (s, a, r, s', done) transitions."""
    states = rollout["states"]       # (T, state_dim)
    actions = rollout["actions"]     # (T,)
    rewards = rollout["rewards"]     # (T,)
    next_states = rollout["next_states"]
    dones = rollout["dones"].float()

    logits, values = model(states)
    _, next_values = model(next_states)

    # 1-step TD target and advantage
    td_target = rewards + gamma * next_values.detach() * (1.0 - dones)
    advantage = (td_target - values).detach()

    dist = Categorical(logits=logits)
    log_probs = dist.log_prob(actions)
    entropy = dist.entropy().mean()

    actor_loss = -(log_probs * advantage).mean()
    critic_loss = F.mse_loss(values, td_target)
    loss = actor_loss + value_coef * critic_loss - entropy_coef * entropy

    optimizer.zero_grad()
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=0.5)
    optimizer.step()

    return {
        "loss": loss.item(),
        "actor_loss": actor_loss.item(),
        "critic_loss": critic_loss.item(),
        "entropy": entropy.item(),
    }


# Training loop sketch (vectorised envs recommended)
model = ActorCritic(state_dim=4, action_dim=2)
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)

for iteration in range(1000):
    rollout = collect_rollout(env, model, n_steps=128)
    stats = a2c_update(model, optimizer, rollout)
    if iteration % 10 == 0:
        print(f"iter={iteration} loss={stats['loss']:.3f} H={stats['entropy']:.3f}")

PPO clip objective (PyTorch)

import torch
import torch.nn.functional as F
from torch.distributions import Categorical

def ppo_update(
    model,
    optimizer,
    rollout: dict,
    epochs: int = 4,
    clip_epsilon: float = 0.2,
    value_coef: float = 0.5,
    entropy_coef: float = 0.01,
    batch_size: int = 64,
):
    """PPO-Clip update reusing a rollout for multiple epochs."""
    states = rollout["states"]
    actions = rollout["actions"]
    advantages = rollout["advantages"]       # computed via GAE
    returns = rollout["returns"]             # GAE + V
    old_log_probs = rollout["log_probs"].detach()

    # Normalise advantages (standard trick)
    advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)

    n = states.shape[0]

    for _ in range(epochs):
        perm = torch.randperm(n)
        for start in range(0, n, batch_size):
            idx = perm[start : start + batch_size]
            s = states[idx]
            a = actions[idx]
            adv = advantages[idx]
            ret = returns[idx]
            old_lp = old_log_probs[idx]

            logits, values = model(s)
            dist = Categorical(logits=logits)
            new_lp = dist.log_prob(a)
            entropy = dist.entropy().mean()

            # Probability ratio r_t(θ)
            ratio = torch.exp(new_lp - old_lp)

            # Clipped surrogate objective
            surr1 = ratio * adv
            surr2 = torch.clamp(ratio, 1 - clip_epsilon, 1 + clip_epsilon) * adv
            actor_loss = -torch.min(surr1, surr2).mean()

            critic_loss = F.mse_loss(values, ret)
            loss = actor_loss + value_coef * critic_loss - entropy_coef * entropy

            optimizer.zero_grad()
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
            optimizer.step()


def compute_gae(rewards, values, dones, gamma=0.99, lam=0.95):
    """Generalized Advantage Estimation (Schulman 2016)."""
    advantages = torch.zeros_like(rewards)
    gae = 0.0
    next_value = 0.0
    for t in reversed(range(len(rewards))):
        mask = 1.0 - dones[t]
        delta = rewards[t] + gamma * next_value * mask - values[t]
        gae = delta + gamma * lam * mask * gae
        advantages[t] = gae
        next_value = values[t]
    returns = advantages + values
    return advantages, returns

A2C, A3C, IMPALA, PPO, SAC và GRPO

A3C (Asynchronous Advantage Actor-Critic, 2016): nhiều worker async, mỗi worker có bản copy model, push gradient về global model. Nổi tiếng nhưng khó reproduce vì non-determinism.

A2C: synchronous version — các env chạy song song nhưng gradient update sync. Đơn giản, deterministic, tận dụng GPU tốt. OpenAI khuyến nghị từ 2017.

IMPALA (DeepMind 2018): scale lên hàng trăm actor với V-trace off-policy correction. Xử lý tốt lag giữa actor và learner. Dùng cho large-scale RL (AlphaStar).

PPO (2017): đơn giản hoá TRPO, clip ratio thay vì KL constraint. Robust, implementation-friendly, default cho RLHF.

SAC: off-policy, maximum entropy, thiết kế cho continuous control. Sample-efficient hơn PPO trên robotics.

GRPO (DeepSeek 2024): Group Relative Policy Optimization — bỏ Critic, dùng reward tương đối giữa các responses cho cùng prompt. Hiệu quả cho LLM RLHF.

Từ Q-Learning tới Actor-Critic

Q-Learning học Q(s, a) → act greedy theo argmax. Hoạt động tốt với action discrete nhỏ. Với action space lớn hoặc continuous, argmax trở nên không khả thi.

Policy Gradient học trực tiếp π(a|s). Vấn đề: variance cao vì chỉ dùng Monte Carlo return làm tín hiệu. REINFORCE cần hàng triệu episode cho bài toán đơn giản.

Insight: nếu ta học đồng thời V(s) làm baseline, thay "return" bằng "return − V(s)" trong gradient, variance giảm mạnh mà không thay đổi expected gradient (vì E[V(s)] = const theo action). Đây chính là Actor-Critic.

Mở rộng: thay baseline V(s) bằng TD target r + γV(s′), được advantage 1-step. Dùng GAE, được smooth multi-step advantage. Thêm clipping, được PPO. Thêm off-policy correction, được IMPALA. Mỗi bước là một cải tiến nhỏ và có lý.

Triển khai và debug

Triển khai thực tế: với các bài cartpole / lunar lander, A2C đơn giản đủ hội tụ trong vài phút trên CPU. Với Atari hay MuJoCo, PPO với vectorized envs (8–32 env song song) là lựa chọn mặc định — libraries tham khảo: Stable Baselines3, CleanRL, RLlib.

Hyperparameters quan trọng cho Actor-Critic: learning rate (3e-4 với Adam là sweet spot), gamma (0.99), GAE lambda (0.95), entropy coef (0.01, decay theo thời gian), value coef (0.5), clip epsilon (0.2 cho PPO), batch size (64–256), epochs per rollout (4–10 cho PPO).

Debug checklist khi Actor-Critic không học: (1) Kiểm tra Critic loss có giảm không — nếu không, Critic có thể stuck. (2) Kiểm tra entropy — nếu rớt về 0 quá nhanh, tăng entropy coef. (3) Kiểm tra advantage scale — nên near-zero-mean, unit-variance sau normalise. (4) Kiểm tra gradient norms — nếu explode, giảm lr hoặc clip mạnh hơn.

RLHF pipeline tổng quan cho LLM: (1) SFT — supervised fine-tune base LLM trên (prompt, response). (2) Reward model — classifier trên (prompt, chosen, rejected) để predict preference. (3) PPO — reward model làm environment, Actor = LLM policy, Critic = value head; GAE + clip 0.2 + KL penalty để không drift khỏi SFT. ChatGPT, Claude, Gemini đều dùng biến thể của pipeline này.

Tóm tắt

  • Actor-Critic: Actor (policy π) chọn action, Critic (value V) đánh giá. Kết hợp ưu điểm Policy Gradient + Q-Learning.
  • Advantage A(s, a) = r + γV(s′) − V(s) đo action tốt/xấu hơn mean bao nhiêu → giảm variance đáng kể cho Actor update.
  • PPO clip ratio trong [1 − ε, 1 + ε] giới hạn thay đổi policy mỗi update → training ổn định ngay cả khi reuse data.
  • PPO là default cho RLHF (ChatGPT, Claude, Gemini). GRPO (DeepSeek) là variant mới không cần Critic riêng, tiết kiệm memory.
  • A3C (async) đã nhường chỗ cho A2C (sync) + vectorized envs trên GPU hiện đại. IMPALA scale lên hàng trăm worker.
  • Entropy bonus giữ policy mềm để tiếp tục explore; GAE (λ ≈ 0.95) cân bằng bias/variance tốt nhất trong hầu hết domain.

Continue the module

Lesson 5 of 5