行为的监督学习：行为克隆为什么会失败

0. 本讲导读

上一讲我们讨论了「为什么要做深度强化学习」：为什么手工设计控制器在真实世界里不可扩展，为什么表示学习和决策制定必须放在同一个框架里解决。这一讲开始动真格——我们要造出本课程的第一个可运行的算法。

而这个算法出人意料地朴素：让人类演示一遍，然后用监督学习去拟合人类的动作。这就是行为克隆（behavioral cloning, BC），也叫模仿学习（imitation learning）最基础的形式。它甚至不需要奖励函数 $r(s,a)$，不需要价值函数，不需要与环境交互——一个标准的图像分类/回归训练脚本就能跑。

本讲真正的价值不在于「介绍 BC 这个算法」，而在于回答这样一串问题，它们构成了 Levine 讲课里典型的动机链条：

• 把控制问题写成监督学习，到底丢了什么？ 监督学习的一切理论保证都建立在「训练和测试数据独立同分布（i.i.d.）」上。而在控制问题里，策略自己的输出会改变它下一步看到的输入。这个反馈回路一旦存在，i.i.d. 假设就彻底失效。
• 失效有多严重？ 这是本讲的技术核心。我们会一步不漏地推出：如果策略在训练分布上犯错概率不超过 $\epsilon$，那么在长度为 $H$ 的任务上，期望犯错总数的最坏情况上界是 $O(\epsilon H^2)$ —— 注意是 $H$ 的二次方，而不是监督学习里天真预期的 $\epsilon H$。
• 那为什么现实中 BC 又经常能用？ 1989 年的 ALVINN、2016 年 NVIDIA 的端到端自动驾驶、今天的机器人 VLA 模型，全都是行为克隆。理论说不行，实践说行，矛盾在哪？答案藏在「数据是怎么收集的」里。
• 怎么从根上修好它？ DAgger（Dataset Aggregation） 的核心思想只有一句话：既然是 $p_{\text{data}}$ 和 $p_{\pi_\theta}$ 对不上，与其想办法让策略去迁就数据，不如让数据去迁就策略。

与后续课程的关系：下一讲会继续深挖模仿学习——DAgger 的工程变体、非马尔可夫策略（历史信息）带来的因果混淆（causal confusion）、以及人类演示天然的多模态性该怎么用扩散策略（diffusion policy）、动作分块（action chunking）之类的手段建模。再往后进入真正的强化学习时，你会发现本讲的分布漂移分析像幽灵一样反复出现：off-policy 修正、TRPO 的信任域、offline RL 的分布外动作，本质上都是同一个 $p_{\text{train}} \neq p_{\text{test}}$ 的问题在不同场景下的变形。

1. 记号：从 $p_\theta(y|x)$ 到 $\pi_\theta(a_t|o_t)$

先从一件你已经会的事情开始。给定一张车载前视摄像头拍到的图片 $\mathbf{x}$，我们想输出图中物体的类别 $y$（比如「car」）。标准做法是训练一个神经网络输出条件分布 $p_\theta(y|\mathbf{x})$，然后在带标注的数据集 $\{(\mathbf{x}^{(i)}, y^{(i)})\}_{i=1}^{N}$ 上做最大似然估计（maximum likelihood estimation, MLE）：

这就是监督学习。交叉熵损失、Adam、数据增强、早停——整套工具链你都熟悉。

1.1 只改标签，不改结构

现在把这张图上的符号换掉，什么都不改：让输出 $y$ 不再是物体类别，而是此刻应该打多少方向盘、踩多深油门。于是同一个网络就成了一个「驾驶员」。

本课程通用的记号，从这里开始固定下来：

1.2 状态与观测：马尔可夫性到底在说什么

$\mathbf{s}$ 和 $\mathbf{o}$ 的区别是本课程反复踩坑的地方，必须一次讲清。

马尔可夫性（Markov property）说的是：给定当前状态 $\mathbf{s}_t$，未来 $\mathbf{s}_{t+1}$ 与过去 $\mathbf{s}_{t-1}$ 条件独立。用大白话讲：知道了现在，过去就再也提供不了任何额外信息。这是「状态」这个词的定义性质——如果一个量不满足它，它就不配叫状态。

