Lecture 9 · 函数逼近与策略梯度

CS221: Artificial Intelligence — Principles and Techniques · Stanford · Autumn 2025
📅 Oct 20 · 💻 policy_gradient.py

---

从表格法到函数逼近

上一讲（Lecture 8 · 强化学习）：

• 环境是未知的 MDP，转移概率与奖励都摸不到，只能通过「行动 → 观察反馈」的交互来学习。
• 学了四大算法：Model-Based Monte Carlo、Model-Free Monte Carlo、SARSA、Q-Learning。
• 它们有一个共同前提：为每一个 $(s, a)$ 对单独存一个 Q 值——这叫表格法（tabular method）。

本讲（MDPs III）：

• 表格法的死穴：当状态是图像、句子这类高维对象时，状态空间大到无法枚举，「一格一值」既存不下也学不完。
• 函数逼近（function approximation）：用带参数 $\theta$ 的函数 $Q_\theta(s, a)$ 代替查找表，让相似状态共享参数、互相泛化。
• 退一步看全景，学习最优行为有三条路：model-based / value-based / policy-based 三大范式。
• 策略梯度（policy gradient）/ REINFORCE：跳过 Q 值这个中间量，直接参数化并优化策略 $\pi_\theta(a \mid s)$。

一句话主线：把强化学习装进「假设类 / 损失函数 / 优化算法」这个机器学习框架（Lecture 2 · 线性回归 以来反复出现的三件套），最后干脆绕过所有中间量，直接对策略做梯度上升。

---

1. 回顾：表格法的边界

1.1 强化学习的统一形式

上一讲的三个 model-free 算法（Monte Carlo、SARSA、Q-Learning）表面上各有一套流程，其实共享同一套骨架：

• 维护当前估计 $\hat{Q}(s, a)$；
• 每看到一条经验，构造一个目标（target）——对「从这里出发未来能拿多少」的一次估计；
• 朝目标方向挪一小步：

$$\hat{Q}(s, a) \leftarrow \hat{Q}(s, a) + \alpha \left[\text{target} - \hat{Q}(s, a)\right]$$

其中 $\alpha$ 是学习率（步长），$\text{target} - \hat{Q}(s,a)$ 是「预测误差」：目标比当前估计高就上调，低就下调。三个算法的区别只在目标怎么算，以及用哪个策略产生数据：

