基于模型的强化学习

0. 本讲导读

到目前为止我们学的所有方法——策略梯度、actor-critic、Q-learning、以及第 14 讲把语言模型接进来的 RLVR—— 有一个共同点：它们从来不去了解世界是怎么运转的。它们只知道「我做了这个动作，最后拿到了这么多奖励」。 转移概率 $p(s_{t+1}|s_t,a_t)$ 始终躲在采样过程后面，从没有被显式写下来过。这类方法叫 无模型强化学习（model-free RL）。

但人显然不是这么学的。你伸手去推桌上的杯子之前，脑子里已经预演过杯子会往哪滑、会不会倒； 如果推错了，你也不需要真把水洒一地才知道那个动作不好。这种「先在脑子里跑一遍」的能力， 在 RL 里对应的就是模型（model）：一个能回答「在状态 $s$ 做动作 $a$ 之后会发生什么」的函数。 如果我们手上有这个东西，很多问题会立刻变得简单——不需要真的在环境里试错， 可以在模型里想象出任意多的数据；甚至可以完全不学策略，直接用规划器（planner）在模型里搜出一条好轨迹。

本讲要问的核心问题只有一个：既然拟合 $p(s'|s,a)$ 只是一个再普通不过的监督学习问题， 我们为什么不干脆学一个模拟器，然后在里面跑 RL？Levine 用了整整一讲来说明：这个想法是对的， 但最朴素的实现方式必然失败，而且失败的原因和第 2 讲模仿学习里的 分布漂移（distributional shift）是同一个东西，只是换了一副面孔—— 这次漂移的不是策略看到的状态，而是模型被查询到的状态-动作对。

脉络分三段：第一段写下「学出来的模拟器」的朴素算法，并逐条拆解它为什么会失败 （分布漂移、模型设计的领域依赖、以及「有了模拟器不等于规划变容易」）。 第二段把分布漂移讲透：为什么把数据收集放进循环只能「勉强算是」修好了问题， 为什么优化器一定会去利用模型的错误（model exploitation），以及两条对策—— 信赖域（trust region）和不确定性感知（uncertainty-aware）模型。 第三段回答「不确定性到底怎么估」：输出熵为什么不够， 偶然不确定性（aleatoric）与认知不确定性（epistemic）的区别，贝叶斯神经网络， 以及工程上真正好用的 bootstrap 集成（bootstrap ensemble）。

1. 我们真的能学出一个「模拟器」吗

先把术语对齐。本讲的记号沿用全课：$s_t$ 是状态（满足马尔可夫性），$a_t$ 是动作， $o_t$ 是观测（可能只是状态的一部分），$r(s,a)$ 是奖励，$\pi_\theta(a|s)$ 是策略， $\tau=(s_1,a_1,\dots,s_T,a_T)$ 是轨迹。所谓模型，就是对转移分布的一个显式表示：

其中 $\phi$ 是模型参数（为了和策略参数 $\theta$ 区分开）。注意确定性模型是随机模型的特例 （退化成一个 $\delta$ 分布）。本讲前半段为了叙述简洁用 $f$，后半段讨论不确定性时必须换回 $p$。

为什么想要模型：三个动机

动机一：样本效率。这是最直接的理由。model-free 方法的样本消耗量级大家已经很熟悉了： 在线策略梯度类方法要在真实环境里跑上百万甚至上亿步。而模型是用监督学习拟合的， 监督学习是我们最擅长、样本效率最高的一类学习。一旦有了模型， 后续的策略优化一步真实环境交互都不需要——全部在模型里进行。 换句话说，我们把「昂贵的真实交互」换成了「便宜的模型内交互」。

动机二：可以完全不用 RL。如果模型是可微的、或者动作空间不大， 我们可以直接用规划（planning）或轨迹优化（trajectory optimization） 求解，压根不需要学一个策略网络，也不需要处理 Bellman 误差、目标网络这些麻烦事。 这在机器人领域是主流做法：模型预测控制（Model Predictive Control, MPC）几十年来一直是工业标准。

动机三：模型可以复用。动力学 $p(s'|s,a)$ 是环境的属性，与奖励无关。 换一个任务（换 $r$），策略和值函数全部作废，但模型一字不改还能用。 这一点在多任务、目标条件（goal-conditioned）设定下价值极大。

这不是新想法：系统辨识

「先辨识动力学，再基于辨识出的动力学做控制」在控制论里叫 系统辨识（system identification），比深度学习早了半个世纪。 经典做法是：假设动力学有已知的参数化形式（比如刚体动力学方程 $M(q)\ddot q + C(q,\dot q)\dot q + g(q) = \tau$，未知的只是质量、惯量、摩擦系数这几个数）， 然后用少量数据把这几个物理参数拟合出来。这套东西非常好用： 未知量只有几个到几十个，数据需求极小，泛化极好——因为方程的结构本身已经编码了正确的归纳偏置。

深度学习版本的野心大得多：我们不假设任何结构，直接用一张大网络去拟合 $f_\phi: (s,a) \mapsto s'$。好处是通用，坏处是——网络在数据覆盖之外的行为毫无保证。 下一节我们就会看到，正是这个「毫无保证」，让朴素算法从根上垮掉。

2. 朴素算法：model-based RL v0.5

把上一节的想法写成算法，只有三行：

第二步的损失函数值得多说一句。写成 $\|f_\phi(s_i,a_i)-s_i'\|^2$， 等价于假设 $p(s'|s,a)=\mathcal{N}(f_\phi(s,a), \sigma^2 I)$ 且 $\sigma$ 固定， 再做极大似然：$-\log p = \frac{1}{2\sigma^2}\|f_\phi - s'\|^2 + \text{const}$。 也就是说，最小二乘等价于一个方差固定的高斯模型——它永远不会告诉你「我不确定」。 这个隐含假设会在第 7 节被彻底推翻。

2.1 这个算法在什么情况下真的能用

先给它一句公道话：v0.5 不是完全没用。当以下条件成立时它工作得相当好：

• 动力学有已知的良好结构（如前述系统辨识的情形），待拟合的参数很少；
• 基础策略 $\pi_\beta$ 的数据已经覆盖了最优策略会去的那片状态空间；
• 状态维度低、动力学光滑。

典型的成功例子就是给机器人做重力补偿、给四旋翼辨识推力系数这类任务。 但只要环境稍微复杂一点、$\pi_\beta$ 稍微「不够好」一点，第二条就会破。而它一破，全盘皆输。

2.2 失败点一：分布漂移（这次漂移的是模型的输入分布）

形式化地说：我们用监督学习拟合模型，得到的保证是训练分布下的期望误差小：

但第 3 步的优化器要做的事情是：找一个 $\pi_f$ 最大化模型里的回报

这里 $p_f^\pi$ 是「策略 $\pi$ 在模型 $f$ 里」诱导的轨迹分布。 优化器完全没有理由停留在 $p_{\pi_\beta}$ 覆盖的区域内。事实上恰恰相反： $\pi_\beta$ 是个笨策略，它去过的地方回报都不高；回报高的地方，按定义就是 $\pi_\beta$ 没去过的地方。 于是优化过程会系统性地、主动地把查询点推向模型没有数据的区域。 这比模仿学习里的漂移严重得多——在模仿学习里漂移是被动累积的误差； 在这里漂移是优化目标主动奖励的行为。

2.3 失败点二：模型的设计是领域相关的

这条常常被忽略，但它是实践中最难的部分。「学一个模拟器」听起来是一个统一的问题， 实际上模型的状态表示、网络结构、训练目标全都高度依赖具体领域：

2.4 失败点三：有了模拟器，规划也未必容易

• 大神经模型可能比传统模拟器慢得多。一个物理引擎步进一次可能只要几微秒， 而一次视频扩散模型的前向要几百毫秒。如果规划需要几万次 rollout，学出来的模拟器反而是负担。
• 有了「模拟器」不代表规划/RL 就容易了。模拟器只是把环境交互变便宜了， 探索难、奖励稀疏、长时序信用分配这些问题一个都没消失。
• 直接在图像像素上做规划和最优控制极其困难。规划算法需要在状态空间里做优化， 而像素空间既高维又没有有用的度量结构——两张只差几个像素的图可能语义天差地别。
• 在学出来的模拟器里跑 model-free RL 也可能非常困难、非常慢。 你只是把「真实环境的样本复杂度」换成了「模型内 rollout 的计算复杂度」，后者未必更便宜。
• 有时我们会故意选一个不那么准确（更简单）的模型，只为了让规划变容易。 比如用线性模型换来 LQR 的闭式解，用低维隐状态换来 CEM 能在其中搜索。准确度和可规划性是一对权衡。

3. 分布漂移的数学：误差是怎么被放大的

幻灯片上这一段只有一张图和一句「yet another form of distributional shift」。 但既然这是全讲的病根，值得把量化的推导补全。我们要回答： 单步模型误差 $\epsilon$ 会在 $T$ 步的 rollout 里被放大成多大的回报误差？

又是 $O(\epsilon T^2)$——和第 2 讲行为克隆的误差界完全同一个形状，这不是巧合： 两者都是「单步误差 $\epsilon$ + 误差改变了后续的状态分布 + 时间长度 $T$」的组合。 代入数字感受一下：单步 TV 误差 $\epsilon=0.01$（已经算相当准了），$T=200$，$R_{\max}=1$， 界给出 $\approx 0.01\times 200\times 199 \approx 398$，而这段轨迹的总回报本身最多也就 $200$。 界完全失效了。当然这是最坏情况的上界，但它准确地传达了一件事： 长时域 rollout 下，模型误差的放大是超线性的。这也解释了为什么后来的很多算法 （如 Dyna 类方法）宁可只用模型做很短的 rollout（$k=1\sim5$ 步）， 剩下的长期价值交给学到的值函数。

3.1 版本 1.0：把数据收集塞进循环

既然问题是「$\pi_f$ 去的地方模型没数据」，最自然的修法就是：那就让 $\pi_f$ 去采点数据回来。 这就是 DAgger 的思路搬到模型上：

v1.0 确实有用，而且是所有实用 model-based RL 算法的基本骨架： 它保证了「策略去哪里，数据就补到哪里」，让模型在当前策略的分布上逐步变准。 从模拟引理的角度看，它是在把 $\epsilon$ 定义所依赖的那个分布 $\mu$ 不断拉向 $p_{\pi_f}$。

但为什么只是「sort of」？因为它是事后补救：策略必须先冲出悬崖、真的摔下去一次， 数据才会告诉模型「这里不能走」。在仿真里这只是浪费样本；在真实机器人上，这一次可能就是最后一次。 更麻烦的是下一节要讲的：即使你愿意付这个代价，第 3 步里的「学出最优策略」 这个要求本身就是有毒的。

4. 走多远？版本 1.5 与「模型被利用」

4.1 别一口气优化到最优

v1.0 的第 3 步写的是「学出最优策略 $\pi_f$」。想想这意味着什么： 优化器会在模型里搜索所有可能的策略，挑出模型认为回报最高的那个。 而模型在没有数据的区域可以给出任意离谱的预测。那么「模型认为回报最高的策略」 大概率就是「最会利用模型错误的策略」。

所以第一个修正是：别把策略优化到最优，只改进一点点。

这个「走多远」的两难，和第 9–10 讲的信赖域问题在结构上一模一样： 那里我们要在「用旧数据的重要性采样估计有效」和「策略改进足够快」之间权衡； 这里我们要在「模型预测有效」和「策略改进足够快」之间权衡。数学形式也一样， 都归结为约束 $D_{\mathrm{KL}}(\pi_{\text{new}} \| \pi_{\text{old}}) \le \epsilon$。

4.2 问题比想象的更糟：优化器会主动挖出模型的错误

这张图值得停下来品一品。请注意：那个虚假尖峰之所以致命，恰恰因为它是尖峰。 如果模型误差是随机分布的、有正有负，那么大部分误差点根本不会被选中—— 优化器只会挑正向误差最大的那个点。也就是说， $\argmax$ 操作把「零均值的随机误差」系统性地转成了「正向偏差」。 这和第 8 讲 Q-learning 里的最大化偏差（maximization bias）是同一个数学现象。

4.3 两条药方

注意版本 2.0 的措辞变化：不是「在 $p$ 下最优」，而是「在 $p$ 下期望意义最优」 （best policy in expectation under $p$）。这个「期望」是对模型的不确定性取的， 而不只是对环境的随机性取的。下一节会说明，这个小小的措辞差别为什么能救命。

5. 不确定性估计凭什么能救命

5.1 一个具体的数值例子

为什么「均值一样，方差不同，期望回报就不同」？因为回报函数是非线性的—— 准确地说，是不对称的：站在悬崖边一米处很安全，掉下去则是灾难。 用 Jensen 不等式的语言：对于凹的回报函数 $r$，$\E[r(s')] \le r(\E[s'])$， 方差越大，这个不等号越紧。

5.2 这套逻辑的边界

• 还是需要探索才能变好（need to explore to get better）。 如果永远只往「有把握」的地方走，模型永远不会在新区域获得数据，性能就卡死了。 不确定性回避和探索是方向相反的两股力：前者说「别去不熟的地方」，后者说「必须去不熟的地方」。 实际算法里的解法是把探索交给外层循环——v1.5 的「每轮采一点新数据」本身就在做小步探索； 更激进的做法（第 19–20 讲）会给不确定性一个正的奖励（乐观主义）， 让智能体主动去消除不确定性。
• 期望值不等于悲观值。取期望是一个「风险中性」的操作。 如果任务真的不能容忍任何失败（真实机器人、医疗决策），你需要的是显式的悲观估计， 比如优化下分位数 $\text{CVaR}_\alpha$ 或者用 $\hat R - \lambda \sigma$ 这种带惩罚的目标。 期望值给的保护是被动的、强度由奖励的不对称性决定，你无法直接调节它。
• 期望值也不等于乐观值。反过来，如果你在做探索，想要的是 $\hat R + \lambda\sigma$（upper confidence bound），期望值同样给不了。
• ……但期望值通常是个不错的起点。这是 Levine 的实用主义判断： 悲观和乐观都需要额外的超参数 $\lambda$，调不好就会太保守或太激进； 而「按模型的不确定性取期望」是唯一一个没有额外超参数的选择， 并且在实践中（比如 PETS 这类算法）已经足以让 model-based RL 稳定工作。

6. 两种不确定性：输出熵为什么不够

现在问题变成：怎么让神经网络告诉我们它有多不确定？ 第一个想法几乎是条件反射式的：让网络输出一个分布而不是一个点。

Levine 给认知不确定性的那句定义值得背下来： 「模型对数据是确定的，但我们对模型是不确定的」 （the model is certain about the data, but we are not certain about the model）。

6.1 为什么输出熵抓不到认知不确定性

考虑最坏的情况：一张容量极大的网络，在小数据集上训练到完美过拟合。 它输出的 $p_\phi(s'|s,a)$ 在每个训练点上都是一个尖锐的、几乎零方差的分布—— 因为它确实把每个训练点都记住了，训练损失为零。现在拿一个训练集外的 $(s,a)$ 去问它， 网络会怎样？它会同样自信地给出一个尖锐分布，只不过均值可能完全是胡说。

问题的根源在于：网络输出的那个分布，建模的是「给定这组参数 $\phi$，$s'$ 有多随机」， 也就是 $p(s'|s,a,\phi)$ 中对 $s'$ 的随机性。它完全没有表达 $\phi$ 本身有多不可靠。 用一句话说：过拟合的网络输出熵低，但它恰恰是最不可信的网络。

7. 想法 2：直接估计参数的后验

把这个思路写成公式。通常的训练是点估计：

我们改成保留整个后验，并在预测时把它积掉：

（注意这里换用 $\theta$ 表示模型参数，与幻灯片一致。） $p(\theta|\mathcal{D})$ 的熵就是模型不确定性的度量：数据充分时后验集中、熵低； 数据不足时后验弥散、熵高。而且这个量与输入无关地刻画了参数层面的无知， 再通过上面的积分传播到每个具体的 $(s_t,a_t)$ 上—— 在数据覆盖的输入上不同 $\theta$ 给出的预测差不多（积分后仍然尖锐）， 在没覆盖的输入上不同 $\theta$ 给出的预测天差地别（积分后被抹平成一个宽分布）。这正是我们想要的行为。

7.1 贝叶斯神经网络

贝叶斯神经网络（Bayesian neural network, BNN）的想法是直接对 $p(\theta|\mathcal{D})$ 建模。 但 $\theta$ 动辄百万维，真实后验的形状复杂到无法表示，所以必须做近似。 最常见的近似是平均场（mean field）：

参数量正好翻倍：每个权重从 1 个数变成 2 个数（均值 + 标准差）。 训练方法是变分推断——最大化 ELBO，这套工具第 11–12 讲已经完整推过了： 把 $q(\theta)=\prod_i\mathcal{N}(\mu_i,\sigma_i)$ 当作变分分布， 用重参数化技巧 $\theta_i = \mu_i + \sigma_i\epsilon_i$（$\epsilon_i\sim\mathcal{N}(0,1)$） 让梯度能穿过采样，目标是

这就是 Blundell 等人的 Bayes by Backprop。另一条更省事的路线是把 dropout 解释成变分近似 （Gal 等人的 Concrete Dropout）：训练时和推断时都开着 dropout，多次前向取样， 样本之间的分歧就是认知不确定性的估计。

8. Bootstrap 集成：工程上真正好用的那个

核心近似只有两行。第一行：用 $N$ 个 Dirac 分布的均匀混合来代替后验——

第二行：把这个近似代入预测积分，$\delta$ 函数的筛选性质直接把积分变成求和——

也就是说，预测分布 = $N$ 个模型输出分布的等权混合。 如果每个 $p(\cdot|s,a,\theta_i)$ 是高斯 $\mathcal{N}(\mu_i,\Sigma_i)$， 那么这个混合分布的均值和方差正好复现第 6 节的全方差分解：

第二项就是「模型们吵架的程度」。在训练数据密集的地方，所有成员都被数据钉死在同一个答案上， 分歧接近零；在没有数据的地方，每个成员按自己随机初始化的偏好乱外推，分歧巨大。 这就是我们要的认知不确定性，而且它几乎不需要任何新数学。

8.1 为什么叫「bootstrap」，以及为什么实践中可以省掉它

统计学里的 bootstrap 是这样一个技巧：想知道一个估计量的抽样分布， 但只有一份数据集 $\mathcal{D}$（大小 $M$），那就从 $\mathcal{D}$ 里有放回地 再抽 $M$ 个样本组成 $\mathcal{D}_i$，重复 $N$ 次，在每个 $\mathcal{D}_i$ 上各算一次估计量。 这些估计量的分散程度就近似了真实的抽样分布。有放回采样使每个 $\mathcal{D}_i$ 大约只包含原数据集 $1-(1-1/M)^M \to 1-e^{-1}\approx 63.2\%$ 的不同样本， 剩下的位置由重复样本填充——正是这种差异制造了模型之间的独立性。

最后一条对工程实现是个好消息：你不需要维护 $N$ 份不同的数据集， 所有模型共享同一个 replay buffer，只是初始化不同、每步看到的 mini-batch 顺序不同。 这既省内存又省代码，而且经验上不确定性估计的质量并不比真 bootstrap 差。

8.2 最小实现：概率动力学模型 + 集成

下面给出一份能跑通的实现。要点：预测 $\Delta s$、输入输出归一化、 每个成员输出高斯的均值与对数方差、用负对数似然（NLL）训练、 对 $\log\sigma^2$ 做软性上下界约束（PETS 的做法，防止方差跑飞）。

import torch, torch.nn as nn

class GaussianDynamics(nn.Module):
    """单个概率动力学模型：(s, a) -> N(mu_ds, sigma^2)，预测状态增量 delta_s = s' - s"""
    def __init__(self, dim_s, dim_a, hidden=256):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim_s + dim_a, hidden), nn.SiLU(),
            nn.Linear(hidden, hidden),        nn.SiLU(),
            nn.Linear(hidden, 2 * dim_s),          # 前 dim_s 是均值，后 dim_s 是 log 方差
        )
        self.dim_s = dim_s
        # 可学习的方差软边界（PETS 的技巧）：让 logvar 被平滑地夹在 [min, max] 内
        self.max_logvar = nn.Parameter(torch.full((dim_s,),  0.5))
        self.min_logvar = nn.Parameter(torch.full((dim_s,), -10.0))
        # 输入/输出归一化统计量（用数据集估计，不参与梯度）
        self.register_buffer('in_mu',  torch.zeros(dim_s + dim_a))
        self.register_buffer('in_std', torch.ones(dim_s + dim_a))
        self.register_buffer('ds_mu',  torch.zeros(dim_s))
        self.register_buffer('ds_std', torch.ones(dim_s))

    def fit_normalizer(self, s, a, ds):
        x = torch.cat([s, a], dim=-1)
        self.in_mu.copy_(x.mean(0));  self.in_std.copy_(x.std(0).clamp_min(1e-6))
        self.ds_mu.copy_(ds.mean(0)); self.ds_std.copy_(ds.std(0).clamp_min(1e-6))

    def forward(self, s, a):
        """返回归一化空间中的 (mu, logvar)"""
        x = (torch.cat([s, a], dim=-1) - self.in_mu) / self.in_std
        out = self.net(x)
        mu, logvar = out[..., :self.dim_s], out[..., self.dim_s:]
        # 软夹紧：超出边界时用 softplus 平滑衰减，梯度不会被截断成 0
        logvar = self.max_logvar - nn.functional.softplus(self.max_logvar - logvar)
        logvar = self.min_logvar + nn.functional.softplus(logvar - self.min_logvar)
        return mu, logvar

    def nll_loss(self, s, a, s_next):
        ds = ((s_next - s) - self.ds_mu) / self.ds_std      # 归一化后的目标增量
        mu, logvar = self(s, a)
        inv_var = torch.exp(-logvar)
        # 高斯 NLL（省略常数）：0.5 * [ (y-mu)^2 / var + log var ]
        loss = 0.5 * ((mu - ds) ** 2 * inv_var + logvar).sum(-1).mean()
        # 让软边界本身也被轻微地往里拉，否则 max_logvar 会一直往上漂
        loss = loss + 0.01 * (self.max_logvar.sum() - self.min_logvar.sum())
        return loss

    @torch.no_grad()
    def predict(self, s, a, sample=True):
        """返回真实空间中的下一状态"""
        mu, logvar = self(s, a)
        ds = mu + torch.randn_like(mu) * torch.exp(0.5 * logvar) if sample else mu
        return s + ds * self.ds_std + self.ds_mu