而观测没有这个性质。看图里那辆被卡车挡住的小汽车：在 $\mathbf{s}_t$ 里它的坐标和速度都在，但 $\mathbf{o}_t$（一张图片）里它被完全遮挡了。此刻如果你只看 $\mathbf{o}_t$，你会以为右车道是空的；但如果你还记得 $\mathbf{o}_{t-1}$——那时它还没被挡住——你就知道那儿有辆车。过去的观测对预测未来是有用的，所以观测不满足马尔可夫性。

1.3 演示数据与行为克隆的目标函数

数据从哪来？让一个人去开车，把他每一时刻看到的画面和他打的方向盘都记录下来。一次完整的记录叫一条演示轨迹（demonstration trajectory），数据集就是 $N$ 条这样的轨迹：

然后——把它当成一堆 $(\mathbf{o},\mathbf{a})$ 的散装样本对，忘掉它们的时间顺序，直接跑最大似然：

这个式子就是行为克隆。请仔细体会「忘掉时间顺序」这五个字——它是本讲后面所有麻烦的源头。我们把一个序贯决策问题当成了 $N \times H$ 个互不相干的分类/回归问题来处理，等于默认了这些样本是 i.i.d. 的。它们当然不是。

2. 行为克隆算法：完整的两步

算法本身简单到可以写在一张便签上：

2.1 历史插曲：1989 年的 ALVINN

这个想法一点都不新。1989 年，CMU 的 Dean Pomerleau 做了 ALVINN（Autonomous Land Vehicle In a Neural Network）：一个只有 5 个隐藏单元、输入是 $30\times 32$ 灰度「视网膜」、输出 30 个转向方向单元的全连接网络，装在一辆改装军用卡车上，学人类司机开车。

Levine 讲这段历史是有目的的：让你意识到 BC 的问题不是「模型不够大」。同样的范式在 5000 参数和 50 亿参数上都能跑，也都会遭遇同一个结构性缺陷。这个缺陷不在模型里，在问题的设定里。

2.2 动作分布怎么参数化

「输出一个分布」在具体实现上分两种情况。

离散动作。网络输出 $A$ 维 logits 向量，用 softmax 转成概率：

取对数似然就是标准的交叉熵损失。这跟做图像分类一模一样。顺便说一句：大语言模型的下一 token 预测，形式上就是一个离散动作空间上的行为克隆——观测是上文，动作是下一个 token，演示数据是人类写的文本。这个类比在本课后面讲 RLHF 时会再次出现。

连续动作。最简单的做法是输出一个多元高斯的参数：

在 $\Sigma(\mathbf{o}_t) = \mathbf{I}$ 的特殊情况下，负对数似然退化为

也就是普通的均方误差回归。这解释了为什么很多 BC 实现直接就是 MSE loss——它是「固定单位方差高斯 + 最大似然」的等价形式。

2.3 一份能跑的最小实现

下面是完整的 BC 训练循环（PyTorch），连续动作用对角高斯，离散动作只需把最后两行换成交叉熵。

import torch, torch.nn as nn

class GaussianPolicy(nn.Module):
    """pi_theta(a|o)：观测 -> 对角高斯的 (mu, log_std)。"""
    def __init__(self, obs_dim, act_dim, hidden=256):
        super().__init__()
        self.trunk = nn.Sequential(
            nn.Linear(obs_dim, hidden), nn.ReLU(),
            nn.Linear(hidden, hidden), nn.ReLU(),
        )
        self.mu_head = nn.Linear(hidden, act_dim)
        # log_std 与观测无关（state-independent），是最常用的简化
        self.log_std = nn.Parameter(torch.zeros(act_dim))

    def dist(self, obs):
        h = self.trunk(obs)
        mu = self.mu_head(h)
        std = self.log_std.clamp(-5.0, 2.0).exp()
        return torch.distributions.Normal(mu, std)

    def log_prob(self, obs, act):
        # 各维度独立，log p(a|o) = sum_j log p(a_j|o)
        return self.dist(obs).log_prob(act).sum(dim=-1)

    @torch.no_grad()
    def act(self, obs, deterministic=False):
        d = self.dist(obs)
        return d.mean if deterministic else d.sample()


