15.1 强化学习基础

大语言模型的对齐训练——无论是 RLHF、DPO 还是 GRPO——都建立在强化学习（Reinforcement Learning, RL）的理论框架之上。本节从经典 RL 的基本概念出发，依次介绍马尔可夫决策过程（MDP）、值函数与贝尔曼方程、策略梯度定理，以及 Q-Learning、REINFORCE、Actor-Critic 等经典算法，最终过渡到 LLM 场景下 RL 概念的重新诠释，为后续章节的 PPO、GRPO、DPO 等算法打下基础。

---

15.1.1 强化学习的基本范式

强化学习的核心范式可以概括为一句话：智能体（Agent）通过与环境（Environment）的交互，根据获得的奖励信号学习策略，以最大化累积奖励。

与监督学习需要大量"输入-标签"配对不同，RL 只需要一个稀疏的奖励信号（Reward Signal），智能体通过试错（Trial and Error）来发现哪些行为是好的。这种学习范式天然适用于难以提供逐样本标签的场景——游戏对弈、机器人控制，以及 LLM 对齐。

RL 中的核心概念可以归纳为下表：

概念	符号	含义
智能体（Agent）	—	做决策的主体，输出动作
环境（Environment）	—	接收动作、返回状态与奖励的外部系统
状态（State）	$s$	环境的当前描述，Agent 据此决策
动作（Action）	$a$	Agent 在某状态下可选择的行为
奖励（Reward）	$r$	环境对动作的即时反馈标量
策略（Policy）	$\pi (a\mid s)$	从状态到动作的概率分布
回报（Return）	$G_t$	从 $t$ 时刻起的累积折扣奖励

表 15-1：强化学习核心概念。

智能体与环境的交互形成一个循环：智能体在状态 $s$ 下根据策略 $\pi$ 选择动作 $a$，环境接收动作后转移到新状态 $s^{\prime }$ 并给出奖励 $r$，智能体再根据新状态继续决策。

图 15-1：一个 4×4 GridWorld 导航任务。机器人（左上角）需要找到通往目标位置（绿色房子）的路径，同时避开陷阱（红色叉号）。这是 MDP 的一个典型实例。

---

15.1.2 马尔可夫决策过程（MDP）

要让 RL 问题在数学上可处理，需要引入一个关键假设——马尔可夫性（Markov Property）：

$$P(s_{t+1}\mid s_t,a_t,s_{t-1},a_{t-1},\dots )=P(s_{t+1}\mid s_t,a_t)$$

即下一状态仅依赖当前状态和动作，与更早的历史无关。直观地说，当前状态已经携带了做最优决策所需的全部信息。下棋时只需看当前棋盘布局即可决策，不必记忆每一步如何走到这里。

在马尔可夫性的基础上，我们可以将 RL 问题形式化为马尔可夫决策过程（Markov Decision Process, MDP），由五元组 $(S,A,P,R,\gamma )$ 定义：

符号	含义
$S$	状态空间
$A$	动作空间
$P(s^{\prime }\mid s,a)$	状态转移概率
$R(s,a)$	奖励函数
$\gamma \in [0,1]$	折扣因子，权衡即时与未来奖励

表 15-2：MDP 五元组。

回报（Return） 定义为从 $t$ 时刻起的累积折扣奖励：

$$G_t=r_t+\gamma r_{t+1}+{\gamma }^2{r}_{t+2}+\cdots =\sum _{k=0}^{\mathrm{\infty }}{\gamma }^k{r}_{t+k}$$

折扣因子 $\gamma$ 的作用是使远期奖励的权重递减——$\gamma$ 接近 0 时智能体更关注眼前利益，接近 1 时则更重视长远回报。在 LLM 对齐中，通常设 $\gamma$ 接近 1（如 0.99 或直接取 1），因为我们关心的是整个生成序列的最终质量。

---

15.1.3 值函数与贝尔曼方程