class Ensemble(nn.Module):
    """N 个独立初始化的动力学模型。共享同一个数据集，靠随机初始化 + SGD 噪声制造多样性。"""
    def __init__(self, n_models, dim_s, dim_a, hidden=256):
        super().__init__()
        self.models = nn.ModuleList([GaussianDynamics(dim_s, dim_a, hidden)
                                     for _ in range(n_models)])

    def fit_normalizer(self, s, a, s_next):
        for m in self.models:
            m.fit_normalizer(s, a, s_next - s)

    def train_epoch(self, buf, opt, batch=256, steps=200, bootstrap=False):
        """buf: (S, A, S') 三个张量。bootstrap=True 时每个成员看有放回采样的子集。"""
        S, A, S2 = buf
        M = S.shape[0]
        for _ in range(steps):
            loss = 0.0
            for m in self.models:
                idx = torch.randint(0, M, (batch,))    # 有放回采样 == 天然的 bootstrap 批
                loss = loss + m.nll_loss(S[idx], A[idx], S2[idx])
            opt.zero_grad(); loss.backward()
            torch.nn.utils.clip_grad_norm_(self.parameters(), 10.0)
            opt.step()

    @torch.no_grad()
    def disagreement(self, s, a):
        """成员均值之间的方差 —— 认知不确定性的直接度量"""
        mus = torch.stack([m.predict(s, a, sample=False) for m in self.models])  # [N,B,dim_s]
        return mus.var(dim=0).mean(dim=-1)            # [B]