def behavior_cloning(obs_all, act_all, obs_dim, act_dim,
                     epochs=50, batch_size=256, lr=1e-3):
    """obs_all: (N*H, obs_dim)  act_all: (N*H, act_dim)
    注意这里把所有轨迹的所有时间步「打散」成了一个大池子，
    并且每个 epoch 都随机打乱 —— 这正是在假装样本是 i.i.d. 的。"""
    policy = GaussianPolicy(obs_dim, act_dim)
    opt = torch.optim.Adam(policy.parameters(), lr=lr)
    n = obs_all.shape[0]
    for ep in range(epochs):
        perm = torch.randperm(n)
        total = 0.0
        for i in range(0, n, batch_size):
            idx = perm[i:i + batch_size]
            o, a = obs_all[idx], act_all[idx]
            loss = -policy.log_prob(o, a).mean()   # 负对数似然
            opt.zero_grad(); loss.backward(); opt.step()
            total += loss.item() * len(idx)
        print(f"epoch {ep:3d}  NLL = {total / n:.4f}")
    return policy

请特别留意 behavior_cloning 里那句 torch.randperm(n)。它把所有轨迹、所有时间步的数据彻底打散重排——这是监督学习的标准操作，也正是我们主动抹掉时序结构、假装数据 i.i.d. 的那一行代码。整个第 4、5 节要付的账，就是从这里欠下的。

3. 它到底行不行？

3.1 不行

拿一个理想化的实验来看：训练数据是一条黑色轨迹，我们在上面做 BC，然后把学到的策略放回环境里跑，画出它的期望轨迹（红色）。

注意这张图里失败的模式：不是随机抖动，是单向发散。这跟监督学习中「测试误差比训练误差高一点」的图景完全不同。误差在这里不是被平均掉，而是被积分起来。

3.2 行

然后 Levine 立刻放了 2016 年 NVIDIA 的演示视频：一辆车在锥桶阵里稳稳地开，用的正是纯粹的端到端行为克隆（Bojarski 等人）。这构成了一个必须解释的矛盾。

3.3 为什么那个能行？

答案不在网络结构里，在数据采集装置里。

顺着这条线，可以给出一份「让 BC 变得可用」的想法清单（第 8 节会逐条展开）：

4. 分布漂移：问题的名字

先给这个现象一个准确的名字。

分布漂移在监督学习里也存在（跨域泛化、OOD 检测都在处理它），但那里它是一个外生的、偶然的麻烦：数据集收得不好、部署环境变了。而在控制问题里，它是内生的、必然的——

写成一行：我们优化的是

而且 $p_{\text{data}}(\mathbf{o}_t) \neq p_{\pi_\theta}(\mathbf{o}_t)$。更糟的是，$p_{\pi_\theta}$ 依赖于 $\theta$，所以每次你更新参数，测试分布就跟着变——这是一个移动的靶子。

5. 到底能有多糟：$O(\epsilon H^2)$ 的完整推导

这一节是本讲的技术核心。我们要把上面的直觉变成一个定量的、可以讨论的界。

5.1 先说清楚理论能给什么、不能给什么

请把这段话记牢。下面推出的 $O(\epsilon H^2)$ 是最坏情况上界，不是对现实的预测。它的价值在于告诉你「误差随时域二次增长」这个标度关系，以及问题的结构性来源。第 6 节会专门讨论它有多悲观。

5.2 设定：代价函数与犯错概率

为简单起见，全部在完全可观测设定下讨论（$\mathbf{o}_t = \mathbf{s}_t$）。假设数据由一个好策略 $\pi^\star(\mathbf{s}_t)$ 产生，它是确定性的：在状态 $\mathbf{s}$ 上，正确动作就是 $\pi^\star(\mathbf{s})$。定义 0-1 代价：

也就是说：每犯一次错，付出 1 单位代价。这是一个很粗糙的代价函数（它认为「稍微打偏一点」和「一头撞上去」一样糟），但正因为粗糙，它给出的界才是最坏情况的界。

把这一步写全：

5.3 我们要界定的量：期望犯错总数

整条轨迹上的总代价，就是把每个时刻的期望代价加起来。注意状态要从策略自己诱导的分布 $p_{\pi_\theta}(\mathbf{s}_t)$ 里采：

5.4 第一版：最坏情况的直观论证

先做一个更强、更不现实的假设，好把直觉建立起来：

注意这里是「对训练集里的每一个状态，犯错概率都不超过 $\epsilon$」，这比「平均犯错概率不超过 $\epsilon$」强得多。即便如此，结论仍然很糟。

逐步展开这个论证。考虑第 $t$ 步：

