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

Gradient chính sách

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

Phương pháp tối ưu trực tiếp chính sách hành động bằng gradient ascent trên phần thưởng kỳ vọng

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

Dự đoán

Robot cần điều khiển cánh tay (góc xoay 0–360 độ — liên tục). Q-Learning cần discretize thành 36 bins → mất độ chính xác. Có cách nào tốt hơn?

Q-Learning: output Q cho mỗi action rời rạc → action liên tục phải discretize (mất thông tin). Policy Gradient: output mean + std của Gaussian → sample action liên tục trực tiếp. Tự nhiên cho robot, xe tự lái, bất kỳ action space liên tục nào.

Khoảnh khắc Aha

Q-Learning: học bản đồ giá trị rồi suy ra đường đi. Policy Gradient: học trực tiếp cách đi. Giống học lái xe: Q-Learning = học giá trị mỗi ngã tư rồi tính đường. PG = học trực tiếp phản xạ (bao nhiêu độ, nhanh/chậm). PG tự nhiên hơn cho hành động liên tục!

Thử thách

REINFORCE có vấn đề: variance cao vì dùng toàn bộ episode return. Cách đơn giản nhất để giảm variance?

Baseline subtraction: thay vì gradient = G_t · ∇ log π, dùng (G_t − b) · ∇ log π. Nếu b = mean(G), action tốt hơn trung bình → gradient dương (tăng xác suất). Action tệ → gradient âm (giảm). Không thay đổi expected gradient nhưng variance giảm 50–90%!

Chính sách hội tụ về π(right)=0.98. Bạn có nên xoá hẳn p(left) = 0 không?

Khi p(action) tiến sát 1 thì gradient của action còn lại gần bằng 0 — policy không thể thoát khỏi cực trị cục bộ. Thực hành tốt: cộng thêm entropy bonus β · H(π) vào objective để giữ một chút exploration, đặc biệt khi môi trường non-stationary.

Định nghĩa và định lý

Policy Gradient tối ưu trực tiếp policy πθ(a∣s)\pi_\theta(a|s) bằng gradient ascent trên expected return. Trái ngược với Q-Learning (học value rồi suy ra policy), PG học policy trực tiếp. Kết hợp với một critic ta được Actor-Critic, và biến thể PPO/GRPO hiện là xương sống của RLHF cho các mô hình ngôn ngữ.

Policy Gradient Theorem:

∇θJ(θ)=Eπθ[∑t=0T∇θlog⁡πθ(at∣st)⋅Gt]\nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^{T} \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot G_t\right]

REINFORCE với baseline:

∇θJ(θ)=E[∇θlog⁡πθ(at∣st)⋅(Gt−b)]\nabla_\theta J(\theta) = \mathbb{E}\left[\nabla_\theta \log \pi_\theta(a_t|s_t) \cdot (G_t - b)\right]

Advantage function là lựa chọn baseline phổ biến nhất:

Aπ(s,a)=Qπ(s,a)−Vπ(s),∇θJ≈E[∇θlog⁡πθ(a∣s)⋅Aπ(s,a)]A^{\pi}(s,a) = Q^{\pi}(s,a) - V^{\pi}(s), \quad \nabla_\theta J \approx \mathbb{E}\left[\nabla_\theta \log \pi_\theta(a|s) \cdot A^{\pi}(s,a)\right]

Ghi chú về continuous action và gradient ascent

Code mẫu

REINFORCE với PyTorch — bản đầy đủ

import torch
import torch.nn as nn
import torch.distributions as dist

class PolicyNetwork(nn.Module):
    def __init__(self, state_dim: int, action_dim: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, 128), nn.ReLU(),
            nn.Linear(128, 128), nn.ReLU(),
            nn.Linear(128, action_dim),
        )

    def forward(self, state: torch.Tensor) -> torch.Tensor:
        logits = self.net(state)
        return torch.softmax(logits, dim=-1)


def train(env, episodes: int = 1000, gamma: float = 0.99, lr: float = 3e-4):
    state_dim = env.observation_space.shape[0]
    action_dim = env.action_space.n
    policy = PolicyNetwork(state_dim, action_dim)
    optim = torch.optim.Adam(policy.parameters(), lr=lr)

    for ep in range(episodes):
        state, _ = env.reset()
        log_probs, rewards = [], []
        done = False

        while not done:
            s = torch.as_tensor(state, dtype=torch.float32)
            probs = policy(s)
            d = dist.Categorical(probs)
            a = d.sample()
            log_probs.append(d.log_prob(a))
            state, r, terminated, truncated, _ = env.step(a.item())
            rewards.append(r)
            done = terminated or truncated

        # Tính discounted returns
        returns, G = [], 0.0
        for r in reversed(rewards):
            G = r + gamma * G
            returns.insert(0, G)
        returns_t = torch.tensor(returns, dtype=torch.float32)

        # Baseline subtraction: trừ mean + chuẩn hoá → variance reduction
        returns_t = (returns_t - returns_t.mean()) / (returns_t.std() + 1e-8)

        # Policy gradient loss — dấu âm vì ta gradient-DESCENT trên -J
        loss = -(torch.stack(log_probs) * returns_t).sum()

        optim.zero_grad()
        loss.backward()
        torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0)
        optim.step()

        if ep % 50 == 0:
            print(f"ep={ep:4d} return={sum(rewards):7.2f} "
                  f"len={len(rewards):3d} grad_norm_clipped=1.0")