disagreement 这个函数就是全方差分解里的第 (II) 项：把随机性关掉 （sample=False，只取均值），看 $N$ 个成员的均值散得有多开。 你可以直接把它当作 exploration bonus 或者 pessimism penalty 用。

9. 把整条链接起来：不确定性感知的 MPC 循环

到这里，本讲的三个部分已经齐了：怎么收数据（v1.5 的循环）、 怎么训模型（概率模型 + 集成）、以及为什么要这么做（分布漂移与模型利用）。 剩下唯一的空缺是「第 3 步到底怎么用模型」——这是下一讲的主题， 但为了让代码能真正跑起来，这里先给出最简单也最常用的那个答案： 随机打靶（random shooting）+ 交叉熵方法（cross-entropy method, CEM）+ 模型预测控制（MPC）。

9.1 用采样做规划：从 random shooting 到 CEM

不学策略，直接在每个时刻现场求解一个有限时域的最优控制问题：

其中期望同时对环境随机性和模型不确定性取—— 后者正是第 5 节说的「in expectation under $p$」。这个优化问题在连续动作空间里非凸、 不可微（模型可能不可微，奖励也可能不可微），所以最省事的解法是纯采样：

• 随机打靶：从某个分布（比如均匀分布）里采 $K$ 条长度为 $H$ 的动作序列， 在模型里 rollout，选累计回报最高的那条。简单、无梯度、可并行； 缺点是 $K$ 需要随 $H\times\dim(a)$ 指数增长才能覆盖搜索空间。
• CEM：把随机打靶做成迭代的。用一个高斯 $\mathcal{N}(\mu,\sigma^2)$ 采 $K$ 条， 评估后取回报最高的 $E$ 条（精英，elites），用这 $E$ 条重新拟合 $\mu,\sigma$，重复几轮。 本质上是一个非常朴素的分布式进化策略——搜索分布逐步收缩到高回报区域。 经验上 $K\approx 200\sim 1000$、精英比例 $10\%$、迭代 $4\sim 6$ 轮就足够。
• MPC：不管规划出多长的序列，只执行第一个动作，然后在新的真实状态上重新规划。 这一步是整个方案能工作的关键：它把「模型误差在 $H$ 步内累积」的问题 用每一步都从真实状态重启的方式反复清零，等于给系统加了一个闭环反馈。 代价是计算量——每个控制周期都要跑一次完整的 CEM。