• 如果前 $t-1$ 步一次都没犯错（概率至少 $(1-\epsilon)^{t-1}$），那么此刻你还在训练分布上，第 $t$ 步的犯错概率 $\le \epsilon$，而且往后的每一步依然受 $\epsilon$ 约束。
• 如果犯过至少一次错（概率 $\le 1-(1-\epsilon)^{t-1}$），你已经不在训练分布里了，最坏情况下剩下的每一步都犯错，代价为 1。

于是，「第一次犯错发生在第 $t$ 步」这个事件的概率大约是 $\epsilon$（乘上前面都没错的概率，$\le\epsilon$），而一旦在第 $t$ 步首次犯错，后续 $H-t$ 步全部作废，贡献代价 $H-t$。把所有可能的首错时刻加起来：

这就是幻灯片上「$H$ 个项，每项 $O(\epsilon H)$，合计 $O(\epsilon H^2)$」的含义。

5.5 一个具体数值：为什么 99.9% 的准确率救不了你

假设你训练出一个非常好的驾驶策略，在训练分布上每一步的犯错概率只有 $\epsilon = 10^{-3}$（千分之一，按 10 Hz 控制频率算，相当于平均每 100 秒才失误一次，听起来相当靠谱）。

这张表说明三件事。第一，短时域任务上 BC 很好用——这解释了为什么「抓取一个物体」这类几秒钟的任务用 BC 效果不错。第二，长时域任务上界迅速退化到平凡（犯错数不可能超过 $H$，所以界一旦超过 $H$ 就没信息量了）。第三，也是最重要的：要想在 $H$ 变大时保持性能，$\epsilon$ 必须以 $1/H^2$ 的速度下降，而泛化误差通常只能随数据量 $N$ 以 $O(1/\sqrt{N})$ 或 $O(1/N)$ 下降。这就回答了幻灯片上的第二个问题：问题不会随着数据变多而自动消失，只会变得更贵。

6. 更一般的分析：用总变差距离做完整证明

上一节的假设「对训练集里每一个状态犯错概率都 $\le\epsilon$」太强了：真实的监督学习只能保证平均误差小。这一节把假设换成更弱、更现实的版本，重新做一遍推导——结论仍然是 $O(\epsilon H^2)$，而且这次是严格的。

6.1 更弱的假设

用话说：「如果我们从训练分布里采一个状态，策略不太可能犯错。」这正是监督学习的泛化保证所能给出的东西——它对个别的、罕见的困难状态不作任何承诺。

6.2 一个有用的分解

核心技巧是把策略诱导的状态分布 $p_{\pi_\theta}(\mathbf{s}_t)$ 按「到 $t$ 时刻为止有没有犯过错」分成两块：

6.3 两个分布差多远：总变差距离

引入总变差距离（total variation divergence）：

「$\le 1$」是它最重要的性质：无论两个分布差得多离谱，TV 距离最多是 1（当两者支撑集完全不相交时取到）。这就是我们用来给 $p_{\text{mistake}}$ 兜底的工具。

把这几步全部写出来。

这个中间结论本身就很有信息量：策略的状态分布与训练分布的偏离，随时间线性增长，斜率是 $\epsilon$。$t$ 越大偏得越远，这是「误差累积」最直接的数学表述。

6.4 从分布距离到代价

现在回到我们真正关心的量——期望犯错总数。

7. 这个界有多悲观？以及一个反直觉的悖论

拿到一个 $O(\epsilon H^2)$ 的界之后，正确的态度不是「所以 BC 没救了」，而是去问：这个最坏情况在现实中有多典型？

7.1 为什么最坏情况通常不会发生

$O(\epsilon H^2)$ 的推导里有一个隐含的最坏假设：一旦离开训练分布，就再也回不来（$p_{\text{mistake}}$ 与 $p_{\text{train}}$ 完全不相交，TV 距离取到上界 1）。真实的物理系统很少这么残酷：

• 大多数控制问题有吸引子结构：车道保持任务里，即使方向盘打偏几度，路面几何和后续的正确动作也会把你拉回车道中心；机械臂的位置误差在下一步就能被纠正。
• 动力学往往是耗散的、稳定的：小扰动会衰减而不是放大。走钢丝之所以是最坏情况的完美隐喻，正因为它是罕见的不稳定系统。
• 状态分布的重叠往往并不小：车偏离 5 厘米时看到的画面，与在中心线上看到的画面在特征空间里非常接近，网络的泛化能力本身就提供了一定的鲁棒性。

7.2 但「能恢复」不等于「学得会恢复」