值函数是 RL 中最核心的概念之一，它回答了一个问题："从某个状态（或状态-动作对）出发，按照某个策略行动，未来能获得多少累积奖励？"

状态值函数（State Value Function） $V^{\pi }(s)$：从状态 $s$ 出发，按策略 $\pi$ 行动的期望回报：

$$V^{\pi }(s)={\mathbb{E}}_{\pi }[G_t\mid s_t=s]={\mathbb{E}}_{\pi }[\sum _{k=0}^{\mathrm{\infty }}{\gamma }^k{r}_{t+k}\mid s_t=s]$$

动作值函数（Action Value Function / Q 函数） $Q^{\pi }(s,a)$：在状态 $s$ 选择动作 $a$，之后按策略 $\pi$ 行动的期望回报：

$$Q^{\pi }(s,a)={\mathbb{E}}_{\pi }[G_t\mid s_t=s,a_t=a]$$

两者的关系是：$V^{\pi }(s)=\sum _a\pi (a\mid s)Q^{\pi }(s,a)$，即状态值是动作值在策略下的期望。

优势函数（Advantage Function） 度量某个动作相对于"平均水平"的好坏：

$$A^{\pi }(s,a)=Q^{\pi }(s,a)-V^{\pi }(s)$$

$A>0$ 表示该动作优于平均，$A<0$ 表示劣于平均。优势函数在 PPO、GRPO 等算法中扮演核心角色。

贝尔曼方程（Bellman Equation） 是值函数的递归表达，也是几乎所有 RL 算法的理论基石。将回报拆分为"即时奖励 + 折扣后的未来回报"：

$$G_t=r_t+\gamma G_{t+1}$$

对 $V^{\pi }$ 取期望，可以得到贝尔曼期望方程：

$$V^{\pi }(s)=\sum _a\pi (a\mid s)\sum _{s^{\prime }}P(s^{\prime }\mid s,a)[R(s,a,s^{\prime })+\gamma V^{\pi }(s^{\prime })]$$

该方程的深刻含义是：一个状态的价值等于"从该状态出发一步可获得的奖励"加上"下一状态价值的折扣期望"。这种递归结构使得我们可以通过迭代求解值函数，而不需要枚举所有可能的轨迹。

类似地，Q 函数的贝尔曼方程为：

$$Q^{\pi }(s,a)=\sum _{s^{\prime }}P(s^{\prime }\mid s,a)[R(s,a,s^{\prime })+\gamma \sum _{a^{\prime }}\pi (a^{\prime }\mid s^{\prime })Q^{\pi }(s^{\prime },a^{\prime })]$$

最优值函数对应最优策略 ${\pi }^{\ast }$：

$$V^{\ast }(s)=\underset{a}{max}{Q}^{\ast }(s,a),Q^{\ast }(s,a)=\sum _{s^{\prime }}P(s^{\prime }\mid s,a)[R(s,a,s^{\prime })+\gamma \underset{a^{\prime }}{max}{Q}^{\ast }(s^{\prime },a^{\prime })]$$

这就是贝尔曼最优性方程——$Q^{\ast }$ 是上述递推关系的不动点，Q-Learning 等算法正是通过迭代逼近这个不动点来求解最优策略。

下面用一个简单的 GridWorld 示例来演示值迭代的过程：

import numpy as np