9.2 用集成做 rollout：轨迹采样

集成模型怎么参与 rollout？最直接的做法（PETS 论文里叫 TS1 / TS∞）是 粒子化：对每条候选动作序列，开 $P$ 个粒子并行 rollout， 每个粒子在每一步（TS1）或整条轨迹上固定（TS∞）随机选一个集成成员来推进。 然后把 $P$ 个粒子的回报取平均——这就是对 $p(\theta|\mathcal{D})$ 的蒙特卡洛积分。

为什么这样做能自动实现风险规避？回到悬崖的例子：在模型有把握的区域， 所有成员给出的下一状态几乎相同，$P$ 个粒子挤在一起，平均回报就等于那个确定的回报； 在模型没把握的区域，粒子们四散飞开，其中一部分落进了灾难区，把平均值狠狠拉低。 规划器于是自发地避开了它。

@torch.no_grad()
def cem_plan(ens, s0, reward_fn, dim_a, H=20, K=500, elites=50, iters=5,
             P=20, a_low=-1.0, a_high=1.0, mu_init=None):
    """
    ens      : Ensemble
    s0       : [dim_s] 当前真实状态
    reward_fn: (s, a) -> [B] 已知的奖励函数（model-based RL 通常假设奖励已知）
    P        : 每条候选序列的粒子数（对模型不确定性做蒙特卡洛积分）
    返回     : 规划出的第一个动作 [dim_a]，以及可热启动下一轮的 mu
    """
    N = len(ens.models)
    mu = torch.zeros(H, dim_a) if mu_init is None else mu_init.clone()
    sigma = torch.full((H, dim_a), (a_high - a_low) / 2)

    for _ in range(iters):
        # 1) 从当前搜索分布采 K 条动作序列并裁剪到动作范围内
        acts = (mu + sigma * torch.randn(K, H, dim_a)).clamp(a_low, a_high)

        # 2) 每条序列开 P 个粒子，在集成模型里 rollout
        s = s0.expand(K * P, -1).contiguous()                 # [K*P, dim_s]
        ret = torch.zeros(K * P)
        for h in range(H):
            a = acts[:, h].repeat_interleave(P, dim=0)        # [K*P, dim_a]
            ret += reward_fn(s, a)
            # TS1：每个粒子在每一步独立地随机挑一个集成成员
            member = torch.randint(0, N, (K * P,))
            s_next = torch.empty_like(s)
            for i in range(N):
                m = member == i
                if m.any():
                    s_next[m] = ens.models[i].predict(s[m], a[m], sample=True)
            s = s_next

        # 3) 对粒子取平均 —— 这就是「in expectation under p」
        scores = ret.view(K, P).mean(dim=1)                   # [K]

        # 4) 取精英，重新拟合搜索分布
        top = scores.topk(elites).indices
        mu = acts[top].mean(dim=0)
        sigma = acts[top].std(dim=0).clamp_min(1e-3)

    # MPC：只返回第一个动作；把 mu 左移一格作为下一轮的热启动
    warm = torch.cat([mu[1:], torch.zeros(1, dim_a)], dim=0)
    return mu[0], warm