这是 Levine 特别强调的一点，也是许多人第一次读这套材料时漏掉的。系统物理上可以从偏离态恢复，与策略知道怎么恢复，是两件完全不同的事。而 BC 学不到恢复行为的原因非常直接：演示数据里没有恢复行为。

一个优秀的人类司机从不压线，所以数据集里 $p_{\text{train}}$ 的支撑集根本不包含「车已经压线」这个状态；网络在这个输入上的输出是纯粹的外插，没有任何监督信号约束过它。就算真实世界允许你打方向盘回正，策略也不知道这件事。

这个洞见有非常具体的工程后果，在今天的机器人数据采集里是常识：

• 主动注入噪声：让演示者在带噪声的遥操作下工作（或对专家动作加小扰动），迫使他不断做微观纠正，这些纠正就成了训练信号。DART（Laskey 等人，2017）就是把这个想法系统化的方法。
• 合成偏离态：NVIDIA 的三摄像头就是最经典的例子——不改变演示者的行为，而是用几何变换伪造偏离视角，再解析地推算出对应的修正动作。
• 不要过滤掉「不完美」的演示：直觉上你会想只保留最漂亮的那些轨迹，但对 BC 来说，含有小失误 + 纠正的轨迹是宝贵的，不该扔。

8. DAgger：从根上修好分布漂移

8.1 换一个方向想

问题是 $p_{\text{data}}(\mathbf{o}_t) \neq p_{\pi_\theta}(\mathbf{o}_t)$。要修好它，可以从两端下手：

• 改 $p_{\pi_\theta}$：让策略尽量别偏离数据分布。这需要更强的模型、更好的表示、更多数据——本质上是在把 $\epsilon$ 往小里压。有用，但正如第 5 节算过的，代价随 $H$ 二次增长。
• 改 $p_{\text{data}}$：让训练数据来自策略自己会访问到的分布。这才是 DAgger 的思路。

8.2 算法

为什么这样就修好了？因为随着迭代进行，$\mathcal{D}$ 里越来越大的比例来自 $p_{\pi_\theta}$ 本身，训练分布逐步收敛到策略的执行分布。当 $p_{\text{data}} \to p_{\pi_\theta}$ 时，第 6 节推导里那个 $2D_{\mathrm{TV}} \le 2\epsilon t$ 的偏移项趋近于 0，只剩下主项 $\sum_t \epsilon = \epsilon H$。误差界从 $O(\epsilon H^2)$ 回到了监督学习的 $O(\epsilon H)$——这是 Ross 等人论文的核心定理（严格版本用 no-regret 在线学习的框架给出，且要求专家可查询的次数随迭代增长）。

8.3 DAgger 的真正麻烦：第 3 步

这一步在实践中有三个层面的困难：

8.4 工程上更常用的变体：人类接管

这个变体在人机工效上好太多：人类不需要对着截图猜，而是直接接过控制权继续开，标签是他在真实闭环情境下的自然操作，质量高得多。今天绝大多数机器人公司的数据飞轮就是这么转的。

8.5 DAgger 的最小实现

def dagger(env, expert, obs_dim, act_dim, n_iters=10, rollouts_per_iter=20):
    """expert(obs) -> 正确动作；在仿真里通常是一个已有的控制器，
    在真机上就是「请人类标注 / 接管」这一步。"""
    obs_buf, act_buf = [], []

    # 第 0 轮：纯 BC，用专家自己跑出来的数据
    for _ in range(rollouts_per_iter):
        o, done = env.reset(), False
        while not done:
            a = expert(o)                    # 专家演示
            obs_buf.append(o); act_buf.append(a)
            o, _, done, _ = env.step(a)      # 环境由专家动作驱动

    policy = None
    for it in range(n_iters):
        # 1. 在聚合后的数据集上重新训练（每轮从头训，避免早期数据的过拟合遗留）
        policy = behavior_cloning(torch.stack(obs_buf), torch.stack(act_buf),
                                  obs_dim, act_dim)

        # 2&3. 跑「学生」策略采状态，但标签来自专家 —— 这两行是 DAgger 的全部秘密
        for _ in range(rollouts_per_iter):
            o, done = env.reset(), False
            while not done:
                a_student = policy.act(o, deterministic=True)
                a_expert  = expert(o)        # 专家对学生访问到的状态给出正确动作
                obs_buf.append(o); act_buf.append(a_expert)
                o, _, done, _ = env.step(a_student)   # 注意：环境由「学生」驱动！
        # 4. 聚合已经在上面的 append 里完成了
        print(f"DAgger iter {it}: dataset size = {len(obs_buf)}")
    return policy