def value_iteration(grid_size=4, gamma=0.99, theta=1e-6):
    """在一个简单 GridWorld 上演示值迭代算法。
    目标位置在右下角 (grid_size-1, grid_size-1)，到达后获得奖励 +1。
    其余位置每步奖励为 -0.04（鼓励尽快到达目标）。
    """
    n_states = grid_size * grid_size
    # 动作：上(0)、下(1)、左(2)、右(3)
    actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    goal = (grid_size - 1, grid_size - 1)

    V = np.zeros((grid_size, grid_size))

    for iteration in range(1000):
        delta = 0
        for r in range(grid_size):
            for c in range(grid_size):
                if (r, c) == goal:
                    continue  # 目标状态值固定为 0（已结束）
                old_v = V[r, c]
                # 对所有动作取 max（贝尔曼最优性方程）
                action_values = []
                for dr, dc in actions:
                    nr, nc = max(0, min(r + dr, grid_size - 1)), \
                             max(0, min(c + dc, grid_size - 1))
                    reward = 1.0 if (nr, nc) == goal else -0.04
                    action_values.append(reward + gamma * V[nr, nc])
                V[r, c] = max(action_values)
                delta = max(delta, abs(old_v - V[r, c]))
        if delta < theta:
            print(f"值迭代在第 {iteration + 1} 轮收敛")
            break

    # 提取最优策略
    policy = np.full((grid_size, grid_size), ' ')
    symbols = ['↑', '↓', '←', '→']
    for r in range(grid_size):
        for c in range(grid_size):
            if (r, c) == goal:
                policy[r, c] = '★'
                continue
            best_a = -1
            best_v = float('-inf')
            for i, (dr, dc) in enumerate(actions):
                nr = max(0, min(r + dr, grid_size - 1))
                nc = max(0, min(c + dc, grid_size - 1))
                reward = 1.0 if (nr, nc) == goal else -0.04
                v = reward + gamma * V[nr, nc]
                if v > best_v:
                    best_v = v
                    best_a = i
            policy[r, c] = symbols[best_a]

    print("\n最优值函数：")
    print(np.round(V, 2))
    print("\n最优策略：")
    for row in policy:
        print(' '.join(row))

value_iteration()

运行结果会显示值函数从目标位置向外衰减的梯度，以及指向目标的最优策略箭头——这正是贝尔曼方程递归结构的直观体现。

---

15.1.4 从 Q-Learning 到 REINFORCE

经典 RL 算法大致分为两条技术路线：基于值函数（Value-based）和基于策略梯度（Policy Gradient）。

Q-Learning：基于值函数的代表。 Q-Learning 是一种无模型（Model-free）、离策略（Off-policy）的算法，直接学习最优动作值函数 $Q^{\ast }$，无需知道环境转移概率 $P$。其核心更新规则为：

$$Q(s,a)\leftarrow Q(s,a)+\alpha [r+\gamma \underset{a^{\prime }}{max}Q(s^{\prime },a^{\prime })-Q(s,a)]$$

其中 $\alpha$ 是学习率，$r+\gamma \underset{a^{\prime }}{max}Q(s^{\prime },a^{\prime })$ 称为 TD 目标（Temporal Difference Target），$r+\gamma \underset{a^{\prime }}{max}Q(s^{\prime },a^{\prime })-Q(s,a)$ 称为 TD 误差。Q-Learning 的精髓在于：它使用一步采样代替了贝尔曼最优性方程中对所有下一状态的求和，使得学习无需完整的环境模型。

Q-Learning 的策略隐含在 Q 函数中：$\pi (s)=\arg \underset{a}{max}Q(s,a)$。为了保证探索，通常使用 $ϵ$-greedy 策略：以 $1-ϵ$ 的概率选择当前最优动作，以 $ϵ$ 的概率随机探索。

import numpy as np

