Actor-Critic：用学出来的值函数给策略梯度降方差

0. 本讲导读

上一讲我们推出了策略梯度（policy gradient）的最终形式，并用因果性（causality）把它化简成了「reward-to-go」加权的对数似然梯度：

这个式子是无偏的，但它的方差大到令人绝望。原因藏在 $\hat Q_t^{(i)}$ 这一项里：它是「在状态 $s_t^{(i)}$ 下采取动作 $a_t^{(i)}$ 之后能拿到多少总回报」这个期望值的单样本估计。一条轨迹就是一次抽样，而未来几十上百步的随机性（策略的随机采样、环境转移的随机性）全都压缩进了这一个数字里。同一个 $(s_t,a_t)$，这次跑出来 $+100$，下次可能跑出来 $-30$，梯度方向就跟着乱抖。

本讲的核心思想只有一句话：与其用一条轨迹的单样本回报，不如训练一个神经网络去拟合这个期望，再把拟合值代进策略梯度里。 拟合出来的那个值函数网络就叫 critic（评论家），被它指导的策略网络就叫 actor（演员）。actor 负责做动作，critic 负责打分——这就是 actor-critic 这个名字的来历。

围绕这一句话，本讲要展开的问题链条是：

• 拟合谁？ 我们可以拟合 $Q^\pi$、$V^\pi$ 或 $A^\pi$。哪一个进策略梯度方差最低？哪一个最容易学？（结论：用 $A^\pi$ 进梯度，但只学 $V^\pi$。）
• 怎么学？ 拟合 $V^\pi$ 这件事叫策略评估（policy evaluation）。监督标签从哪来？蒙特卡洛回报（无偏、方差大）还是自举目标 $r+\gamma \hat V_\phi(s')$（有偏、方差小）？
• 无限长的任务怎么办？ $H\to\infty$ 时 $V^\pi$ 会发散，于是引入折扣因子 $\gamma$。而 $\gamma$ 放在策略梯度的哪个位置，会得到两个不一样的梯度——几乎所有人都在用「错的那个」，为什么？
• 算法怎么组织？ 批量（batch）版本 vs 在线（online）版本；在线版本为什么必须靠并行 worker 才能跑起来；actor 和 critic 该共享网络还是各用一个。
• 能不能既降方差又不引入偏差？ 能——把 critic 只当 baseline 用。这条路通向 n-step return 和 GAE（generalized advantage estimation），用一个旋钮 $\lambda$ 连续调节偏差与方差。
• 能不能用 replay buffer 变成 off-policy？ 能，但天真的做法是错的。修正它需要把 critic 从 $V$ 换成 $Q$，再加上重参数化技巧——终点就是 SAC。

与前后讲的关系：上一讲（策略梯度）给了 actor 的更新公式，本讲给它配一个 critic；下一讲（基于值的 RL）会把这件事推到极端——干脆不要 actor，只学一个 $Q$，用 $\argmax_a Q(s,a)$ 当策略。可以说 actor-critic 正好坐在纯策略梯度和纯值函数方法的中间，理解了它，两边都通了。本讲还会第一次完整推导 GAE，它是 PPO 实现里的标配部件，也是作业 2 的必做项。

1. 从单样本 reward-to-go 到期望：Q、V、A 三个值函数

1.1 回顾：REINFORCE 里那个刺眼的单样本回报

先统一记号：$s_t$ 是状态（满足马尔可夫性），$a_t$ 是动作，$\pi_\theta(a|s)$ 是参数为 $\theta$ 的策略，$r(s,a)$ 是奖励，$p(s'|s,a)$ 是环境转移，$H$ 是回合长度（horizon），$\tau=(s_1,a_1,\dots,s_H,a_H)$ 是轨迹，$\gamma$ 是折扣因子。上标 $(i)$ 表示第 $i$ 条采样轨迹。

REINFORCE 的完整算法是：

1. 从 $\pi_\theta(a_t|s_t)$ 采样 $N$ 条轨迹 $\{\tau^{(i)}\}$（就是跑策略）；
2. 计算 $\nabla_\theta J(\theta)\approx \frac1N\sum_i\sum_t \nabla_\theta\log\pi_\theta(a_t^{(i)}|s_t^{(i)})\,\hat Q_t^{(i)}$，其中 $\hat Q_t^{(i)}=\sum_{t'=t}^{H} r(s_{t'}^{(i)},a_{t'}^{(i)})$；
3. $\theta \leftarrow \theta + \alpha\nabla_\theta J(\theta)$。

关键在于理解 $\hat Q_t^{(i)}$ 到底代表什么。它想表达的意思是：「如果我在状态 $s_t^{(i)}$ 采取动作 $a_t^{(i)}$，之后预期能拿到多少总奖励？」 但一条轨迹只能给出这个问题的一个样本。真正的答案应该是对所有可能的未来求期望：

这就是状态-动作值函数（state-action value function），也叫 Q 函数：真实的期望 reward-to-go。

把单样本换成真实期望，策略梯度变成

1.2 baseline 应该取什么：状态值函数出场

上一讲已经证明：给策略梯度的权重减去任意一个与动作无关的 baseline $b$，梯度期望不变。当时我们用的是最简单的 $b=\frac1N\sum_i r(\tau^{(i)})$，即「平均回报」。现在有了 $Q^\pi$，一个更好的 baseline 呼之欲出。

定义状态值函数（state value function）

即「从状态 $s_t$ 出发，按当前策略行动，期望能拿多少总奖励」。它与 $Q^\pi$ 的差值就是优势函数（advantage function）：

$A^\pi$ 的语义是「$a_t$ 比在 $s_t$ 处随便按策略抽一个动作好多少」。它有一个非常漂亮的性质：在当前策略下的期望恒为零，$\E_{a\sim\pi}[A^\pi(s,a)]=0$。这意味着在任何状态下，总有一半左右（按概率加权）的动作优势为正、一半为负，梯度会均匀地「推好的、压坏的」。

为什么这是好事？考虑一个所有奖励都是正数的环境（比如每步 $+1$ 的生存奖励）。用原始 reward-to-go 时，所有动作的权重都是正的，策略梯度会同时推高所有采样到的动作的概率——只是推的力度不同。由于概率必须归一化，最终效果是相对的，能学，但梯度里混进了大量与「哪个动作更好」无关的公共分量，这部分纯粹是噪声放大器。减去 $V^\pi$ 之后，公共分量被扣掉了，剩下的每一个数字都直接回答「这个动作值不值得强化」。

1.3 三个函数，学哪一个？

于是策略梯度的最终形态是

注意这里的核心权衡：$A^\pi$ 估计得越准，梯度方差越低。注意是「方差」而不是「偏差」——如果我们的 $\hat A$ 有系统性误差，梯度就是有偏的，可能收敛到错误的地方。这与纯策略梯度形成鲜明对比：后者的 $\hat A$（单样本回报减常数 baseline）永远无偏，但方差大到需要海量样本。本讲从这里开始，就一直在这条偏差-方差的钢丝上走。

接下来的问题是：$Q^\pi$、$V^\pi$、$A^\pi$ 这三个函数，我们到底该用神经网络去拟合哪一个？答案在下一节。

2. 只拟合状态值函数就够了

2.1 fit what to what?

三个候选里，$Q^\pi$ 和 $A^\pi$ 都是 $(s,a)$ 的二元函数，而 $V^\pi$ 只是 $s$ 的一元函数。输入维度更低意味着更少的样本就能学好，这是选 $V^\pi$ 的第一个理由。第二个理由更本质：有了 $V^\pi$，另外两个都能拼出来。

由 Q 函数的定义与马尔可夫性，把第一步的奖励从求和里拿出来：

这一步用到了：给定 $s_{t+1}$ 之后，后续的期望回报只依赖 $s_{t+1}$（马尔可夫性），也就是 $V^\pi(s_{t+1})$ 的定义。注意 $r(s_t,a_t)$ 是确定的（已知 $s_t,a_t$），不需要期望。

代入优势函数：

最后那个 $\approx$ 是把对 $s_{t+1}$ 的期望换成了实际采样到的那一个 $s_{t+1}$。这是一次单样本近似，会引入方差——但请注意它和之前那个单样本 reward-to-go 的量级差别：之前是把整条未来轨迹压成一个样本，现在只把一步转移压成一个样本，后面所有步的随机性都被 $V^\pi$ 平滑掉了。这就是方差骤降的来源。

2.2 策略评估：值函数的监督标签从哪来

策略评估（policy evaluation）指的就是「给定策略 $\pi$，算出它的 $V^\pi$」，不涉及任何策略改进。它和 RL 目标的关系是

即目标函数就是初始状态的值在初始状态分布下的平均。

最朴素的做法是蒙特卡洛策略评估（Monte Carlo policy evaluation）：

或者更好的

第二式方差更小，但它要求能把模拟器重置到任意指定状态并从那里重跑多次。真实机器人做不到，大多数标准 gym 环境也做不到（只能 reset 到初始分布）。所以实践中我们只有第一式——每个状态只有一条样本轨迹。这正是纯策略梯度在做的事。

2.3 函数逼近让单样本也够用

虽然每个状态只有一条样本，但如果我们用神经网络 $\hat V^\pi_\phi$ 去拟合，情况会好很多。构造训练集

然后做最普通的监督回归：

关键洞察在于：神经网络是连续、光滑的函数。当两个状态 $s$ 和 $s'$ 很接近时，网络给它们的输出也接近，于是它们各自的单样本标签会被隐式地平均。相当于免费获得了「从同一状态重启多次」的效果——只不过是近似的、基于泛化的。Levine 的原话是「not as good as this（指真正的多次重启平均），but still pretty good!」。

2.4 自举（bootstrapping）：把 critic 自己当标签

蒙特卡洛标签 $y_t=\sum_{t'\ge t} r_{t'}$ 是无偏的，但它把未来 $H-t$ 步的所有随机性都塞进了一个标签里，方差随剩余步数增长。有没有方差更小的标签？

回到理想目标的定义并做一次一步展开：

第一个 $\approx$ 只是把一步的期望换成采样（同样是低方差的单步近似）；第二个 $\approx$ 是关键：我们把 $V^\pi$ 替换成了自己当前的估计 $\hat V^\pi_\phi$。这就是「自举」——用自己的估计去构造自己的训练标签，像揪着自己的鞋带把自己拎起来。

训练集变成

损失函数一模一样。实现上要注意：标签里的 $\hat V^\pi_\phi(s_{t+1})$ 必须被当成常数（PyTorch 里 .detach()），不能让梯度穿过去，否则优化的就不是回归问题了。

2.5 两个历史性的例子

这两个例子的共同点值得强调：奖励只在回合结束时出现（赢 $+1$ / 输 $-1$），中间几十上百步全是 $0$。如果只用蒙特卡洛，每个局面的标签就是最终输赢，噪声极大；而值函数网络学到的是「这个局面的胜率」，它把终局信号沿着自举链条一路回传，同时用泛化能力在相似局面之间共享信息。这正是 2.3 和 2.4 两节说的机制在真实系统里的体现。

3. 折扣因子 γ：它到底是什么，该放在哪里

3.1 无限长任务会让值函数发散

到目前为止我们都假设回合长度 $H$ 有限。但很多任务本质上是连续/循环型（continuous / cyclical）的：让机器人一直跑下去、让服务器一直调度请求。此时 $H=\infty$，如果每步奖励都是正的，$V^\pi(s)=\sum_{t=1}^{\infty} r_t$ 就是 $+\infty$，网络要去拟合一个发散的目标，训练必然崩掉。

标准解法是折扣因子（discount factor） $\gamma\in[0,1]$。自举目标改成

对应的优化目标变成

只要奖励有界 $|r|\le R_{\max}$，$|V^\pi|\le R_{\max}/(1-\gamma)$ 就是有限的。$\gamma=0.99$ 时上界是 $100R_{\max}$，完全在网络能表达的范围内。CS285 里 $\gamma=0.99$ 是几乎所有连续控制任务的默认值。

3.2 折扣因子的两种解释

3.3 γ 放在策略梯度的哪里：option 1 vs option 2

这是本讲最容易被跳过、但概念上最微妙的一点。我们已经知道 $\gamma$ 怎么进值函数了，那它怎么进策略梯度？有两种自然的写法，而它们不相等。

写法 A（option 1）：先写出无折扣的 causality 形式，再把 reward-to-go 换成折扣 reward-to-go：

注意折扣的指数是 $t'-t$：每个时间步都以「自己所在的时刻」为原点重新开始打折。

写法 B（option 2）：从折扣目标 $J(\theta)=\E[\sum_t \gamma^{t-1}r_t]$ 出发，老老实实推策略梯度。上一讲的推导给出

再用因果性去掉 $t'\lt t$ 的项，并把 $\gamma^{t'-1}$ 拆成 $\gamma^{t-1}\cdot\gamma^{t'-t}$：

与写法 A 相比，多了一个前置因子 $\gamma^{t-1}$。

3.4 从「时变」到「时不变」：为什么可以只写转移三元组

这一小节表面上只是换记号，实际影响很大。原来我们写 $s_t^{(i)}$，需要同时记住「第几条轨迹、第几步」。但在时齐（time-invariant / stationary）的无限视界 MDP 中：

• 转移 $p(s'|s,a)$ 不随 $t$ 变化；
• 折扣目标 $\sum_{t'\ge t}\gamma^{t'-t}r_{t'}$ 从任何时刻看都长得一样；
• 因此 $V^\pi(s)$ 只是 $s$ 的函数，与 $t$ 无关。

于是我们可以把所有轨迹拆散成一堆独立的转移（transition） $(s_i,a_i,s_i')$，训练集写成

这个记号的转变是后面所有内容的前提：只有把数据看成「一袋转移」而不是「一批轨迹」，replay buffer、mini-batch 随机梯度、异步并行采样这些工程手段才有意义。 反之，如果任务是有限视界且策略/值函数依赖时间（比如「第 10 步必须抓住杯子」），就必须保留 $t$，此时 $V$ 要写成 $V(s,t)$，或者把 $t$ 作为观测的一部分喂进网络。

4. 基本的 actor-critic 算法：批量版与在线版

4.1 批量 actor-critic

把前三节的结论装配起来，就得到批量 actor-critic 算法（batch actor-critic）：

1. 用当前策略 $\pi_\theta(a|s)$ 采样一批转移 $\{(s_i,a_i,r_i,s_i')\}$（通常是若干条完整轨迹拆散得到）；
2. 计算自举目标 $y_i = r(s_i,a_i)+\gamma\hat V^\pi_\phi(s_i')$；
3. 把 $\hat V^\pi_\phi(s)$ 回归到目标 $\{y_i\}$，即最小化 $\sum_i\|\hat V^\pi_\phi(s_i)-y_i\|^2$；
4. 计算优势 $\hat A^\pi(s_i,a_i)=r(s_i,a_i)+\gamma\hat V^\pi_\phi(s_i')-\hat V^\pi_\phi(s_i)$；
5. $\nabla_\theta J(\theta)\approx\sum_i \nabla_\theta\log\pi_\theta(a_i|s_i)\,\hat A^\pi(s_i,a_i)$；
6. $\theta\leftarrow\theta+\alpha\nabla_\theta J(\theta)$，回到第 1 步。

几点必须讲清楚的细节：

• 第 2 步和第 4 步里的 $\hat V^\pi_\phi$ 用的是哪一版参数？ 第 2 步用的是更新前的 $\phi$（老的 critic 给出目标），第 4 步一般用更新后的 $\phi$（新 critic 给出更准的优势）。这个细节在实现里很容易搞混，但影响不大。
• 第 3 步做几次梯度下降？ 可以只做一次（此时更像在线 TD），也可以做几十次直到收敛（此时更像「拟合值迭代」）。做太多次会过拟合到旧目标上，做太少 critic 跟不上 actor。常见做法是每轮做几到几十次 mini-batch 更新。
• 终止状态的处理：如果 $s_i'$ 是回合结束（terminal），必须令 $y_i=r_i$，即把 $\gamma\hat V^\pi_\phi(s_i')$ 强制置零。忘了这一点是最常见的 bug 之一：网络会认为「死了以后还能继续拿奖励」，学出来的策略会主动求死或主动求生（取决于奖励符号）。注意要区分「真正终止」和「因为时间上限被截断（time limit）」，后者理论上仍应自举。
• on-policy 性质：第 1 步的样本必须来自当前的 $\pi_\theta$。一旦 $\theta$ 更新，之前的样本就作废了，因为 $V^\pi$ 是对特定策略 $\pi$ 定义的。这是 actor-critic 样本效率低的根源，第 7 节会试图修补它。

4.2 在线 actor-critic：只有一条转移怎么办

批量版本要求先攒够一批数据。但既然我们已经把数据看成「一袋转移」，理论上每走一步就能更新一次。这就是在线 actor-critic（online actor-critic）：

1. 用 $a\sim\pi_\theta(a|s)$ 走一步，得到 $(s_i,a_i,r_i,s_i')$；
2. $y_i = r(s_i,a_i)+\gamma\hat V^\pi_\phi(s_i')$；
3. 用 $\nabla_\phi\mathcal{L}_i(\phi)$ 更新 $\phi$，其中 $\mathcal{L}_i(\phi)=\|\hat V^\pi_\phi(s_i)-y_i\|^2$；
4. $\hat A^\pi(s_i,a_i)=r(s_i,a_i)+\gamma\hat V^\pi_\phi(s_i')-\hat V^\pi_\phi(s_i)$；
5. $\nabla_\theta J(\theta)\approx\nabla_\theta\log\pi_\theta(a_i|s_i)\,\hat A^\pi(s_i,a_i)$；
6. $\theta\leftarrow\theta+\alpha\nabla_\theta J(\theta)$。

4.3 并行化：同步 vs 异步

解决办法是并行化：同时跑 $K$ 个环境实例，每步收集 $K$ 条互不相关的转移，凑成一个 batch 再更新。这样既保持了「在线」（每步一更新），又拿到了 i.i.d. 程度足够好的 mini-batch。

Levine 对异步版本的评价值得记下来：从理论上讲，异步 worker 用的是稍旧的策略产生数据，所以严格来说已经 off-policy 了，这是个「错误」；但只要参数变化不大（学习率小、更新频繁），这个偏差在实践中可以忽略。这是深度 RL 里非常典型的态度——大量方法在理论上是不严格的，但工程上有效。后来的研究（如 OpenAI 的 A2C 实现）发现同步版本在同等计算量下往往更好且更容易调试，所以现在同步并行是主流。

4.4 网络架构：两个网络还是一个网络

幻灯片上画的是两个独立的网络（一个吐 $\pi_\theta(a|s)$，一个吐 $\hat V^\pi_\phi(s)$）。但在图像输入的任务里，两个网络都要从像素里提取特征，这份工作重复了两遍。于是有两种设计：

5. critic 当 baseline：要方差还是要无偏

5.1 要让它在实践中真正好用，还缺什么

把 §4 的算法直接实现出来，在简单任务上能跑，但在稍难的任务上通常表现平庸。要让它变成「真正能用的策略梯度」，需要两方面的改进：

• 更好的 $\hat A^\pi$ 估计——本讲剩余部分（n-step、GAE）；
• 更好的 $\nabla_\theta J(\theta)$ 估计——即在同一批数据上做多次策略更新而不崩掉，这是 PPO 的内容，留到后面的讲次。

5.2 三种估计量的偏差-方差谱

写在一起看得更清楚。记 $g_t = \nabla_\theta\log\pi_\theta(a_t|s_t)$：

第三行是个非常有意思的位置：它用了 critic，却没有引入任何偏差。原因是 critic 只出现在 baseline 的位置，而 baseline 的无偏性对任意只依赖状态的函数都成立——哪怕这个函数学得一塌糊涂。学得越准，方差降得越多；学得不准，最多是白干，绝不会把梯度带偏。这是一个「只赚不赔」的用法。

5.3 证明：状态相关的 baseline 不引入偏差

6. n-step return 与 GAE：把偏差-方差变成一个旋钮

6.1 在哪里「切一刀」

把两个极端写在一起：

第一个只信任一步真实奖励，之后全部交给 critic；第二个信任全部真实奖励，critic 只当 baseline。自然的折中是：信任前 $n$ 步真实奖励，第 $n$ 步之后交给 critic。这就是 n-step return 优势：

三项的含义依次是：前 $n$ 步的真实折扣奖励、第 $n$ 步之后的估计值（打 $\gamma^n$ 的折扣）、以及作为 baseline 的当前值。令 $n=1$ 退化为 $\hat A^\pi_{\mathrm{C}}$，令 $n\to\infty$ 退化为 $\hat A^\pi_{\mathrm{MC}}$。

6.2 GAE：不用选 n，全都要

选 $n$ 是个超参数搜索问题，而且不同状态的最优 $n$ 未必一样。广义优势估计（Generalized Advantage Estimation, GAE）的想法是干脆不选：把所有 $n$ 的 n-step 优势加权平均起来。

权重怎么选？既然「早点切」方差更小，那就让权重随 $n$ 指数衰减：

归一化系数是 $(1-\lambda)$，即 $w_n=(1-\lambda)\lambda^{n-1}$（几何分布）。$\lambda=0$ 时只保留 $n=1$（纯 critic）；$\lambda\to 1$ 时权重趋于均匀并把质量推向大 $n$（纯蒙特卡洛）。

6.3 化简：为什么会得到 TD 误差的指数加权和

这个结果有几个值得反复品味的地方：

• $\lambda$ 和 $\gamma$ 在公式里以乘积 $\gamma\lambda$ 出现，所以幻灯片上那句「similar effect as discount!」是字面意义上的：调小 $\lambda$ 与调小 $\gamma$ 对优势估计的影响形式完全一样，都是缩短有效视界、降低方差、引入偏差。区别在于 $\gamma$ 同时改变了我们优化的目标（它出现在 $\delta$ 的定义里、也定义了 $V^\pi$ 是什么），而 $\lambda$ 只影响估计量，不改变目标。所以 $\lambda$ 是一个更「干净」的方差旋钮：可以放心把 $\gamma$ 设成 $0.99$ 来定义任务，再用 $\lambda=0.95$ 单独控制估计噪声。
• $\lambda=0$：只剩 $l=0$ 项，$\hat A=\delta_t$，就是最基本的 actor-critic（最低方差、最大偏差）。$\lambda=1$：$\hat A=\sum_l\gamma^l\delta_{t+l}$，望远镜全部抵消后正好是 $\sum_{t'\ge t}\gamma^{t'-t}r_{t'}-\hat V_\phi(s_t)$，即蒙特卡洛优势（无偏、最大方差）。
• 常用取值是 $\lambda\in[0.9,0.99]$，其中 $0.95$ 是最常见的默认值（PPO 原论文用的就是 $\gamma=0.99,\lambda=0.95$）。以 $\gamma\lambda=0.99\times0.95\approx0.94$ 计，有效视界约 $1/(1-0.94)\approx 17$ 步——和 §6.1 里 n-step 的经验值 $5\sim 20$ 完全吻合。
• 计算极其便宜：从轨迹末尾往前做一次线性扫描即可，$\hat A_t = \delta_t+\gamma\lambda\hat A_{t+1}$。这个递推式直接由上面的求和形式得到。

6.4 用 GAE 的策略梯度算法与优势标准化

完整算法：

1. 用 $\pi_\theta$ 采样一批轨迹 $\{\tau^{(i)}\}$；
2. 算值函数回归目标 $y_t^{(i)}=r(s_t^{(i)},a_t^{(i)})+\gamma\hat V^\pi_\phi(s_{t+1}^{(i)})$（也可以用 $\lambda$-return 作为目标，即 $\hat V_\phi(s_t)+\hat A^{\mathrm{GAE}}_t$）；
3. 把 $\hat V^\pi_\phi$ 拟合到 $\{y_t^{(i)}\}$；
4. 算 $\hat A^\pi_{\mathrm{GAE}}(s_t^{(i)},a_t^{(i)})=\sum_{t'\ge t}(\gamma\lambda)^{t'-t}\delta_{t'}^{(i)}$；
5. $\nabla_\theta J(\theta)\approx\sum_i\sum_t\nabla_\theta\log\pi_\theta(a_t^{(i)}|s_t^{(i)})\,\bar A(s_t^{(i)},a_t^{(i)})$；
6. $\theta\leftarrow\theta+\alpha\nabla_\theta J(\theta)$。

第 5 步用的是标准化后的优势：

减去 $\mu$ 是一个（近似的）常数 baseline，理论上无偏；除以 $\sigma$ 严格来说改变了梯度的大小（相当于自适应地缩放学习率），但不改变方向。这在实践中是必备操作：它让同一套超参数能跨越奖励量级差好几个数量级的任务，也让训练早期（优势尺度大）和后期（优势尺度小）的有效步长保持一致。

7. Off-policy actor-critic：给它接上 replay buffer

7.1 天真的做法为什么是错的

在线 actor-critic 的样本效率极低：每条转移只用一次就扔掉。深度学习的本能反应是加一个 replay buffer（经验回放池）：把走过的转移都存起来，每次训练从池子里随机抽一个 batch。这既解决了「batch size 只有 1」的问题，也解决了「连续样本高度相关」的问题，还能把每条数据反复利用。

但直接这么做是错的，而且错在两个不同的地方。设 buffer 里的数据来自某个较旧的策略 $\bar\pi$：

1. critic 的目标错了。 我们想学的是 $V^\pi$，即当前策略的值函数，它满足 $V^\pi(s)=\E_{a\sim\pi_\theta(a|s)}\big[r(s,a)+\gamma V^\pi(s')\big]$。但 buffer 里的 $a_i$ 是 $\bar\pi$ 采的，用它算出来的目标对应的是 $\E_{a\sim\bar\pi(a|s)}[r(s,a)+\gamma V^\pi(s')]$——这是旧策略的值函数，不是我们要的。
2. actor 的梯度错了。 策略梯度公式 $\E_{a\sim\pi_\theta}[\nabla_\theta\log\pi_\theta(a|s)\hat A(s,a)]$ 要求动作从当前策略采样。buffer 里的 $a_i$ 不是当前策略会选的动作，这个期望的采样分布不对。

7.2 第一处修补：把 critic 从 V 换成 Q

第一个错误的根源是：$V^\pi(s)$ 的定义里，「第一步的动作」是由策略决定的，所以数据里的动作必须来自当前策略。而 $Q^\pi(s,a)$ 的定义里，第一步的动作是作为输入给定的：

这个式子里对 $(s,a)$ 没有任何分布假设——它对任意 $(s,a)$ 都成立。所以 buffer 里的 $(s_i,a_i,s_i')$ 无论来自哪个策略都能用：$s_i'$ 是环境按 $p(s'|s_i,a_i)$ 给的，这与策略无关。唯一需要来自当前策略的是 $a'$——而它我们可以自己现场采，因为采样动作不需要与环境交互，只要跑一次策略网络的前向：

这就是「用最新策略」的含义：$a_i'$ 永远由当前的 $\pi_\theta$ 产生，所以学出来的是当前策略的 $Q^\pi$，而不是旧策略的。代价是 critic 的输入从 $s$ 变成了 $(s,a)$，学起来更难一些——这是为拿到 off-policy 能力付的学费。

7.3 第二处修补：actor 用的动作要重新采

同样的技巧用在 actor 侧：既然采样动作不需要与环境交互，那就对 buffer 里的每个状态 $s_i$，重新从当前策略采一个动作 $a_i^\pi\sim\pi_\theta(a|s_i)$，然后

注意这里直接用了 $\hat Q^\pi_\phi$ 而不是优势 $\hat Q-\hat V$。这确实方差更高（没有减 baseline），但方便——我们只有 $Q$ 网络，没有 $V$ 网络。幻灯片留下的问题「为什么这里高方差是可以接受的？」答案是：因为我们可以对同一个 $s_i$ 采任意多个动作而不花任何环境交互成本。想降方差就多采几个 $a^\pi$ 求平均，或者用 $\hat V_\phi(s_i)\approx\frac{1}{M}\sum_{m}\hat Q_\phi(s_i,a^{\pi,m}_i)$ 现算一个 baseline。在 on-policy 情形下你做不到这一点（每个动作都必须真的执行），但 off-policy + Q 函数让「重复采样动作」变成了免费操作。

7.4 剩下那个改不掉的问题：状态分布

修完两处之后还有第三个偏差：$s_i$ 不来自当前策略的状态分布 $p_\theta(s)$。我们能重新采动作，却不能重新采状态——状态是环境交互的产物，要想按 $p_\theta(s)$ 采状态就必须用当前策略真的跑一遍，那 replay buffer 就白搭了。

Levine 对此的态度很干脆：「nothing we can do here, just accept it」。并给出一个安慰性的直觉：我们本来想要「在 $p_\theta(s)$ 上表现最优的策略」，现在得到的是「在一个更宽的状态分布（历史上所有策略访问过的状态的混合）上表现最优的策略」。这个策略在我们真正关心的那部分状态上通常也不差——只是我们浪费了一些容量去优化那些当前策略根本不会去的地方。在后面的离线 RL 讲次里会看到，当这个分布偏移变得极端时（数据全部来自完全不同的策略），它会从「可以接受」变成「致命」。

7.5 重参数化技巧：绕开对数概率

先看清楚我们在优化什么。第 4 步的梯度

目标就是「让策略在每个状态下选出 Q 值高的动作」。这是一个很朴素的目标。而 log-derivative（也叫 REINFORCE / score function）估计量只是计算这个梯度的一种方法——它把 $\hat Q_\phi$ 当成一个黑箱，只用它的取值。可是 $\hat Q_\phi$ 明明是一个可微的神经网络，我们完全可以对它的输入 $a$ 求导！

重参数化技巧（reparameterization trick）的关键观察：高斯采样可以拆成「确定性变换 + 与参数无关的噪声」。设 $\pi_\theta(a|s)=\mathcal{N}(\mu_\theta(s),\sigma_\theta(s))$，则

与直接从 $\pi_\theta$ 采样等价。因此

而右边这个式子里 $\theta$ 出现在可微函数的内部，autograd 直接就能求导：

把所有修补装配起来，得到带重参数化的 off-policy actor-critic：

1. 用 $a\sim\pi_\theta(a|s)$ 走一步，把 $(s_i,a_i,r_i,s_i')$ 存入 replay buffer $\mathcal{R}$；
2. 从 $\mathcal{R}$ 抽一个 batch，采 $a_i'\sim\pi_\theta(a'|s_i')$，算目标 $y_i=r(s_i,a_i)+\gamma\hat Q^\pi_\phi(s_i',a_i')$；
3. 用 $\nabla_\phi\sum_i\|\hat Q^\pi_\phi(s_i,a_i)-y_i\|^2$ 更新 $\phi$；
4. 采 $\epsilon_i\sim\mathcal{N}(0,1)$，用 $\nabla_\theta\sum_i \hat Q^\pi_\phi\big(s_i,\mu_\theta(s_i)+\sigma_\theta(s_i)\epsilon_i\big)$ 更新 $\theta$；
5. 回到第 1 步。

8. 实现细节与最小可跑代码

8.1 一份 on-policy actor-critic + GAE 的最小实现

下面这段代码把 §4 的算法框、§6 的 GAE 递推和 §6.4 的优势标准化全部串起来。它是可以真正跑通的逻辑（配一个 Gym 连续控制环境即可），只是省略了日志、评估、随机种子等工程外壳。

import torch
import torch.nn as nn


class Actor(nn.Module):
    """高斯策略 pi(a|s) = N(mu_theta(s), diag(exp(log_std)))。
    log_std 做成与状态无关的全局参数，这是连续控制里最常用的做法。"""

    def __init__(self, obs_dim, act_dim, hidden=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, hidden), nn.Tanh(),
            nn.Linear(hidden, hidden), nn.Tanh(),
            nn.Linear(hidden, act_dim),
        )
        self.log_std = nn.Parameter(torch.zeros(act_dim))

    def dist(self, obs):
        mu = self.net(obs)
        return torch.distributions.Normal(mu, self.log_std.exp())


class Critic(nn.Module):
    """V_phi(s)：输入状态，输出一个标量。"""

    def __init__(self, obs_dim, hidden=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, hidden), nn.Tanh(),
            nn.Linear(hidden, hidden), nn.Tanh(),
            nn.Linear(hidden, 1),
        )

    def forward(self, obs):
        return self.net(obs).squeeze(-1)


def compute_gae(rewards, values, dones, last_value, gamma=0.99, lam=0.95):
    """GAE 的反向递推：A_t = delta_t + gamma * lam * A_{t+1}。

    rewards, values, dones : 形状 (T,) 的一维张量
    last_value             : V_phi(s_T)，即这一段 rollout 之后的自举值
    返回 (advantages, returns)，returns 用作 critic 的回归目标。
    """
    T = rewards.shape[0]
    adv = torch.zeros(T)
    running = torch.zeros(())
    for t in reversed(range(T)):
        next_value = last_value if t == T - 1 else values[t + 1]
        nonterminal = 1.0 - dones[t]                      # 终止状态不自举
        delta = rewards[t] + gamma * next_value * nonterminal - values[t]
        running = delta + gamma * lam * nonterminal * running
        adv[t] = running
    returns = adv + values          # lambda-return = A^GAE + V(s)
    return adv, returns


def update(actor, critic, opt_a, opt_c, obs, act, adv, ret, n_critic_steps=8):
    # --- actor：伪损失，只有梯度有意义，数值本身没有意义 ---
    adv = (adv - adv.mean()) / (adv.std() + 1e-8)         # 优势标准化
    logp = actor.dist(obs).log_prob(act).sum(dim=-1)      # 各维独立，log 概率相加
    actor_loss = -(logp * adv).mean()                    # 取负号是因为要做梯度上升
    opt_a.zero_grad()
    actor_loss.backward()
    nn.utils.clip_grad_norm_(actor.parameters(), 0.5)    # 梯度裁剪，防单批数据把策略打飞
    opt_a.step()

    # --- critic：普通的平方误差回归，目标已 detach ---
    for _ in range(n_critic_steps):
        critic_loss = ((critic(obs) - ret) ** 2).mean()
        opt_c.zero_grad()
        critic_loss.backward()
        opt_c.step()

配套的采样与主循环（以 Gym 接口为例）：

def collect_rollout(env, actor, critic, n_steps=2048):
    obs_buf, act_buf, rew_buf, done_buf, val_buf = [], [], [], [], []
    obs, _ = env.reset()
    for _ in range(n_steps):
        obs_t = torch.as_tensor(obs, dtype=torch.float32)
        with torch.no_grad():
            dist = actor.dist(obs_t)
            action = dist.sample()
            value = critic(obs_t)
        nxt, rew, terminated, truncated, _ = env.step(action.numpy())

        obs_buf.append(obs_t)
        act_buf.append(action)
        rew_buf.append(float(rew))
        val_buf.append(value)
        # 注意：只有"真正终止"才算 done；因超时被截断时仍应自举
        done_buf.append(float(terminated))

        obs = nxt
        if terminated or truncated:
            obs, _ = env.reset()

    with torch.no_grad():
        last_value = critic(torch.as_tensor(obs, dtype=torch.float32))
    return (torch.stack(obs_buf), torch.stack(act_buf),
            torch.tensor(rew_buf), torch.tensor(done_buf),
            torch.stack(val_buf), last_value)


env = ...                                    # 任一连续动作环境
actor = Actor(obs_dim, act_dim)
critic = Critic(obs_dim)
opt_a = torch.optim.Adam(actor.parameters(), lr=3e-4)
opt_c = torch.optim.Adam(critic.parameters(), lr=1e-3)

for itr in range(1000):
    obs, act, rew, done, val, last_v = collect_rollout(env, actor, critic)
    adv, ret = compute_gae(rew, val, done, last_v, gamma=0.99, lam=0.95)
    update(actor, critic, opt_a, opt_c, obs, act, adv.detach(), ret.detach())

8.2 off-policy 版本的 actor 更新（重参数化）

§7.5 的重参数化梯度写成代码只有几行，关键是不要 detach 动作——梯度必须能从 $Q$ 网络穿过动作回到策略参数：

def reparam_actor_loss(actor, q_net, obs):
    """off-policy actor 更新：直接最大化 Q(s, a(theta))。"""
    dist = actor.dist(obs)
    action = dist.rsample()        # rsample 而不是 sample：保留计算图（重参数化）
    q_value = q_net(obs, action)   # 梯度经由 action 传回 mu_theta / sigma_theta
    return -q_value.mean()


def q_target(q_net, actor, rew, next_obs, done, gamma=0.99):
    """critic 目标：动作 a' 一定要用最新策略现采，而不是 buffer 里的动作。"""
    with torch.no_grad():
        next_action = actor.dist(next_obs).sample()
        next_q = q_net(next_obs, next_action)
        return rew + gamma * (1.0 - done) * next_q

把 sample() 写成 rsample() 是这段代码里唯一但也是最关键的区别：前者切断梯度（只能配 score function 估计量用），后者保留 $a=\mu_\theta+\sigma_\theta\epsilon$ 这条计算路径，让 autograd 自动算出重参数化梯度。

8.3 实现清单：最容易踩的坑

本讲小结

一句话：把策略梯度里那个单样本的 reward-to-go 换成学出来的值函数，用可控的偏差换取巨大的方差削减，这就是 actor-critic。

要点清单：

• 方差的根源是「用一条轨迹估计一个期望」。critic 的全部价值在于把这个期望估出来。
• 只学 $V^\pi$（输入维度最低），$Q^\pi$ 和 $A^\pi$ 都能由它和一步转移拼出来。
• 自举 vs 蒙特卡洛 = 偏差 vs 方差。深度 RL 里视界长，自举几乎总是赢。
• $\gamma$ 既是数学上的死亡概率，也是实践中的方差旋钮；$\gamma$ 放在 $\log\pi$ 前面（option 2）才是折扣目标的真梯度，但大家都用 option 1，因为我们其实想要的是无折扣/平均奖励目标。
• 在线 actor-critic 必须并行化才能跑；同步（A2C）比异步（A3C）更简单也通常更好。
• critic 放在 baseline 位置 → 完全无偏；放在「替换未来回报」的位置 → 有偏但低方差。GAE 用 $\lambda$ 在两者之间连续插值。
• GAE 的推导核心是「n-step 优势 = 前 n 个 TD 误差的折扣和」这个望远镜恒等式。
• 加 replay buffer 需要三处审视：critic 目标（换 $Q$ + 现采 $a'$）、actor 动作（现采 $a^\pi$）、状态分布（无解，接受它）。
• 写完 §6 的算法你就有了 PPO 的一半；写完 §7 你就到了 SAC 的门口。

延伸阅读

核心论文

• High-Dimensional Continuous Control Using Generalized Advantage Estimation (Schulman, Moritz, Levine, Jordan, Abbeel, 2015) — GAE 的原始论文，本讲第 6 节的完整来源。除了 $\hat A^{\mathrm{GAE}}$ 的推导，还给出了「$\gamma$ 与 $\lambda$ 分别控制什么」的实验对比，值得亲自看那几张曲线。
• Asynchronous Methods for Deep Reinforcement Learning (Mnih et al., 2016) — A3C 原论文。异步并行 worker 的具体做法、共享主干网络的架构、以及为什么在当年不用 GPU 也能训 Atari。
• Proximal Policy Optimization Algorithms (Schulman et al., 2017) — PPO。本讲的 GAE + 优势标准化就是它的一半，另一半是裁剪的重要性采样目标。今天绝大多数 on-policy 实现（包括 RLHF）都是它。
• Soft Actor-Critic (Haarnoja et al., 2018) — 第 7 节那条 off-policy 路线的终点：replay buffer + $Q$ 函数 + 重参数化梯度 + 熵正则化，连续控制上的默认强基线。
• Continuous Control with Deep Reinforcement Learning (Lillicrap et al., 2015) — DDPG，用确定性策略做同样的事（$\sigma\to 0$ 的极限），第 7 节结尾预告的那类算法。

偏差、方差与折扣的理论

• Bias in Natural Actor-Critic Algorithms (Philip Thomas, 2014) — 严格分析了「option 1 少了 $\gamma^{t-1}$」造成的偏差，是理解 §3.3 的必读文献。
• Learning to Predict by the Methods of Temporal Differences (Sutton, 1988) — TD($\lambda$) 与资格迹（eligibility traces）的源头，GAE 本质上是它在优势估计上的对应物。
• Q-Prop (Gu et al., 2016) — 把 on-policy 无偏梯度与 off-policy critic 结合，用 critic 的一阶泰勒展开做控制变量（control variate），是「既要无偏又要低方差」这条思路的代表。
• Sample Efficient Actor-Critic with Experience Replay / ACER (Wang et al., 2016) — 用截断重要性采样 + Retrace 修正让多步回报也能 off-policy 使用，正好补上 §7 表格里「off-policy 只能 1 步自举」那一格。

历史与实践

• Temporal Difference Learning and TD-Gammon (Tesauro, 1992/1995) — 第 2.5 节那个例子的原文，第一个证明神经网络 + 自举可以在真实任务上达到人类水平的系统。
• Mastering the Game of Go with Deep Neural Networks and Tree Search (Silver et al., 2016) — AlphaGo，值函数网络在稀疏终局奖励下的大规模应用。
• What Matters In On-Policy Reinforcement Learning? (Andrychowicz et al., 2020) — 对 on-policy actor-critic 的几十个实现细节做了大规模消融实验，§8.3 那张坑表里的很多结论都能在这里找到定量证据。