NumPy — REINFORCE đồ chơi cho corridor

import numpy as np

def run_episode(policy, corridor_len=11, goal=5, max_steps=20):
    pos, traj = 0, []
    for _ in range(max_steps):
        a = np.random.choice(2, p=policy)   # 0=left, 1=right
        new_pos = max(0, pos - 1) if a == 0 else min(corridor_len - 1, pos + 1)
        r = 1.0 if new_pos == goal else -0.04
        traj.append((pos, a, r))
        pos = new_pos
        if pos == goal:
            break
    return traj

def reinforce_update(policy, traj, lr=0.35, gamma=0.95):
    # Tính return từng step
    G, returns = 0.0, []
    for _, _, r in reversed(traj):
        G = r + gamma * G
        returns.insert(0, G)
    returns = np.array(returns)
    advantages = returns - returns.mean()  # baseline = mean

    p = policy.copy()
    for (_, a, _), adv in zip(traj, advantages):
        # Gradient của log-softmax 2 lớp
        p[a]    += lr * adv * (1 - p[a])
        p[1-a]  -= lr * adv * p[1-a]
        p = np.clip(p, 0.02, 0.98)
        p /= p.sum()
    return p

policy = np.array([0.5, 0.5])
for ep in range(200):
    traj = run_episode(policy)
    policy = reinforce_update(policy, traj)
    if ep % 20 == 0:
        print(f"ep={ep:3d}  π(right)={policy[1]:.3f}  steps={len(traj)}")

Log-prob trick

Vì sao gọi là "log-prob trick"? Ta biến gradient của một kỳ vọng (khó tính) thành kỳ vọng của một gradient (sample-able). Điểm mấu chốt:

∇θπθ(a∣s)=πθ(a∣s)⋅∇θlog⁡πθ(a∣s)\nabla_\theta \pi_\theta(a|s) = \pi_\theta(a|s) \cdot \nabla_\theta \log \pi_\theta(a|s)

Nhờ đó ta có thể sample action theo policy, lấy gradient của log-prob rồi cân bằng bằng weight (chính là return hoặc advantage). Đây là cách duy nhất để huấn luyện khi environment không khả vi — tức gần như mọi bài toán RL thực tế (game engines, simulators vật lý, LLM decoding, ...).

Vì sao baseline không làm lệch gradient

Cho một baseline b(s)b(s) chỉ phụ thuộc state (không phụ thuộc action). Ta có:

Ea∼π[∇θlog⁡πθ(a∣s)⋅b(s)]=b(s)∑aπθ(a∣s)⋅∇θπθ(a∣s)πθ(a∣s)\mathbb{E}_{a \sim \pi}[\nabla_\theta \log \pi_\theta(a|s) \cdot b(s)] = b(s) \sum_a \pi_\theta(a|s) \cdot \frac{\nabla_\theta \pi_\theta(a|s)}{\pi_\theta(a|s)}
=b(s)∑a∇θπθ(a∣s)=b(s)∇θ(∑aπθ(a∣s))=b(s)∇θ1=0.= b(s) \sum_a \nabla_\theta \pi_\theta(a|s) = b(s) \nabla_\theta \left( \sum_a \pi_\theta(a|s) \right) = b(s) \nabla_\theta 1 = 0.

Vì vậy trừ baseline vẫn giữ unbiased estimator, chỉ làm giảm variance. Baseline tối ưu (variance-minimising) có dạng weighted average các returns, thường được xấp xỉ bằng một value-network Vϕ(s)V_\phi(s) học song song với policy — chính là Actor-Critic.

So sánh REINFORCE, A2C, PPO, GRPO

REINFORCE là bản gốc: dùng Monte Carlo return, update 1 lần/episode, variance rất cao, sample ít. Ưu điểm duy nhất là công thức đơn giản — bạn có thể viết lại chỉ với NumPy như ví dụ phía trên.