def q_learning_demo(episodes=500, alpha=0.1, gamma=0.99, epsilon=0.1):
    """在 4x4 GridWorld 上演示 Q-Learning。"""
    grid_size = 4
    n_states = grid_size * grid_size
    n_actions = 4  # 上、下、左、右
    actions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    goal = (grid_size - 1, grid_size - 1)

    Q = np.zeros((n_states, n_actions))

    def state_to_idx(r, c):
        return r * grid_size + c

    def step(r, c, action_idx):
        dr, dc = actions[action_idx]
        nr = max(0, min(r + dr, grid_size - 1))
        nc = max(0, min(c + dc, grid_size - 1))
        reward = 1.0 if (nr, nc) == goal else -0.04
        done = (nr, nc) == goal
        return nr, nc, reward, done

    for ep in range(episodes):
        r, c = 0, 0  # 从左上角出发
        for _ in range(100):  # 每轮最多 100 步
            s = state_to_idx(r, c)
            # epsilon-greedy 选择动作
            if np.random.random() < epsilon:
                a = np.random.randint(n_actions)
            else:
                a = np.argmax(Q[s])

            nr, nc, reward, done = step(r, c, a)
            ns = state_to_idx(nr, nc)

            # Q-Learning 更新（核心）
            td_target = reward + gamma * np.max(Q[ns]) * (1 - done)
            Q[s, a] += alpha * (td_target - Q[s, a])

            r, c = nr, nc
            if done:
                break

    # 输出学到的最优策略
    symbols = ['↑', '↓', '←', '→']
    print("Q-Learning 学到的策略：")
    for r in range(grid_size):
        row = []
        for c in range(grid_size):
            if (r, c) == goal:
                row.append('★')
            else:
                row.append(symbols[np.argmax(Q[state_to_idx(r, c)])])
        print(' '.join(row))

q_learning_demo()

Q-Learning 的局限在于：它只能处理离散且低维的状态-动作空间。语言模型的动作空间是整个词汇表（数万到数十万），状态是变长的 token 序列——表格式 Q-Learning 完全不可行。虽然 DQN（Deep Q-Network）用神经网络替代 Q 表解决了部分问题，但对于 LLM 这种超大规模的策略空间，基于策略梯度的方法更为自然。

REINFORCE：策略梯度的起点。 REINFORCE 直接参数化策略 ${\pi }_{\theta }(a\mid s)$，通过梯度上升最大化期望回报。其核心思想是策略梯度定理：

$${\mathrm{\nabla }}_{\theta }J(\theta )={\mathbb{E}}_{\tau \sim {\pi }_{\theta }}[\sum _{t=0}^T{\mathrm{\nabla }}_{\theta }\log {\pi }_{\theta }(a_t\mid s_t)\cdot G_t]$$

其中 $G_t=\sum _{k=t}^T{\gamma }^{k-t}{r}_k$ 是从 $t$ 时刻起的实际回报。这个公式有一个优美的直觉：如果某个动作带来了高回报（$G_t$ 大），就增大该动作的概率；反之则减小。

策略梯度定理的推导基于一个关键恒等式 ${\mathrm{\nabla }}_{\theta }{\pi }_{\theta }(\tau )={\pi }_{\theta }(\tau ){\mathrm{\nabla }}_{\theta }\log {\pi }_{\theta }(\tau )$，展开后环境转移概率 $P(s_{t+1}\mid s_t,a_t)$ 关于 $\theta$ 的梯度为零（因为环境不依赖于策略参数），所以梯度仅涉及 ${\mathrm{\nabla }}_{\theta }\log {\pi }_{\theta }(a_t\mid s_t)$。

REINFORCE 的问题是方差极大：用完整轨迹的回报 $G_t$ 估计梯度，不同轨迹之间的回报波动会导致梯度估计噪声很高。减小方差的两个关键技巧是：

1. 引入基线（Baseline）：从回报中减去一个与动作无关的基线 $b(s)$，常取 $b(s)=V^{\pi }(s)$。数学上，$\mathbb{E}[{\mathrm{\nabla }}_{\theta }\log {\pi }_{\theta }\cdot b(s)]=0$，所以减基线不改变梯度期望，但显著降低方差。
2. 只关注未来（Reward-to-go）：$t$ 时刻的梯度只用 $t$ 之后的奖励，过去的奖励对当前决策没有因果影响。

当基线选为 $V^{\pi }(s)$ 时，$G_t-V^{\pi }(s_t)$ 就是优势函数 $A^{\pi }(s_t,a_t)$ 的蒙特卡洛估计。至此，策略梯度可以写为：