把 scores 那一行从 .mean(dim=1) 改成 ret.view(K,P).mean(1) - lam * ret.view(K,P).std(1)， 就从「期望值」变成了「悲观值」——这正是第 5 节讨论的那个 $\lambda$ 超参数。 改成加号则是乐观值（用于探索）。三行代码里藏着三种完全不同的风险态度。

9.3 外层循环：完整的 model-based RL v1.5

def mbrl_loop(env, ens, reward_fn, dim_a, n_iters=30, steps_per_iter=200):
    opt = torch.optim.Adam(ens.parameters(), lr=1e-3, weight_decay=1e-5)
    S, A, S2 = [], [], []

    # --- 第 0 轮：用随机基础策略 pi_beta 收集种子数据 ---
    s = env.reset()
    for _ in range(1000):
        a = torch.empty(dim_a).uniform_(-1, 1)
        s2, _, done, _ = env.step(a.numpy())
        S.append(s); A.append(a); S2.append(s2)
        s = env.reset() if done else s2

    for it in range(n_iters):
        buf = (torch.as_tensor(S).float(),
               torch.as_tensor(A).float(),
               torch.as_tensor(S2).float())

        # --- 第 2 步：重训模型（每轮从头训比增量微调更稳） ---
        ens.fit_normalizer(*buf)
        ens.train_epoch(buf, opt, steps=1000)

        # --- 第 3 步 + 第 1 步合并：用 MPC 在真实环境里跑，同时收新数据 ---
        # 注意这天然就是 v1.5 的「只改进一点点」：策略隐含在规划器里，
        # 模型只变了一点，规划结果也就只变了一点，不存在「一口气优化到最优」的问题。
        s, warm, ep_ret = env.reset(), None, 0.0
        for _ in range(steps_per_iter):
            a, warm = cem_plan(ens, torch.as_tensor(s).float(), reward_fn,
                               dim_a, mu_init=warm)
            s2, r, done, _ = env.step(a.numpy())
            S.append(s); A.append(a); S2.append(s2)
            ep_ret += r
            s = env.reset() if done else s2
        print(f'iter {it}  真实回报 {ep_ret:.1f}  数据量 {len(S)}')