算法	on/off-policy	target（估计效用的方式）
Model-Free Monte Carlo	on-policy，估计 $Q_\pi$	$u_t$：完整 rollout 从 $t$ 时刻起的折扣奖励和（不自举）
SARSA	on-policy，估计 $Q_\pi$	$r + \gamma \hat{Q}(s', a')$，其中 $a'$ 是实际执行的下一动作（自举）
Q-Learning	off-policy，估计 $Q^*$	$r + \gamma \max_{a'} \hat{Q}(s', a')$（自举）

1.2 一次交互长什么样

源码里先用上一讲的 QLearning 在不可靠电车 MDP（FlakyTramMDP，见 Lecture 7 · 马尔可夫决策过程）上跑一段，让我们看清「智能体眼中的世界」——它看不到转移概率，每一步只拿到五元组 $(s, a, r, s', \text{is\_end})$：

from mdp import FlakyTramMDP, value_iteration
from reinforcement_learning import QLearning, walk_tram_policy, simulate

mdp = FlakyTramMDP(num_locs=6, failure_prob=0.1)
policy = partial(walk_tram_policy, mdp.num_locs)
rl = QLearning(exploration_policy=policy, epsilon=0.4, discount=1, learning_rate=0.1)

# 一次交互（智能体只看到 s, a, r, s', is_end）
action = rl.get_action(state=1)
rl.incorporate_feedback(state=1, action="walk", reward=-1, next_state=2, is_end=False)
rl.incorporate_feedback(state=2, action="walk", reward=-1, next_state=3, is_end=False)
rl.incorporate_feedback(state=3, action="tram", reward=-2, next_state=6, is_end=True)

# 多次 rollout，价值就是平均效用
value = simulate(mdp, rl, num_trials=100)  # @inspect value

每条 rollout $\tau$ 产生一个效用（utility）——折扣奖励之和 $u(\tau) = r_1 + \gamma r_2 + \gamma^2 r_3 + \cdots$；跑很多条 rollout 取平均，就是这套「探索 + 学习」流程实际拿到的价值。

1.3 状态空间爆炸

表格法要求「每个 $(s, a)$ 一个格子」。电车 MDP 只有几个位置，当然没问题；可现实任务里的状态往往是：

• 一张图像：学习机器人操作策略时，状态就是摄像头此刻的画面；
• 一句话：做定理证明时，状态是当前推导到的数学命题文本。

出路：不再逐格记忆，而是学一个函数——把「这个状态见过没有」换成「这个状态和见过的状态像不像」，让相似的状态共享参数、互相泛化。

graph LR
    T["表格法 Tabular<br/>每个 (s,a) 一个格子"] -->|状态是图像/句子| X["存不下<br/>访问不全"]
    T -->|泛化| F["函数逼近<br/>Q_θ(s,a)"]
    F --> G["相似状态<br/>共享参数、互相泛化"]

    style T fill:#ffcdd2,stroke:#c62828
    style X fill:#ffcdd2,stroke:#c62828
    style F fill:#c8e6c9,stroke:#2e7d32
    style G fill:#e1f5fe,stroke:#0277bd

---

2. 函数逼近（Function Approximation）

2.1 三大设计问题（呼应机器学习）

把 Q 值从「查找表」换成「带参数 $\theta$ 的函数」$Q_\theta(s, a)$，立刻回到机器学习那三个老问题：

graph TD
    Q["Q_θ(s, a)"] --> H["1. 假设类<br/>Q_θ 能是哪些函数?"]
    Q --> L["2. 损失函数<br/>怎么判断 Q_θ 好不好?"]
    Q --> O["3. 优化算法<br/>怎么降低损失?"]

    style Q fill:#ffe0b2,stroke:#e65100
    style H fill:#e1f5fe,stroke:#0277bd
    style L fill:#f3e5f5,stroke:#7b1fa2
    style O fill:#c8e6c9,stroke:#2e7d32

2.2 假设类：特征 + 线性 / MLP

第一步：把状态和动作映射成一个特征向量（feature vector） $\phi(s, a) \in \mathbb{R}^d$。
第二步：在特征上套一个函数：

• 线性函数：$Q_\theta(s, a) = \phi(s, a) \cdot \theta$，参数 $\theta \in \mathbb{R}^d$ 就是权重向量；
• 多层感知机（MLP）：$Q_\theta(s, a) = \text{MLP}_\theta(\phi(s, a))$，表达力更强，可以刻画特征间的非线性交互。

对电车 MDP，源码用最简单的 one-hot 特征（等价于退化回表格，但走的是「函数逼近」的机器）：把 $(s, a)$ 编号成一个整数，再变成长度 $|\mathcal{S}| \cdot |\mathcal{A}|$ 的 one-hot 向量。

def phi(self, state: int, action: str) -> torch.Tensor:
    # (state, action) → 整数索引 0 ... |states|*|actions|-1
    index = (state - 1) * len(self.actions) + self.actions.index(action)
    # 长度 num_features 的 one-hot 向量
    vector = one_hot(index, self.num_features)
    return vector

2.3 损失与优化：带梯度的 Q-Learning

把 Q 值算出来，再和目标比：

• 目标（自举，同 Q-Learning）：

$$\text{target} = r + \gamma \max_{a'} Q_\theta(s', a') \qquad (\text{终止时 } \text{target} = r)$$

• 损失（标准平方损失）：

$$\mathcal{L}(\theta) = \left(Q_\theta(s, a) - \text{target}\right)^2$$

• 优化：对 $\theta$ 求梯度，走一步 SGD。

这就是把上一讲 Q-Learning 的「更新一行」推广成了「对参数求梯度」：表格法里 $\hat Q(s,a) \leftarrow \hat Q(s,a) + \alpha(\text{target} - \hat Q(s,a))$ 恰好是这个平方损失在 one-hot 特征下的 SGD 步——两者严格等价。完整实现（忠于源码 ParameterizedQLearning）：

class ParameterizedQLearning(RLAlgorithm):
    def __init__(self, num_locs, actions, exploration_policy,
                 epsilon, discount, learning_rate):
        self.actions = actions
        self.num_features = num_locs * len(actions)
        self.exploration_policy = exploration_policy
        self.epsilon = epsilon
        self.discount = discount
        # 线性假设类：φ(s,a) → 一个标量 Q 值
        self.model = nn.Linear(self.num_features, 1)
        self.optimizer = torch.optim.SGD(self.model.parameters(), lr=learning_rate)

    def Q(self, state, action):
        """Q_θ(s, a) = model(φ(s, a))"""
        phi = self.phi(state, action)
        return self.model(phi)

    def pi(self, state):
        """π(s) = argmax_a Q_θ(s, a)"""
        q_values = {a: self.Q(state, a) for a in self.actions}
        return max(q_values.keys(), key=lambda k: q_values[k].item())

    def get_action(self, state):
        # ε-贪婪
        if torch.rand(1).item() < self.epsilon:
            return self.exploration_policy(state)   # 探索
        else:
            return self.pi(state)                   # 利用

    def incorporate_feedback(self, state, action, reward, next_state, is_end):
        # 1) 构造目标（自举）
        if is_end:
            target = reward
        else:
            next_action = self.pi(next_state)
            target = reward + self.discount * self.Q(next_state, next_action)

        # 2) 预测值 + 平方损失
        value = self.Q(state, action)
        loss = (value - target) ** 2

        # 3) 梯度步更新参数
        self.optimizer.zero_grad()
        loss.backward()          # 反向传播算梯度
        self.optimizer.step()    # 更新 θ

2.4 跑起来 & 与真值对照

用参数化 Q-Learning 跑多条 rollout，再和「直接解 MDP」（Lecture 7 · 马尔可夫决策过程 的价值迭代）算出的真值比：

rl = ParameterizedQLearning(num_locs=mdp.num_locs, actions=["walk", "tram"],
        exploration_policy=policy, epsilon=0.4, discount=1, learning_rate=0.1)

value = simulate(mdp, rl, num_trials=100)          # 跑 100 条 rollout

# 抽取当前最优策略与对应价值
states = range(1, mdp.num_locs + 1)
pi = {s: rl.pi(s) for s in states}                 # π_θ(s)
V  = {s: rl.Q(s, pi[s]) for s in states}           # V_θ(s) = Q_θ(s, π_θ(s))

# 与真值对照
result = value_iteration(mdp)                       # result.values, result.pi
# 结论：数量级对得上，被访问越多的状态越准

小结（函数逼近）：

• 用 $\theta$ 参数化 $Q_\theta(s, a)$，代替「一格一值」的查找表；
• 把状态、动作映射成特征 $\phi(s, a)$，让相似的 $(s,a)$ 特征相近；
• 用线性函数或 MLP 完成 $\phi(s, a) \to Q_\theta(s, a)$；
• 定义 $Q_\theta(s, a)$ 与自举目标 $r + \gamma \max_{a'} Q_\theta(s', a')$ 之间的平方损失；
• 每条经验做一步 SGD——表格 Q-Learning 是它在 one-hot 特征下的特例。

---

3. 三大范式：To Model or Not to Model？

到目前为止，我们要么估计 MDP（model-based），要么估计 Q 值（value-based）。退一步看，学习最优行为其实有三条路：

flowchart LR
    subgraph MB["Model-Based"]
        M1["估计 MDP<br/>T̂, R̂"] --> M2["价值迭代"] --> M3["策略 π(s)"]
    end
    subgraph VB["Value-Based"]
        V1["估计 Q 值<br/>Q(s,a)"] --> V2["argmax_a"] --> V3["策略 π(s)"]
    end
    subgraph PB["Policy-Based"]
        P1["直接估计策略<br/>π_θ(a∣s)"] --> P3["策略 π(s)"]
    end

    style M1 fill:#ffe0b2,stroke:#e65100
    style V1 fill:#e1f5fe,stroke:#0277bd
    style P1 fill:#c8e6c9,stroke:#2e7d32
    style M3 fill:#f3e5f5,stroke:#7b1fa2
    style V3 fill:#f3e5f5,stroke:#7b1fa2
    style P3 fill:#f3e5f5,stroke:#7b1fa2

范式	估计什么	得到策略的方式	代表算法	直觉
Model-based	MDP 的 $T$、$R$	对估计的 MDP 跑价值迭代	Model-Based VI	先把世界摸清楚，再规划
Value-based	Q 值 $Q(s,a)$	$\pi(s) = \arg\max_a Q(s,a)$	SARSA、Q-Learning	不建模世界，只学「每步值多少」
Policy-based	策略 $\pi_\theta(a \mid s)$	直接就是策略	REINFORCE	跳过中间量，直接学「怎么做」

为什么要直接估计策略？ 把策略看成一个分类器：输入状态 $s$，输出动作 $a$——这不就是 Lecture 3 · 线性分类 吗？但硬分类器的 $\arg\max$ 不可导，没法做梯度优化，所以我们优化一个概率分类器 $\pi_\theta(a \mid s)$：给每个动作一个概率，既可导、又自带探索。这正是策略梯度的起点。

---

4. 从模仿学习到策略梯度

4.1 模仿学习（Imitation Learning）：有示范就好办

假如有人给我们示范了好策略——一条专家 rollout $\tau$：

rollout = Rollout(steps=[
    Step(action="walk", prob=1, reward=-1, state=2),
    Step(action="walk", prob=1, reward=-1, state=3),
    Step(action="tram", prob=1, reward=-2, state=6),
], discount=1)

那就把它拆成监督学习样本「状态 → 动作」，当分类问题训练：

examples = [
    Example(input=1, output="walk"),
    Example(input=2, output="walk"),
    Example(input=3, output="tram"),
]
# 目标：J(θ) = Σ_t log π_θ(a_t | s_{t-1})   （最大化示范动作的对数似然）

目标函数即示范动作的对数似然：

$$J(\theta) = \sum_{t} \log \pi_\theta(a_t \mid s_{t-1})$$

最大化它就是让策略在专家到过的每个状态里，尽量复现专家的选择。这就是模仿学习（imitation learning），也叫行为克隆（behavior cloning）。现实例子：机器人遥操作（teleoperation）示范、数学题的人类书写解答——大语言模型的 SFT（监督微调）本质上就是对人类示范的行为克隆（见 Lecture 15 · 对齐 I：SFT 与 RLHF（未找到对应页面））。

4.2 策略梯度定理

思路：既然没示范，就用自己的策略采样 rollout，按效用给它们加权——好的 rollout 多学一点、差的少学一点（甚至反着学）。

一条 rollout 的概率。设 $\tau = (s_0, a_1, r_1, s_1, a_2, r_2, s_2, \ldots)$，它被采出来的概率是一连串因子的乘积：

$$p_\theta(\tau) = p(s_0) \cdot \pi_\theta(a_1 \mid s_0) \cdot T(s_0, a_1, s_1) \cdot \pi_\theta(a_2 \mid s_1) \cdot T(s_1, a_2, s_2) \cdots$$

• $p(s_0)$：初始状态分布，环境给定；
• $\pi_\theta(a_t \mid s_{t-1})$：策略——整条链里唯一含 $\theta$ 的部分；
• $T(s_{t-1}, a_t, s_t)$：转移分布，不含 $\theta$，环境说了算。

目标：最大化期望效用（$u(\tau)$ 表示 rollout 的折扣奖励和）：

$$V(\theta) = \mathbb{E}_{\tau \sim p_\theta}[u(\tau)] = \sum_\tau p_\theta(\tau)\, u(\tau)$$

直接对 $V(\theta)$ 求梯度。关键一步是对数导数技巧（log-derivative trick）：由 $\nabla \log p = \nabla p / p$ 得 $\nabla p = p\, \nabla \log p$，把「概率的梯度」改写成「概率 × 对数概率的梯度」：

$$ \begin{aligned} \nabla_\theta V(\theta) &= \nabla_\theta \sum_\tau p_\theta(\tau)\, u(\tau) \\ &= \sum_\tau \nabla_\theta\, p_\theta(\tau)\, u(\tau) \\ &= \sum_\tau p_\theta(\tau)\, \nabla_\theta \log p_\theta(\tau)\, u(\tau) \\ &= \mathbb{E}_{\tau \sim p_\theta}\!\left[\nabla_\theta \log p_\theta(\tau) \cdot u(\tau)\right] \end{aligned} $$

这就是策略梯度定理（policy gradient theorem）。逐符号读：$u(\tau)$ 给整条轨迹打分，$\nabla_\theta \log p_\theta(\tau)$ 指向「让这条轨迹更可能出现」的参数方向，两者相乘再取期望——让高分轨迹变得更可能，低分轨迹变得更不可能。

4.3 REINFORCE：把 T 消掉

对 $\log p_\theta(\tau)$ 做分解（乘积取对数变求和）：

$$\log p_\theta(\tau) = \log p(s_0) + \sum_{t \ge 1} \log \pi_\theta(a_t \mid s_{t-1}) + \sum_{t \ge 1} \log T(s_{t-1}, a_t, s_t)$$

对 $\theta$ 求梯度时，$p(s_0)$ 和 $T(\cdot)$ 都不含 $\theta$，梯度为 0，整段直接消失！于是单条 rollout 的梯度估计是：

$$\nabla_\theta J(\theta; \tau) = u(\tau) \cdot \sum_{t \ge 1} \nabla_\theta \log \pi_\theta(a_t \mid s_{t-1})$$

这就是 REINFORCE 算法（Williams, 1992）——完全不需要知道转移概率 $T$，也不用建模它：环境的随机性在「采样 rollout」这一步已经被自然地体现了。

graph LR
    R["采样 rollout 𝜏<br/>~ 自己的策略 π_θ"] --> U["算 utility(𝜏)"]
    U --> W["按 utility 加权<br/>对 (s,a) 做模仿学习"]
    W --> G["∇_θ J = utility · Σ ∇log π_θ(a∣s)"]
    G --> S["梯度上升更新 θ"]
    S -.下一条 rollout.-> R

    style R fill:#e1f5fe,stroke:#0277bd
    style U fill:#ffe0b2,stroke:#e65100
    style W fill:#f3e5f5,stroke:#7b1fa2
    style G fill:#fce4ec,stroke:#c2185b
    style S fill:#c8e6c9,stroke:#2e7d32

小结（策略梯度）：

• 目标：直接优化策略参数，最大化期望效用 $V(\theta) = \mathbb{E}_\theta[u(\tau)]$；
• 靠对数导数技巧，把梯度写成期望，从而可以用采样得到无偏梯度估计；
• 转移概率 $T$ 在求梯度时消失——不需要环境模型；
• 算法：采一条 rollout（on-policy），用其中每个 $(s, a)$ 做「按 $u(\tau)$ 加权的模仿学习」。

---

5. REINFORCE 实现

5.1 策略参数化：softmax 概率策略

策略 $\pi_\theta(a \mid s)$ 用一个线性层 + softmax 实现——和 Lecture 3 · 线性分类 的多类逻辑回归一模一样：

$$\pi_\theta(a \mid s) = \operatorname{softmax}\big(W \phi(s)\big)_a = \frac{\exp(w_a \cdot \phi(s))}{\sum_{a'} \exp(w_{a'} \cdot \phi(s))}$$

其中 $\phi(s)$ 是状态特征（这里是 one-hot），$W$ 的每一行 $w_a$ 是动作 $a$ 的打分权重，softmax 把打分（logits）归一化成合法概率分布（Reinforce 类，忠于源码）：

class Reinforce(RLAlgorithm):
    def __init__(self, num_locs, actions, discount, learning_rate):
        self.actions = actions
        self.discount = discount
        # φ(s) 是长度 num_locs 的 one-hot；输出每个动作的 logit
        self.model = nn.Linear(num_locs, len(actions))
        self.optimizer = torch.optim.SGD(self.model.parameters(), lr=learning_rate)
        # 记录当前 rollout（像 Monte Carlo 那样攒完一整条再更新）
        self.start_state = None
        self.rollout = []
        self.utility = 0

    def phi(self, state):
        return one_hot(state - 1, self.num_locs)

    def pi(self, state):
        """返回动作上的分布 π_θ(·|s)"""
        logits = self.model(self.phi(state))
        probs = torch.softmax(logits, dim=0)
        return dict(zip(self.actions, probs.tolist()))

5.2 get_action：从策略里采样

注意——不需要显式的探索策略，因为随机策略本身就带来探索：

    def get_action(self, state):
        """从 π_θ(a|s) 采样一个动作"""
        logits = self.model(self.phi(state))
        probs = torch.softmax(logits, dim=0)
        index = torch.multinomial(probs, num_samples=1).item()  # 按概率采样
        return self.actions[index]

5.3 incorporate_feedback：攒完一条 rollout 再更新

和 Model-Free Monte Carlo 一样，要等回合结束才更新——因为权重 $u(\tau)$ 需要完整轨迹才能算出来。损失用交叉熵实现「按效用加权的模仿学习」：

    def incorporate_feedback(self, state, action, reward, next_state, is_end):
        # 记录 rollout，累计效用
        if self.start_state is None:
            self.start_state = state
        self.utility += reward * self.discount ** len(self.rollout)
        self.rollout.append(Step(action=action, prob=1, reward=reward, state=next_state))

        if is_end:
            loss = 0
            for i, step in enumerate(self.rollout):
                state = self.start_state if i == 0 else self.rollout[i - 1].state
                action = step.action

                # 对 state -> action 算交叉熵损失
                logits = self.model(self.phi(state))
                cross_entropy = nn.CrossEntropyLoss()
                target = one_hot(self.actions.index(action), len(self.actions))
                # 关键：整条 rollout 的效用作为权重
                loss += self.utility * cross_entropy(logits, target)

            # 一步梯度更新
            self.optimizer.zero_grad()
            loss.backward()
            self.optimizer.step()

            # 重置 rollout
            self.start_state = None
            self.rollout = []
            self.utility = 0

小结（实现）：

• get_action：从 $\pi_\theta(a \mid s)$ 采样，探索内置于随机策略；
• incorporate_feedback：攒完整条 rollout，用其中的 $(s, a)$ 对做按 $u(\tau)$ 加权的交叉熵更新。

---

6. 增强：降低方差

REINFORCE 给出的是 $\nabla_\theta V(\theta)$ 的无偏估计，但方差很大：单条 rollout 的效用受随机策略和随机转移双重扰动，抖动剧烈，导致梯度方向忽东忽西、学习又慢又不稳。能不能估得更好？

6.1 偏差-方差：先看均值估计小实验

源码用一个「估计均值 $\mu = \mathbb{E}[f(i)] = \sum_i p(i) f(i)$」的小玩具，讲清评价估计器的三要素：偏差（bias）/ 方差（variance）/ 成本（cost）：

估计器	做法	偏差	方差	成本
estimator1	采 1 个点返回 $f(i)$	无偏	高	低
estimator2	采 2 个点取平均	无偏	更低	更高（2 次采样）
estimator3	采 1 个点再加噪声	无偏	更高（更糟）	低
estimator4	减去一个均值为 0 的 $\text{offset}(i)$	无偏	更低	低

def estimator4():
    offsets = torch.tensor([-6., -6., 6., 6.])   # 一个「魔法」偏移，均值为 0
    index = torch.multinomial(probs, num_samples=1)
    estimate = points[index] - offsets[index]     # E[f - offset] = E[f]
    return estimate

6.2 基线（Baseline）：那个「offset」怎么找？

关键恒等式：设 $b(s)$ 是只依赖状态 $s$、不依赖动作 $a$ 的任意函数，则对每个状态 $s$：

$$\mathbb{E}_{a \sim \pi_\theta(\cdot \mid s)}\left[\nabla_\theta \log \pi_\theta(a \mid s) \cdot b(s)\right] = 0$$

证明（把策略梯度定理的推导反着走一遍，核心是「概率归一化为常数 1」）：

$$ \begin{aligned} \sum_a \pi_\theta(a \mid s) &= 1 \quad (\text{常数}) \\ \Rightarrow\ \nabla_\theta \sum_a \pi_\theta(a \mid s) \, b(s) &= 0 \\ \Rightarrow\ \sum_a \nabla_\theta\, \pi_\theta(a \mid s) \, b(s) &= 0 \\ \Rightarrow\ \sum_a \pi_\theta(a \mid s)\, \nabla_\theta \log \pi_\theta(a \mid s)\, b(s) &= 0 \\ \Rightarrow\ \mathbb{E}_{a \sim \pi_\theta}\left[\nabla_\theta \log \pi_\theta(a \mid s) \cdot b(s)\right] &= 0 \end{aligned} $$

第三行到第四行再次用了对数导数技巧 $\nabla \pi = \pi \nabla \log \pi$。注意 $b(s)$ 能提出来全靠它不依赖 $a$——若 $b$ 依赖动作，就不能从对 $a$ 的求和中拿出，恒等式立刻失效。

6.3 三种降方差增强

增强	目标函数中第 $t$ 步的权重	偏差	方差
1. 基线（baseline）	$u(\tau) - b(s_{t-1})$	无偏	↓
2. 回报到底（returns-to-go）	$\left(r_t + \gamma r_{t+1} + \gamma^2 r_{t+2} + \cdots\right) - b(s_{t-1})$	无偏	↓↓
3. 自举（bootstrapping）	$Q(s_{t-1}, a_t) - b(s_{t-1})$	有偏	↓↓↓

• 基线：从效用里减去 $b(s)$——最常用的选择是状态价值估计 $b(s) \approx V(s)$，只保留「比平均好多少」的信号；
• 回报到底：第 $t$ 步的动作只能影响它之后的奖励，之前的奖励与它无关（因果性）——那部分在期望下同样是零，却白白贡献方差。用「从 $t$ 起的未来回报」替换全局效用 $u(\tau)$，等于把每一步与它无关的噪声砍掉，仍然无偏；
• 自举：干脆用（学出来的、有偏的）价值函数 $Q(s, a)$ 替代采样回报——不再依赖整条轨迹的随机性，方差最小，但价值函数估不准的误差会系统性地带进梯度（有偏）。这一步把 policy-based 和 value-based 缝在一起：策略是 actor（演员），价值函数是 critic（评论家）——这就是 actor-critic 方法的雏形。

小结（增强）：

• 这场游戏的目标：为 $\mathbb{E}_\theta[\nabla_\theta \log p_\theta(\tau) \cdot u(\tau)]$ 找一个低偏差、低方差、低成本的估计；
• 基线：减去只依赖状态的 $b(s)$，通用的降方差手段，仍然无偏；
• 回报到底：利用因果性砍掉与当前动作无关的过去奖励，仍然无偏；
• 自举：用价值函数替代采样回报，方差最低但引入偏差——通往 actor-critic。

---

7. 算法的通用形式

回到最高层，本讲所有方法（连同上一讲）都能塞进同一个三步模板：

flowchart TD
    A["1. 用探索策略<br/>产生 rollout"] --> B["2. 构造损失函数"]
    B --> C["3. 梯度步更新参数"]
    C -.循环.-> A

    B --> B1["MDP 参数<br/>→ model-based"]
    B --> B2["Q 值<br/>→ value-based"]
    B --> B3["策略<br/>→ policy-based"]

    style A fill:#e1f5fe,stroke:#0277bd
    style B fill:#ffe0b2,stroke:#e65100
    style C fill:#c8e6c9,stroke:#2e7d32
    style B1 fill:#f3e5f5,stroke:#7b1fa2
    style B2 fill:#f3e5f5,stroke:#7b1fa2
    style B3 fill:#f3e5f5,stroke:#7b1fa2

1. 用探索策略产生 rollout——数据从交互中来（ε-贪婪外挂探索，或随机策略内置探索）；
2. 构造某个损失函数——损失针对谁，就落入哪个范式：MDP 参数（model-based）/ Q 值（value-based）/ 策略（policy-based）；
3. 用梯度步更新参数——SGD 一小步，回到第 1 步继续交互。

---

8. 总结

mindmap
  root((函数逼近与策略梯度))
    表格法的局限
      每个 s,a 对存一个 Q 值
      状态是图像或句子时失效
      存不下、也访问不全
    函数逼近
      带参数 θ 的 Q 函数
      特征 φ 加 线性或MLP
      平方损失 加 SGD
      泛化：状态间共享参数
    三大范式
      model-based 估计 MDP
      value-based 估计 Q 值
      policy-based 估计策略
    策略梯度 REINFORCE
      直接参数化随机策略
      策略梯度定理 无偏
      utility 加权的模仿学习
      转移 T 被消掉
    降方差
      偏差 方差 成本
      基线 b 仍无偏
      returns-to-go 因果性
      自举 有偏但方差小
      通往 actor-critic

关键要点：

• 表格法为每个 $(s,a)$ 存一个 Q 值，状态空间巨大（图像、句子）时既存不下也无法泛化，彻底失效。
• 函数逼近：用 $Q_\theta(s,a) = \phi(s,a) \cdot \theta$（或 MLP）代替查找表，落回「假设类 / 损失 / 优化」框架——把 RL 翻译成监督学习，标签由算法自己构造。
• 带梯度的 Q-Learning：目标 $r + \gamma \max_{a'} Q_\theta(s',a')$，平方损失，对 $\theta$ 做 SGD；表格 Q-Learning 是其 one-hot 特例。注意半梯度与「致命三要素」的收敛陷阱。
• 三大范式：model-based（估计 MDP）、value-based（估计 Q 值）、policy-based（估计策略）——越往后中间量越少、越直接。
• REINFORCE：直接参数化 $\pi_\theta(a \mid s)$（softmax 分类器），靠策略梯度定理得到无偏梯度 $u(\tau) \sum_t \nabla_\theta \log \pi_\theta(a_t \mid s_{t-1})$；本质是「对自己策略、按效用加权的模仿学习」，且消去了转移 $T$；随机策略自带探索，但严格 on-policy。
• 降方差：基线 $b(s)$（控制变量，无偏）、returns-to-go（因果性，无偏）、自举（有偏但方差最小，通往 actor-critic）——都在给梯度估计找一个「期望为 0 的 offset」。
• 通用形式：① 产生 rollout ② 构造损失（MDP / Q / 策略）③ 梯度步；核心永远是最大化期望效用。

下一讲预告：到目前为止环境都是「中立」的 MDP——它按固定的 $T$ 随机反应，不跟你作对。可如果环境里有对手、有人主动跟你唱反调呢？期望效用最大化就得换成「最坏情况下的最优」→ Lecture 10 · 博弈 I：Minimax 与 α-β 剪枝：两人零和博弈、minimax 与 α-β 剪枝。

---

复习自测

---

参考资料

• 💻 policy_gradient.py — 本讲源码
• 📖 Sutton & Barto: Reinforcement Learning (2nd ed.) — 第 9 章（on-policy 函数逼近）、第 11 章（off-policy 与致命三要素）、第 13 章（策略梯度方法）
• 📄 Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning (Williams, 1992) — REINFORCE 原始论文
• 📄 Policy Gradient Methods for RL with Function Approximation (Sutton et al., 2000) — 策略梯度定理与 actor-critic
• 📄 High-Dimensional Continuous Control Using Generalized Advantage Estimation (Schulman et al., 2015) — GAE：在偏差与方差之间连续调节
• 🎥 David Silver’s RL Course — Lecture 6 (Value Function Approximation) & Lecture 7 (Policy Gradient) — DeepMind RL 课程
• 🌐 CS221 课程主页 — 讲义与作业