$${\mathrm{\nabla }}_{\theta }J(\theta )=\mathbb{E}[\sum _t{\mathrm{\nabla }}_{\theta }\log {\pi }_{\theta }(a_t\mid s_t)\cdot A^{\pi }(s_t,a_t)]$$

---

15.1.5 Actor-Critic 与 GAE

Actor-Critic 架构是 REINFORCE 的自然进化：用一个Actor 网络（策略 ${\pi }_{\theta }$）选动作，用一个Critic 网络（值函数 $V_{\varphi }$）估计基线。Critic 的存在使得优势函数不再需要完整的蒙特卡洛回报来估计，可以用 TD 误差替代：

$${\delta }_t=r_t+\gamma V_{\varphi }(s_{t+1})-V_{\varphi }(s_t)$$

${\delta }_t$ 本身就是优势函数的一步估计（$A_t^{(1)}={\delta }_t$），方差低但偏差高（依赖 $V_{\varphi }$ 的准确性）。而蒙特卡洛估计 $G_t-V_{\varphi }(s_t)$ 偏差低但方差高。广义优势估计（Generalized Advantage Estimation, GAE） 用一个参数 $\lambda \in [0,1]$ 在两者之间平滑插值：

$${\hat{A}}_t^{\text{GAE}}=\sum _{l=0}^{\mathrm{\infty }}(\gamma \lambda {)}^l{\delta }_{t+l}$$

• $\lambda =0$：${\hat{A}}_t={\delta }_t$，等价于单步 TD 误差，方差最低但偏差最高。
• $\lambda =1$：${\hat{A}}_t=\sum _{l=0}^{\mathrm{\infty }}{\gamma }^l{\delta }_{t+l}=G_t-V_{\varphi }(s_t)$，等价于蒙特卡洛估计，偏差最低但方差最高。
• 实际中常用 $\lambda =0.95$，兼顾偏差和方差。

GAE 的递归形式使其计算非常高效——从轨迹末尾向前递推：

$${\hat{A}}_t={\delta }_t+\gamma \lambda {\hat{A}}_{t+1}$$

import torch

def compute_gae(rewards, values, gamma=0.99, lam=0.95):
    """计算广义优势估计（GAE）。

    Args:
        rewards: 每步即时奖励, shape [T]
        values:  Critic 估计的状态值, shape [T+1]（含终止状态）
        gamma:   折扣因子
        lam:     GAE 平滑因子

    Returns:
        advantages: 每步优势估计, shape [T]
    """
    T = len(rewards)
    advantages = torch.zeros(T)
    last_gae = 0.0

    for t in reversed(range(T)):
        delta = rewards[t] + gamma * values[t + 1] - values[t]
        last_gae = delta + gamma * lam * last_gae
        advantages[t] = last_gae

    return advantages

# 示例
rewards = torch.tensor([0.0, 0.0, 0.0, 1.0])  # 最后一步获得奖励
values = torch.tensor([0.5, 0.6, 0.7, 0.9, 0.0])  # 含终止状态值=0
adv = compute_gae(rewards, values)
print(f"GAE 优势估计: {adv}")
# 结果中靠近终点的步骤优势较高，体现了 GAE 的信用分配能力

Actor-Critic + GAE 的组合正是 PPO 算法的基础——PPO 在此之上引入裁剪机制来保证策略更新的稳定性。

图 15-2：PPO-Clip 目标函数的直观解释。左图：当优势 $A>0$（好动作）时，概率比 $r$ 超过 $1+ϵ$ 后梯度被截断；右图：当 $A<0$（坏动作）时，$r$ 低于 $1-ϵ$ 后梯度被截断。这种"只截断有利方向"的设计防止了策略更新过大。

---

15.1.6 从古典 RL 到 LLM RL 的概念映射

将 RL 应用于大语言模型时，经典概念需要重新诠释：