请对照两处细节。第一，内层循环里 env.step(a_student) 用的是学生的动作，而 act_buf.append(a_expert) 存的是专家的动作——状态由学生的分布产生，标签由专家提供，这一行错位就是 DAgger 的全部内容。第二，每轮都在聚合后的完整数据集上重训，而不是只用新数据微调；「Aggregation」这个名字就是从这里来的，它保证了策略不会在迭代中遗忘早期的好行为（对应 no-regret 在线学习里的 Follow-the-Leader）。

常见的实用变体还有 $\beta$-混合：第 $i$ 轮用 $\pi_i = \beta_i \pi^\star + (1-\beta_i)\pi_\theta$ 去采数据，$\beta_i$ 从 1 递减到 0。早期主要由专家驾驶（安全、状态不至于太离谱），后期完全交给学生。原论文推荐 $\beta_i$ 指数衰减，并证明只要 $\frac{1}{N}\sum_i \beta_i \to 0$，no-regret 保证依然成立。

9. 不改算法，怎么让 BC 好用

DAgger 需要交互式专家，这个前提在很多场景下无法满足（你手上只有一批别人采好的离线数据）。那么在不改算法的前提下，还有哪些手段？Levine 给出的清单有四条，逐条展开。

9.1 让模型强到几乎不犯错

既然界是 $O(\epsilon H^2)$，把 $\epsilon$ 压到足够小当然也管用。这条路线在今天的机器人基础模型（RT-1、RT-2、Octo、$\pi_0$ 一类）上被推到了极致：几十亿参数、上千小时的多机器人数据、强大的视觉语言预训练。

但要看清这条路的两个前提。其一，$\epsilon$ 必须以 $1/H^2$ 的速度下降才能维持性能，所以模型规模换来的收益是被时域平方稀释的；这解释了为什么大模型在「拿起杯子」这种几秒钟的任务上表现惊艳，在「整理整个厨房」这种几分钟的长程任务上仍然会崩。其二，拟合专家分布本身也很难——人类演示是多模态且非马尔可夫的，用单峰高斯去拟合会得到「两个正确动作的平均值」这种最糟的结果。这正是下一讲要用扩散策略、动作分块等手段解决的问题。

9.2 聪明地采集与增强数据

这是投入产出比最高的一条，也是第 3 节 NVIDIA 案例和第 7 节悖论的直接推论。核心目标只有一个：让 $p_{\text{train}}$ 覆盖策略执行时会漂到的区域，并在那些区域提供正确的纠偏标签。

9.3 历史信息与序列模型

回到第 1 节的部分可观测问题：若 $\mathbf{o}_t$ 不满足马尔可夫性，单帧策略 $\pi_\theta(\mathbf{a}_t|\mathbf{o}_t)$ 在原理上就学不到最优行为。自然的补救是让策略读入整段历史：

实现上有三种常见做法：帧堆叠（把最近 $k$ 帧沿通道维拼起来，DQN 打 Atari 就是这么干的，简单粗暴但只能看到固定长度的过去）、循环网络（LSTM/GRU 维护一个隐状态，理论上能记住任意长的历史）、以及今天的主流Transformer（把观测序列当 token 序列，用因果注意力，还能顺便处理语言指令）。

9.4 多任务学习

最后一条乍看很奇怪：同时学多个任务，每个任务反而学得更好。

设想训练一个导航策略。方案 A：只收集「从各处到达目标点 $\mathbf{p}_1$」的演示。方案 B：收集「到达 $\mathbf{p}_1$」「到达 $\mathbf{p}_2$」「到达 $\mathbf{p}_3$」……的演示，并把目标点作为条件输入，学一个目标条件策略（goal-conditioned policy）$\pi_\theta(\mathbf{a}_t|\mathbf{o}_t, \mathbf{g})$。

方案 B 更好，理由与第 7 节的悖论同源：去往 $\mathbf{p}_2$ 的轨迹会经过许多「对 $\mathbf{p}_1$ 任务来说属于偏离态」的状态。这些状态在方案 A 的数据里根本不存在，在方案 B 里却被别的任务顺带覆盖了。多任务数据以一种「免费」的方式把状态分布撑宽了——从 $\mathbf{p}_2$ 任务的演示里，策略学会了在那片区域该怎么动，这些知识可以迁移到 $\mathbf{p}_1$ 任务上偏离后的恢复。