本讲小结

四个版本的递进（一页速查）

要点清单

• 分布漂移在 model-based RL 里换了对象：模仿学习漂移的是策略的输入状态， 这里漂移的是模型被查询的 $(s,a)$。而且这次漂移是被优化目标主动奖励的，不是被动累积的。
• 模拟引理：单步 TV 误差 $\epsilon$ ⇒ 第 $t$ 步状态分布误差 $\le (t-1)\epsilon$ ⇒ 回报误差 $O(\epsilon T^2)$。这解释了为什么长时域 rollout 不可信，以及为什么 MPC（把 $T$ 换成 $H$）如此有效。
• 模型利用（model exploitation）：在 $K$ 条候选里取 $\argmax$， 会把零均值的模型噪声系统性地转成约 $\sigma\sqrt{2\ln K}$ 的正向偏差。 搜索得越狠，被骗得越惨。调试时永远同时看「模型预测回报」与「真实回报」的裂口。
• 两条对策：信赖域（限制策略变化，$D_{\mathrm{KL}}(\pi_f\|\pi_\beta)\le\epsilon$） 与不确定性感知（待在模型有把握的地方）。前者第 9–10 讲已备好工具，后者是本讲重点。
• 不确定性为什么起效：奖励函数在危险边界附近是不对称的， 所以「均值相同、方差更大」的预测其期望回报更低。悬崖例子里 $\mathcal{N}(1,0.3^2)$ 给 $+9.96$，$\mathcal{N}(1,2^2)$ 给 $-24.1$。风险规避是免费附赠的。
• aleatoric vs epistemic：全方差分解 $\mathrm{Var}[s'] = \E_\theta[\mathrm{Var}[s'|\theta]] + \mathrm{Var}_\theta[\E[s'|\theta]]$。 单个网络的输出熵只给第一项；我们要的是第二项。 「模型对数据是确定的，但我们对模型是不确定的。」
• 估计 $p(\theta|\mathcal{D})$ 的两条路：贝叶斯神经网络（每个权重换成 $\mathcal{N}(\mu_i,\sigma_i)$，变分推断训练；平均场假设粗糙，倾向低估不确定性） 与 bootstrap 集成（$p(\theta|\mathcal{D})\approx\frac1N\sum_i\delta(\theta_i)$， 预测变成 $N$ 个分布的等权混合）。
• 集成的工程结论：基本有效；$N\lt 10$ 是很粗糙的近似，只能定性用； 有放回重采样通常可以省掉，随机初始化 + SGD 噪声就够。
• 下一讲：在有了（不确定性感知的）模型之后，第 3 步该怎么做—— 专为学到的模型设计的规划与最优控制方法。

延伸阅读

不确定性估计

• Weight Uncertainty in Neural Networks (Blundell et al., 2015) —— 幻灯片直接点名的 Bayes by Backprop。把变分推断落到每个权重上， 读它可以搞清楚「权重的分布」在实现层面到底长什么样。
• Concrete Dropout (Gal et al., 2017) —— 另一条被点名的路线：把 dropout 率也变成可学习的，从而把 dropout 严格解释成变分近似。 工程上是「加最少代码拿到不确定性」的方案。
• Simple and Scalable Predictive Uncertainty Estimation using Deep Ensembles (Lakshminarayanan et al., 2017) —— 为「集成 + 高斯 NLL 输出头」这套组合提供了系统的实证支持， 也是本讲「重采样通常没必要」这一结论的主要出处。
• What Uncertainties Do We Need in Bayesian Deep Learning for Computer Vision? (Kendall & Gal, 2017) —— aleatoric / epistemic 这对区分最清晰的一篇论述，附有把两者分开建模的具体损失函数。

不确定性感知的 model-based RL

• Deep Reinforcement Learning in a Handful of Trials using Probabilistic Dynamics Models (Chua et al., 2018) —— 即 PETS，本讲所有思想的教科书式实现：概率集成 + 轨迹采样（TS1/TS∞）+ CEM + MPC。 本讲第 8–9 节的代码基本就是它的简化版。
• Neural Network Dynamics for Model-Based Deep RL with Model-Free Fine-Tuning (Nagabandi et al., 2018) —— 把「预测 $\Delta s$ + 随机打靶 MPC + 数据聚合」这套最朴素的组合做通的工作， 是理解 v1.5 循环的最佳入门读物。
• When to Trust Your Model: Model-Based Policy Optimization (Janner et al., 2019) —— MBPO。把「模型 rollout 只走 $k$ 步」这件事的理论依据写清楚了， 正是对本讲 $O(\epsilon T^2)$ 界的直接回应。
• MOPO: Model-based Offline Policy Optimization (Yu et al., 2020) —— 把「不确定性惩罚」写成显式的 $r - \lambda u(s,a)$， 是第 5 节讨论的「悲观值」在离线设定下的标准做法。

学出来的模拟器 / 世界模型

• World Models (Ha & Schmidhuber, 2018) —— 「在学到的模型里做梦训练策略」这个提法的来源，第 12 讲的状态空间模型在这里派上用场。
• Learning Latent Dynamics for Planning from Pixels (Hafner et al., 2018) —— PlaNet。回答本讲失败点三里的「像素上没法规划」：先学一个低维隐状态，再在隐空间里跑 CEM。
• Dream to Control: Learning Behaviors by Latent Imagination (Hafner et al., 2019) —— Dreamer。把隐空间里的规划换成隐空间里的 actor-critic，是「第 3 步该怎么做」的另一个主流答案。
• Genie: Generative Interactive Environments (Bruce et al., 2024) —— 开场那两张视频生成图所指向的方向：从无标注视频里学出可以用动作交互的生成式环境。

回顾

• 第 2 讲（模仿学习）：分布漂移与 DAgger，本讲 v1.0 的直接来源，两者的 $O(\epsilon T^2)$ 界形状完全一致。
• 第 9–10 讲（高级策略梯度）：信赖域与 KL 约束，本讲「对策 1」的全部工具。
• 第 11–12 讲（变分推断）：贝叶斯神经网络的训练方法，以及从像素学隐动力学的模型骨架。