经典 RL	LLM RL	说明
环境	用户 prompt + 评价系统	环境"给出" prompt 并评价 response
状态 $s_t$	已生成的 token 序列 $(x,y_{<t})$	prompt + 已生成的部分 response
动作 $a_t$	生成下一个 token $y_t$	动作空间 = 词汇表大小
策略 ${\pi }_{\theta }$	语言模型本身	${\pi }_{\theta }(y_t\mid x,y_{<t})$ 即 next-token 概率
奖励 $r$	Reward Model 打分 / 规则验证	通常只在序列末尾给出（稀疏奖励）
轨迹 $\tau$	完整的 response 序列	$(y_1,y_2,\dots ,y_T)$
回报 $G$	整句奖励 $R(x,y)$	多数情况下 $\gamma =1$

表 15-3：经典 RL 与 LLM RL 的概念映射。

LLM 场景下的 RLHF 流程涉及四个模型的协作：

图 15-3：InstructGPT 的 RLHF 三阶段流程。Step 1：用人类标注数据进行 SFT；Step 2：用人类偏好数据训练奖励模型；Step 3：用 PPO 优化策略模型，使其生成的回答最大化奖励模型的评分。

模型	作用	是否更新
策略模型（Actor, ${\pi }_{\theta }$）	生成回答	是
参考模型（Reference, ${\pi }_{\text{ref}}$）	KL 约束基准，防止偏离 SFT	否（冻结）
奖励模型（Reward Model）	对 (prompt, response) 打分	否（冻结）
价值模型（Critic, $V_{\varphi }$）	估计状态价值，用于 GAE	是（PPO 需要，GRPO 不需要）

表 15-4：RLHF 中的四个模型。

---

15.1.7 Token 级 vs 序列级：策略/价值/优势的粒度差异

LLM RL 中一个关键的设计选择是优化粒度——在 token 级还是序列级计算策略比率、价值和优势？这一选择直接影响算法的方差、稳定性和计算效率。

Token 级优化（PPO、GRPO）。 对每个生成的 token $y_t$ 分别计算概率比率和优势：

$$r_t(\theta )=\frac{{\pi }_{\theta }(y_t\mid x,y_{<t})}{{\pi }_{{\theta }_{\text{old}}}(y_t\mid x,y_{<t})}$$

• PPO：通过 Critic 网络 $V_{\varphi }$ 和 GAE 计算每个 token 的优势 ${\hat{A}}_t$，实现细粒度信用分配——知道"错在哪个 token"。
• GRPO：对同一 prompt 采样 $G$ 个完整回答，用组内奖励的均值和标准差做归一化，得到句子级优势 $A_i=(r_i-{\mu }_G)/({\sigma }_G+ϵ)$，然后将同一个 $A_i$ 共享给该回答的所有 token。

Token 级的优势在于粒度细，但也引入了更高的方差——每个 token 的概率比率 $r_t$ 独立计算，它们的乘积可能产生极端值。

序列级优化（GSPO、DPO）。 将整个序列视为一个"动作"，计算序列级的概率比率：

$$s_i(\theta )={\left(\frac{{\pi }_{\theta }(y_i\mid x)}{{\pi }_{{\theta }_{\text{old}}}(y_i\mid x)}\right)}^{1/|y_i|}$$

序列级方法的优势是方差低，因为 $s_i$ 是一个标量而非 $|y_i|$ 个独立的 $r_t$。劣势是信用分配粗糙——只知道整句好不好，不知道好在哪里。

DPO 则更进一步，完全绕过了 RL 循环：它直接从偏好数据 $(x,y_w,y_l)$ 出发，用分类式损失优化策略，使得"好回答"的隐式奖励高于"坏回答"。

下表总结了不同算法在优化粒度上的差异：

算法	优化粒度	是否需要 Critic	优势来源	方差特征
PPO	token 级	需要	GAE（Critic + TD）	中等
GRPO	token 级（句子级优势共享）	不需要	组内归一化奖励	较高
GSPO	序列级	不需要	组内归一化奖励	较低
DPO	偏好对（序列级）	不需要	隐式奖励差	低