这个思路还有一个更激进的版本：把任何一条轨迹的终点事后标记成「目标」，于是所有数据都变成成功的演示。这就是 hindsight relabeling / goal relabeling 的想法，本课后面讲 goal-conditioned RL 时会正式展开。

本讲小结

一页速查：

要点清单：

• 行为克隆不是强化学习，它是被用在了 i.i.d. 假设不成立的场景上的监督学习；它没有任何有效性保证。
• 失败的机制是误差累积：犯一个错就进入没见过的状态，在那里犯错概率不再受训练误差约束，于是发散。「犯错」与「跌出分布」在控制问题里是同一件事。
• 最坏情况上界 $O(\epsilon H^2)$，两个 $H$ 分别来自「有 $H$ 次跌出去的机会」和「每次跌出去平均损失 $H/2$ 步」。
• 推导的主线：0-1 代价 $\to$ 犯错概率 $\to$ 按是否犯错分解状态分布 $\to$ 用 TV 距离界定偏移（$\le\epsilon t$）$\to$「主项 + 偏移项」拆分 $\to$ 求和得 $O(\epsilon H^2)$。这个「主项 + 分布偏移项」的套路后面会反复出现。
• 这是最坏情况界。现实中系统往往能从错误中恢复，所以 BC 常常能用；但系统能恢复 ≠ 策略学得会恢复，除非数据里有恢复行为。
• DAgger 是唯一从根上解决问题的方法（把界降回 $O(\epsilon H)$），代价是需要交互式专家；工程上常用「人类接管」变体，人机工效好但牺牲了部分理论保证。
• 不改算法的四条路：更强的模型（压 $\epsilon$）、更聪明的数据采集与增强（压 $D_{\mathrm{TV}}$）、历史/序列模型（应对部分可观测，但小心因果混淆）、多任务学习（用别的任务免费撑宽状态分布）。
• 下一讲继续：DAgger 的深入变体、非马尔可夫策略的因果混淆、以及人类演示多模态性的建模（混合密度、隐变量模型、扩散策略、自回归离散化）。

延伸阅读

本讲直接引用

• ALVINN: An Autonomous Land Vehicle in a Neural Network（Pomerleau, 1989）— 行为克隆的开山之作，5 个隐藏单元开真车。读它是为了看清 BC 的范式 35 年没变过。
• End to End Learning for Self-Driving Cars (Bojarski et al., 2016) — NVIDIA 的端到端驾驶。重点看第 4 节的数据采集：三摄像头 + 转向角修正才是它能跑起来的真正原因。
• A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning (Ross, Gordon & Bagnell, 2011) — DAgger 原论文，本讲 $O(\epsilon H^2)$ 与 $O(\epsilon H)$ 两个界的严格版本都在这里。定理 2.1 和 3.2 值得逐行读。
• Learning Monocular Reactive UAV Control in Cluttered Natural Environments (Ross et al., 2013) — 幻灯片里那段无人机穿林视频的出处，DAgger 在真实机器人上的完整案例。

让 BC 变得可用

• DART: Noise Injection for Robust Imitation Learning (Laskey et al., 2017) — 把「注入噪声让演示者做纠正」系统化，是第 7 节那个悖论最直接的算法化。
• HG-DAgger: Interactive Imitation Learning with Human Experts (Kelly et al., 2018) — 第 8.4 节「人类接管」变体的正式版本，讨论了它与原始 DAgger 在保证上的差异。
• Causal Confusion in Imitation Learning (de Haan, Jayaraman & Levine, 2019) — 「给策略更多信息反而更差」的系统研究，刹车指示灯的例子就出自这里。读完再回看 9.3 节会有新体会。

现代的 BC：大模型与多模态动作

• RT-1: Robotics Transformer for Real-World Control at Scale (Brohan et al., 2022) — 「用非常强的模型把 $\epsilon$ 压小」这条路线的代表作，也是幻灯片总结页里那张网络图的出处。
• Diffusion Policy: Visuomotor Policy Learning via Action Diffusion (Chi et al., 2023) — 用扩散模型表示多模态动作分布，直接针对 2.2 节末尾提到的「平均值撞树」问题。下一讲的主角之一。
• Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware (Zhao et al., 2023) — ACT / 动作分块（action chunking）：一次预测一段动作序列，等价于把有效时域 $H$ 缩短，从误差累积的角度看非常自然。