A2C / A3C (Advantage Actor-Critic): dùng Critic VϕV_\phi làm baseline, update theo n-step TD hoặc Generalised Advantage Estimation. Variance thấp hơn, sample efficient hơn. A3C (asynchronous) từng là state-of-the-art trước khi PPO xuất hiện.

PPO (Schulman 2017): thêm clipping min⁡(rtAt,clip(rt,1−ϵ,1+ϵ)At)\min(r_t A_t, \text{clip}(r_t, 1-\epsilon, 1+\epsilon) A_t) . Cho phép update nhiều epoch/batch. Đây là default của OpenAI, DeepMind cho RL control và cũng là thuật toán gốc cho RLHF tại OpenAI.

GRPO (DeepSeek 2024): variant của PPO dành cho RLHF/LLM — bỏ critic, dùng group-mean làm baseline. Đơn giản hơn, ít memory hơn, phù hợp khi sample theo prompt. DeepSeek R1, Qwen 2.5, và nhiều mô hình mở khác hiện dùng GRPO thay cho PPO truyền thống.

TRPO (Schulman 2015) là tiền thân của PPO: dùng trust region dựa trên KL-divergence, giải bằng conjugate gradient. Tốt về lý thuyết nhưng phức tạp triển khai — PPO đơn giản hoá bằng cách chỉ clip ratio thay vì giải toán tối ưu có ràng buộc.

Từ REINFORCE đến ChatGPT

Khi nào Policy Gradient thất bại? Khi reward cực kỳ thưa thớt (ví dụ Montezuma's Revenge — phần thưởng chỉ xuất hiện sau hàng trăm bước), mean return ≈ 0, advantage cũng ≈ 0, và policy không có tín hiệu để học. Giải pháp: thêm intrinsic reward (curiosity), hierarchical RL, hoặc imitation learning để bootstrap.

Liên hệ với Maximum Likelihood: nếu bạn gán weight cho mỗi trajectory theo return của nó và cực đại hoá log-likelihood có trọng số, bạn sẽ ra đúng công thức REINFORCE. Đây là góc nhìn "RL = weighted supervised learning" mà nhiều paper RLHF khai thác (ví dụ RWR, AWR, DPO đều dựa trên ý tưởng này).

Tại sao không dùng thẳng gradient của reward? Reward thường không khả vi theo θ\theta — environment là hộp đen. Ta chỉ quan sát samples chứ không có ∇θR(s,a)\nabla_\theta R(s,a). Policy Gradient Theorem là mẹo toán để đẩy gradient vào trong kỳ vọng: ∇Eπ[R]=Eπ[∇log⁡π⋅R]\nabla \mathbb{E}_\pi[R] = \mathbb{E}_\pi[\nabla \log \pi \cdot R] . Mẹo này còn gọi là "log-derivative trick" hoặc "score function estimator" — xuất hiện ở khắp nơi: variational inference, reparameterization trick, REBAR, Gumbel-softmax...

Gợi ý đọc thêm (pháp lý tinh thần): Sutton & Barto chương 13, Spinning Up của OpenAI, và paper gốc PPO. Với LLM: InstructGPT paper, DeepSeek-R1 technical report, và "Secrets of RLHF" series. Nếu thích thực hành, CleanRL (repo của Shengyi Huang) có các file single-file cho REINFORCE, PPO, GRPO — đọc một lần hiểu toàn bộ pipeline.

Công thức bạn nên thuộc lòng: ∇θJ(θ)=E[∇θlog⁡πθ(a∣s)⋅Aπ(s,a)]\nabla_\theta J(\theta) = \mathbb{E}[\nabla_\theta \log \pi_\theta(a|s) \cdot A^\pi(s,a)] . Mọi thuật toán PG hiện đại (A2C, PPO, SAC-discrete, GRPO) đều bắt đầu từ đây rồi chỉ thay đổi cách ước lượng advantage AπA^\pi và cách giới hạn bước update.

Tóm tắt

  • Policy Gradient học TRỰC TIẾP π(a|s), không qua Q-value — tự nhiên cho action liên tục.
  • REINFORCE: sample episode → tính return G_t → update θ theo ∇ log π · G_t.
  • Baseline subtraction: trừ mean return, giảm variance 50–90% mà KHÔNG thay đổi expected gradient.
  • On-policy: mỗi gradient step chỉ dùng dữ liệu từ policy hiện tại — kém sample-efficient hơn off-policy (DQN).
  • Actor-Critic: dùng Critic V_φ(s) làm baseline — biến REINFORCE thành A2C/PPO, ổn định hơn nhiều.
  • PPO/GRPO (với clipping và trust-region) là xương sống của RLHF hiện đại cho ChatGPT, Claude, Gemini.

Continue the module

Lesson 4 of 5