表 15-5：主要 LLM RL 算法在优化粒度上的对比。

图 15-4：PPO 与 GRPO 的架构对比。PPO 需要策略模型、参考模型、奖励模型和价值模型四个模型协同工作；GRPO 通过对同一 prompt 采样多个回答并在组内计算相对优势，完全去掉了价值模型，将显存占用减少近一半。

---

15.1.8 RL 算法族谱与 LLM 对齐的演进

从经典 RL 到 LLM 对齐，算法的演进可以概括为以下谱系：

古典 RL
├── 基于值函数
│   ├── Q-Learning (表格式, 离策略, TD 更新)
│   └── DQN (深度 Q 网络, 离散动作空间)
│
└── 基于策略梯度
    ├── REINFORCE (蒙特卡洛, 高方差)
    ├── Actor-Critic (引入 Critic 降方差)
    │   ├── A2C / A3C (同步/异步 Actor-Critic)
    │   ├── TRPO (信赖域约束, 二阶优化)
    │   └── PPO (裁剪替代 KL 约束, 一阶优化)
    │       ├── PPO + RLHF (InstructGPT, ChatGPT)
    │       ├── VAPO (价值增强, 推理专用)
    │       └── GRPO (去 Critic, 组相对优势)
    │           ├── DAPO (非对称 clip, 动态采样)
    │           ├── GSPO (序列级, 低方差)
    │           └── Dr.GRPO (修正长度偏差)
    │
    └── 偏好优化 (独立分支)
        └── DPO (无 RM, 无 RL 循环, Bradley-Terry)

图 15-5：RL 算法族谱——从古典 RL 到 LLM 对齐。

图 15-6：大模型后训练技术的历史演进。从 SFT 到 RLHF 框架确立，再到 DPO/GRPO 等更高效的替代方案，后训练技术始终在稳定性、效率和效果之间寻找平衡。

这条演进路线的核心脉络是：

1. 从无模型到有模型再到无模型：Q-Learning 不需要环境模型但需要 Q 表 → DQN 用网络替代 → 策略梯度直接优化策略。
2. 从高方差到低方差：REINFORCE 方差极大 → Actor-Critic 用 Critic 做基线 → GAE 平衡偏差-方差 → PPO Clip 进一步稳定。
3. 从通用 RL 到 LLM 特化：PPO + RLHF 首次将 RL 用于 LLM 对齐 → GRPO 利用"同 prompt 多采样"的 LLM 特有结构去掉 Critic → DPO 完全绕过 RL。
4. 从精确到实用：理论上 PPO + GAE 的 token 级优势最精细，但实践中 GRPO 的句子级共享优势已足够有效，而 DPO 甚至不需要在线采样。

---

15.1.9 本节小结

本节从 RL 的基本范式出发，建立了以下核心概念链：

• MDP 五元组为 RL 问题提供了数学框架，马尔可夫性使递归求解成为可能。
• 值函数与贝尔曼方程是几乎所有 RL 算法的理论基石——Q-Learning 通过 TD 更新逼近 $Q^{\ast }$ 的不动点，值迭代通过动态规划直接求解。
• 策略梯度定理开辟了直接优化策略的道路，REINFORCE 是其最朴素的实现，Actor-Critic 和 GAE 通过引入 Critic 基线大幅降低了方差。
• 将这些概念映射到 LLM 场景：状态是已生成的 token 序列，动作是下一个 token，策略就是语言模型本身。RLHF 的四模型架构（Actor, Critic, Reward, Reference）正是 Actor-Critic 在 LLM 中的实例化。
• Token 级与序列级的优化粒度选择是 LLM RL 算法设计的核心权衡：粒度越细，信用分配越精确但方差越高；粒度越粗，方差越低但信号越模糊。

掌握了这些基础之后，下一节将深入 PPO 在 LLM 中的具体实现细节——包括如何计算 token 级的 KL 惩罚奖励、如何设计裁剪目标函数、以及 PPO 训练的工程挑战。