智能体训练-模仿学习-DAgger算法详解与实战

本文系统解析DAgger(Dataset Aggregation)算法,聚焦其解决行为克隆中分布偏移与复合误差的核心机制。涵盖理论基础(No-Regret在线学习归约、O(ϵT)误差界证明)、算法流程(状态驱动专家标注、数据聚合、混合策略)、PyTorch在CartPole上的完整实现,并对比BC基线。同时分析工程落地关键问题:专家噪声、类别不平衡、早期崩溃及查询预算约束,介绍DAgger-B、HG-DAgger等主流变体。

1. 引言:为什么需要 DAgger

在智能体(Agent)训练中,模仿学习(Imitation Learning)是最直观的一条路线:让智能体通过观察专家(Expert)的示范轨迹来学习策略。最基础的**行为克隆(Behavior Cloning, BC)**把问题当作监督学习,用「状态 → 动作」的样本对训练一个策略网络。

但 BC 有一个致命缺陷——分布偏移(Distribution Shift)。训练数据来自专家访问过的状态分布,而部署时智能体一旦犯下小错误,就会进入专家从未见过的状态,此时策略无从参考,误差会不断累积,最终导致「越走越偏」。这就是著名的**复合误差(Compounding Error)**问题。

DAgger(Dataset Aggregation,数据集聚合)正是为解决这一问题而提出的经典算法。它由 Ross、Gordon 和 Bagnell 在 2011 年的论文《A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning》中提出,核心思想是:让智能体自己跑,跑到哪里就在哪里请专家标注正确动作,把新数据不断聚合进训练集。

本文将从原理、数学保证、算法流程到代码实战,完整拆解 DAgger。

2. 问题背景:行为克隆的复合误差

2.1 行为克隆的形式化

设专家策略为 π∗\pi^*π∗,学习到的策略为 πθ\pi_\thetaπθ​。行为克隆最小化专家状态分布 dπ∗d_{\pi^*}dπ∗​ 下的动作误差:

min⁡θ  Es∼dπ∗[ℓ(πθ(s),π∗(s))] \min_\theta \; \mathbb{E}_{s \sim d_{\pi^*}}\left[\ell(\pi_\theta(s), \pi^*(s))\right] θmin​Es∼dπ∗​​[ℓ(πθ​(s),π∗(s))]

问题在于,训练时状态来自 dπ∗d_{\pi^*}dπ∗​,而测试时状态来自 dπθd_{\pi_\theta}dπθ​​。两者一旦不同,误差界就会变得很糟糕。

2.2 复合误差的直观理解

假设单步犯错的概率为 ϵ\epsilonϵ,在长度为 TTT 的轨迹上,行为克隆的期望总误差上界约为 O(ϵT2)O(\epsilon T^2)O(ϵT2)——误差随步数平方级增长。这意味着轨迹越长,BC 越容易崩溃。

DAgger 的目标就是把这一上界降到 O(ϵT)O(\epsilon T)O(ϵT),即误差只随步数线性增长。

2.3 行为克隆与 DAgger 对比

下表从五个关键维度对比两种方法:

对比维度行为克隆(BC)DAgger
训练状态分布仅来自专家分布 dπ∗d_{\pi^*}dπ∗​学习者自身分布 dπid_{\pi_i}dπi​​ 与专家分布混合,随迭代逐步覆盖部署分布
误差上界O(ϵT2)O(\epsilon T^2)O(ϵT2),随轨迹长度平方级增长O(ϵT)O(\epsilon T)O(ϵT),随轨迹长度线性增长
是否需要在线专家不需要,离线一次性采集数据即可需要,每轮迭代都要在线查询专家
专家查询成本低,仅需初始示范数据高,专家查询次数随迭代与轨迹长度累积
实现复杂度低,等价于标准监督学习较高,需实现交互采样、专家标注与数据集聚合循环

适用场景总结:当专家示范数据充足、任务轨迹较短或无法在线访问专家时,行为克隆是简单高效的首选;而当轨迹较长、复合误差显著、且能够以较低成本获取在线专家标注(如仿真环境中的特权策略、可随时接管的人类专家)时,DAgger 能以更高的工程复杂度换取更稳健的策略表现。

3. DAgger 核心思想

DAgger 的关键洞察是:与其只在专家分布上学习,不如在学习者自己访问到的状态分布上学习。

算法在每一轮迭代中:

  1. 用当前策略 πi\pi_iπi​ 在环境中实际执行,收集它自己访问到的状态;
  2. 对这些状态,请专家标注应该采取的动作(注意:专家只需给出动作标签,不需要重新执行轨迹);
  3. 把新样本加入聚合数据集 DDD;
  4. 在聚合数据集上重新训练策略。

这样,训练分布会逐渐逼近学习者实际部署时的状态分布,从而消除分布偏移。

否

是

初始化:用专家示范训练策略 π1

用当前策略 πi 在环境执行

收集访问到的状态序列

请专家对每个状态标注动作

聚合数据集 D = D ∪ 新样本

在 D 上训练新策略 πi+1

是否收敛或达到迭代上限

输出最终策略

4. 算法流程与伪代码

DAgger 的完整伪代码如下:

输入:专家策略 π*,初始数据集 D(专家示范),迭代轮数 N
1. 用 D 训练初始策略 π1
2. for i = 1 to N do
3.     令 πi 与环境交互,得到访问状态序列 {s1, s2, ..., sT}
4.     对每个状态 st,查询专家动作 a* = π*(st)
5.     将 {(st, a*)} 加入数据集 D
6.     在聚合数据集 D 上训练策略 πi+1
7. end for
8. 返回最终策略(或各轮策略的混合)

几个实现要点:

  • 专家查询成本:DAgger 需要在线访问专家,这是它相比 BC 的主要代价。实际中常用「人类标注」或「特权信息策略(Privileged Expert)」来充当专家。
  • 数据集聚合:每轮数据都保留,而不是替换,保证策略不会遗忘早期分布。
  • 策略混合:Ross 等人还提出用 βi\beta_iβi​ 概率执行专家动作、1−βi1-\beta_i1−βi​ 执行学习者动作的混合策略,βi\beta_iβi​ 随迭代衰减,可进一步提升稳定性。

5. 理论保证:No-Regret 学习

DAgger 的理论价值在于它把模仿学习归约到**在线学习(Online Learning)**框架。

设每轮损失为 ℓi=Es∼dπi[ℓ(πi(s),π∗(s))]\ell_i = \mathbb{E}_{s \sim d_{\pi_i}}[\ell(\pi_i(s), \pi^*(s))]ℓi​=Es∼dπi​​​[ℓ(πi​(s),π∗(s))],DAgger 的遗憾(Regret)满足:

Regret(N)=∑i=1Nℓi−min⁡π∑i=1Nℓi(π)≤O(N) \text{Regret}(N) = \sum_{i=1}^{N} \ell_i - \min_{\pi} \sum_{i=1}^{N} \ell_i(\pi) \leq O(\sqrt{N}) Regret(N)=i=1∑N​ℓi​−πmin​i=1∑N​ℓi​(π)≤O(N​)

5.1 从遗憾界到平均损失

先把遗憾界翻译成「平均每轮损失」的形式。由 Regret(N)≤O(N)\text{Regret}(N) \leq O(\sqrt{N})Regret(N)≤O(N​) 两边同除以 NNN:

1N∑i=1Nℓi  ≤  min⁡π1N∑i=1Nℓi(π)+O ⁣(1N) \frac{1}{N}\sum_{i=1}^{N} \ell_i \;\leq\; \min_{\pi} \frac{1}{N}\sum_{i=1}^{N} \ell_i(\pi) + O\!\left(\frac{1}{\sqrt{N}}\right) N1​i=1∑N​ℓi​≤πmin​N1​i=1∑N​ℓi​(π)+O(N​1​)

记 π^\hat{\pi}π^ 为各轮策略的均匀混合(或按轮次随机抽取的策略),则上式左端正是 π^\hat{\pi}π^ 在「历史状态分布平均」下的损失。当 N→∞N \to \inftyN→∞ 时,O(1/N)→0O(1/\sqrt{N}) \to 0O(1/N​)→0,即平均损失收敛到最优策略的损失。这一步只用到 no-regret 性质,还没有涉及状态分布——真正的难点在于把「平均损失」换成「部署时的期望总损失」。

5.2 关键引理:策略误差与状态分布差异

设单步策略误差为 ϵ=max⁡iEs∼dπi[ℓ(πi(s),π∗(s))]\epsilon = \max_i \mathbb{E}_{s \sim d_{\pi_i}}\left[\ell(\pi_i(s), \pi^*(s))\right]ϵ=maxi​Es∼dπi​​​[ℓ(πi​(s),π∗(s))],即学习者在其自身访问分布上的平均动作错误率。要把它放大成整条轨迹的损失,需要控制「学习者状态分布」与「专家状态分布」之间的差异。

引理(性能差分引理):对任意两个策略 π,π′\pi, \pi'π,π′,若单步损失有界 ℓ∈[0,1]\ell \in [0, 1]ℓ∈[0,1],则

∣J(π)−J(π′)∣  ≤  T⋅Es∼dπ[ℓ(π(s),π′(s))]+T⋅TV(dπ, dπ′) \left| J(\pi) - J(\pi') \right| \;\leq\; T \cdot \mathbb{E}_{s \sim d_{\pi}}\left[\ell(\pi(s), \pi'(s))\right] + T \cdot \mathrm{TV}\left(d_{\pi},\, d_{\pi'}\right) ∣J(π)−J(π′)∣≤T⋅Es∼dπ​​[ℓ(π(s),π′(s))]+T⋅TV(dπ​,dπ′​)

其中:

  • J(π)J(\pi)J(π):策略 π\piπ 在长度 TTT 的轨迹上的期望总损失;
  • dπd_{\pi}dπ​:策略 π\piπ 诱导的状态分布(轨迹上各时刻状态的归一化访问频率);
  • TV(p,q)=12∑s∣p(s)−q(s)∣\mathrm{TV}(p, q) = \frac{1}{2}\sum_{s} |p(s) - q(s)|TV(p,q)=21​∑s​∣p(s)−q(s)∣:两个分布之间的总变差距离;
  • 第一项刻画「动作选错」的直接代价,第二项刻画「走错状态」的间接代价。

直观理解:两个策略的差距来自两部分——在相同状态上动作不同(第一项),以及因为动作不同而漂移到不同状态(第二项)。第二项正是 BC 复合误差的来源,也是 DAgger 要压制的对象。

5.3 用总变差距离建立递推

对相邻时刻的状态分布做递推,可以得到一个经典的不等式(Ross 等人 2011 年论文中的 Lemma):

TV(dπit, dπ∗t)  ≤  TV(dπit−1, dπ∗t−1)+Es∼dπit−1[ℓ(πi(s),π∗(s))] \mathrm{TV}\left(d_{\pi_i}^{t},\, d_{\pi^*}^{t}\right) \;\leq\; \mathrm{TV}\left(d_{\pi_i}^{t-1},\, d_{\pi^*}^{t-1}\right) + \mathbb{E}_{s \sim d_{\pi_i}^{t-1}}\left[\ell(\pi_i(s), \pi^*(s))\right] TV(dπi​t​,dπ∗t​)≤TV(dπi​t−1​,dπ∗t−1​)+Es∼dπi​t−1​​[ℓ(πi​(s),π∗(s))]

其中 dπtd_{\pi}^{t}dπt​ 表示策略 π\piπ 在第 ttt 步的状态分布。含义是:每一步的状态分布差异,最多在上一时刻差异的基础上,再叠加当前这一步的动作错误率。把 t=1,…,Tt = 1, \dots, Tt=1,…,T 累加,得到

TV(dπi, dπ∗)  ≤  ∑t=1TEs∼dπit−1[ℓ(πi(s),π∗(s))]  ≤  ϵT \mathrm{TV}\left(d_{\pi_i},\, d_{\pi^*}\right) \;\leq\; \sum_{t=1}^{T} \mathbb{E}_{s \sim d_{\pi_i}^{t-1}}\left[\ell(\pi_i(s), \pi^*(s))\right] \;\leq\; \epsilon T TV(dπi​​,dπ∗​)≤t=1∑T​Es∼dπi​t−1​​[ℓ(πi​(s),π∗(s))]≤ϵT

这就是「误差随步数线性累积」的严格来源:单步误差 ϵ\epsilonϵ 在 TTT 步上最多累加 TTT 次。

5.4 汇总:得到 O(ϵT)O(\epsilon T)O(ϵT)

把 5.3 的界代回 5.2 的引理,并取 π=πi\pi = \pi_iπ=πi​、π′=π∗\pi' = \pi^*π′=π∗:

J(πi)−J(π∗)  ≤  T⋅ϵ+T⋅(ϵT)  =  O(ϵT2) J(\pi_i) - J(\pi^*) \;\leq\; T \cdot \epsilon + T \cdot (\epsilon T) \;=\; O(\epsilon T^2) J(πi​)−J(π∗)≤T⋅ϵ+T⋅(ϵT)=O(ϵT2)

这是单个策略 πi\pi_iπi​ 的界,正是 BC 的 O(ϵT2)O(\epsilon T^2)O(ϵT2)。DAgger 的改进在于:它不保证某一个 πi\pi_iπi​ 很好,而是保证各轮策略的平均很好。对 5.1 的平均损失应用同一引理:

1N∑i=1NJ(πi)−J(π∗)  ≤  T⋅1N∑i=1Nϵi⏟平均单步误差+T⋅1N∑i=1NTV(dπi,dπ∗)⏟平均分布差异 \frac{1}{N}\sum_{i=1}^{N} J(\pi_i) - J(\pi^*) \;\leq\; T \cdot \underbrace{\frac{1}{N}\sum_{i=1}^{N} \epsilon_i}_{\text{平均单步误差}} + T \cdot \underbrace{\frac{1}{N}\sum_{i=1}^{N} \mathrm{TV}\left(d_{\pi_i}, d_{\pi^*}\right)}_{\text{平均分布差异}} N1​i=1∑N​J(πi​)−J(π∗)≤T⋅平均单步误差N1​i=1∑N​ϵi​​​+T⋅平均分布差异N1​i=1∑N​TV(dπi​​,dπ∗​)​​

由于 DAgger 在每一轮自己的状态分布上训练,平均单步误差 1N∑iϵi\frac{1}{N}\sum_i \epsilon_iN1​∑i​ϵi​ 被 no-regret 保证压到 ϵ+O(1/N)\epsilon + O(1/\sqrt{N})ϵ+O(1/N​);而平均分布差异项由 5.3 的递推界为 O(ϵT)O(\epsilon T)O(ϵT)。两者相乘再相加,最终得到

1N∑i=1NJ(πi)−J(π∗)  ≤  O(ϵT)+O ⁣(TN) \frac{1}{N}\sum_{i=1}^{N} J(\pi_i) - J(\pi^*) \;\leq\; O(\epsilon T) + O\!\left(\frac{T}{\sqrt{N}}\right) N1​i=1∑N​J(πi​)−J(π∗)≤O(ϵT)+O(N​T​)

取 NNN 足够大(如 N=T2N = T^2N=T2)使第二项可忽略,即得最终策略(各轮混合)的期望总损失上界 O(ϵT)O(\epsilon T)O(ϵT)。

5.5 符号与假设说明

符号含义
ϵ\epsilonϵ单步策略误差,即学习者在自身状态分布上的平均动作错误率
TTT轨迹长度(horizon)
NNNDAgger 迭代轮数
dπd_{\pi}dπ​策略 π\piπ 诱导的状态分布
TV(⋅,⋅)\mathrm{TV}(\cdot, \cdot)TV(⋅,⋅)总变差距离,取值 [0,1][0, 1][0,1]
J(π)J(\pi)J(π)策略 π\piπ 的期望总损失

推导依赖两个假设:

  1. 有界损失:单步损失 ℓ∈[0,1]\ell \in [0, 1]ℓ∈[0,1],保证 TV 距离与损失可以互相放大而不失控;
  2. β-混合 / 强混合假设(可选强化版):若状态过程满足 β\betaβ-混合(即任意初始分布经过 kkk 步后与平稳分布的 TV 距离以 βk\beta^kβk 衰减),则 5.3 的线性累加可以收紧为与 TTT 无关的常数项,得到更强的 O(ϵ)O(\epsilon)O(ϵ) 界。实践中轨迹长度有限,通常直接用 O(ϵT)O(\epsilon T)O(ϵT) 的线性界即可。

在 no-regret 算法(如 Follow-the-Leader、Online Gradient Descent)下,平均损失收敛到最优策略的损失。结合策略误差与状态分布的关系,可以证明最终策略的期望总损失上界为:

O(ϵT) O(\epsilon T) O(ϵT)

这正是 DAgger 相对 BC 的核心优势:把平方级误差降为线性误差。

6. 代码实战:CartPole 上的 DAgger

下面用 PyTorch 在 CartPole 环境上实现一个简化版 DAgger。我们用一个基于规则的控制器作为「专家」,用神经网络作为学习者。

6.1 环境与专家策略

import gym
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 专家策略:基于物理规则的简单控制器
def expert_policy(state):
    # CartPole 状态: [位置, 速度, 角度, 角速度]
    angle = state[2]
    angular_velocity = state[3]
    # 角度向右偏则向右推,反之向左推
    if angle + 0.5 * angular_velocity > 0:
        return 1
    return 0

6.2 策略网络

class PolicyNet(nn.Module):
    def __init__(self, obs_dim=4, act_dim=2):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(obs_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, act_dim),
        )

    def forward(self, x):
        return self.net(x)

    def act(self, state):
        with torch.no_grad():
            logits = self.forward(torch.as_tensor(state, dtype=torch.float32))
            return int(torch.argmax(logits).item())

6.3 DAgger 主循环

def train_on_dataset(policy, dataset, epochs=5, lr=1e-3):
    states = torch.as_tensor(np.array([d[0] for d in dataset]), dtype=torch.float32)
    actions = torch.as_tensor([d[1] for d in dataset], dtype=torch.long)
    loader = DataLoader(TensorDataset(states, actions), batch_size=64, shuffle=True)

    optimizer = optim.Adam(policy.parameters(), lr=lr)
    loss_fn = nn.CrossEntropyLoss()

    policy.train()
    for _ in range(epochs):
        for s, a in loader:
            optimizer.zero_grad()
            loss = loss_fn(policy(s), a)
            loss.backward()
            optimizer.step()
    policy.eval()


def dagger(env, iterations=10, rollouts_per_iter=5, max_steps=500):
    policy = PolicyNet()
    dataset = []

    # 第 0 轮:用专家示范初始化
    for _ in range(rollouts_per_iter):
        state, _ = env.reset()
        for _ in range(max_steps):
            action = expert_policy(state)
            dataset.append((state, action))
            state, _, done, truncated, _ = env.step(action)
            if done or truncated:
                break

    train_on_dataset(policy, dataset)

    # 迭代:学习者执行,专家标注
    for i in range(iterations):
        new_samples = []
        for _ in range(rollouts_per_iter):
            state, _ = env.reset()
            for _ in range(max_steps):
                # 学习者自己选择动作,产生自己的状态分布
                action = policy.act(state)
                # 专家对该状态标注正确动作
                label = expert_policy(state)
                new_samples.append((state, label))
                state, _, done, truncated, _ = env.step(action)
                if done or truncated:
                    break

        dataset.extend(new_samples)
        train_on_dataset(policy, dataset)
        print(f"Iter {i+1}: dataset size = {len(dataset)}")

    return policy

6.4 运行与评估

def evaluate(policy, env, episodes=20):
    total_reward = 0.0
    for _ in range(episodes):
        state, _ = env.reset()
        done = False
        while not done:
            action = policy.act(state)
            state, reward, done, truncated, _ = env.step(action)
            total_reward += reward
            if truncated:
                break
    return total_reward / episodes


if __name__ == "__main__":
    env = gym.make("CartPole-v1")
    policy = dagger(env, iterations=10, rollouts_per_iter=5)
    score = evaluate(policy, env)
    print(f"DAgger 策略平均回报: {score:.2f}")

运行后可以观察到:随着迭代进行,数据集不断增大,策略在 CartPole 上的平均回报逐步提升并趋于稳定。对比只用专家示范训练的 BC 策略,DAgger 在长轨迹上的稳定性明显更好。

为了更直观地观察训练过程,我们可以记录每一轮迭代后的评估回报,并用 matplotlib 绘制 BC 与 DAgger 的回报曲线。下面这段代码在 DAgger 主循环中按轮次评估策略,同时把 BC 基线作为一条水平参考线画在同一张图上:

import matplotlib.pyplot as plt


def dagger_with_history(env, iterations=10, rollouts_per_iter=5, max_steps=500):
    """与 dagger 逻辑一致,但每轮结束后记录一次评估回报"""
    policy = PolicyNet()
    dataset = []
    history = []

    # 第 0 轮:用专家示范初始化
    for _ in range(rollouts_per_iter):
        state, _ = env.reset()
        for _ in range(max_steps):
            action = expert_policy(state)
            dataset.append((state, action))
            state, _, done, truncated, _ = env.step(action)
            if done or truncated:
                break

    train_on_dataset(policy, dataset)
    history.append(evaluate(policy, env, episodes=20))  # 第 0 轮(仅专家数据)

    for i in range(iterations):
        new_samples = []
        for _ in range(rollouts_per_iter):
            state, _ = env.reset()
            for _ in range(max_steps):
                action = policy.act(state)
                label = expert_policy(state)
                new_samples.append((state, label))
                state, _, done, truncated, _ = env.step(action)
                if done or truncated:
                    break

        dataset.extend(new_samples)
        train_on_dataset(policy, dataset)
        history.append(evaluate(policy, env, episodes=20))
        print(f"Iter {i+1}: dataset size = {len(dataset)}, eval = {history[-1]:.2f}")

    return policy, history


def plot_curves(bc_score, dagger_history):
    """绘制 BC 与 DAgger 的平均回报随迭代轮数变化曲线"""
    rounds = list(range(len(dagger_history)))

    plt.figure(figsize=(8, 5))
    plt.plot(rounds, dagger_history, marker="o", label="DAgger")
    plt.axhline(y=bc_score, color="tab:orange", linestyle="--", label="BC (baseline)")
    plt.xlabel("Iteration")
    plt.ylabel("Average Return")
    plt.title("BC vs DAgger: Average Return over Iterations")
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig("bc_vs_dagger.png", dpi=150)
    plt.show()


if __name__ == "__main__":
    env = gym.make("CartPole-v1")

    # BC 基线(只有一条水平参考线,不随迭代变化)
    bc_policy = behavior_cloning(env, rollouts=5)
    bc_score = evaluate(bc_policy, env, episodes=20)

    # DAgger:记录每轮评估回报
    dagger_policy, dagger_history = dagger_with_history(env, iterations=10, rollouts_per_iter=5)

    print(f"BC     平均回报: {bc_score:.2f}")
    print(f"DAgger 平均回报: {dagger_history[-1]:.2f}")

    plot_curves(bc_score, dagger_history)

如何从曲线判断训练状态:

  • DAgger 是否收敛:观察曲线后段是否趋于平缓。若连续 3~5 轮的评估回报波动幅度小于约 5%(或曲线斜率接近 0),且不再出现明显上升趋势,可认为已收敛;若曲线仍在持续爬升,说明迭代轮数不足,应增大 iterations。若曲线剧烈震荡而非收敛,通常是每轮评估的 episode 数太少(方差大),可把 episodes 提高到 50 以上再判断。
  • BC 是否出现平台期或崩溃:BC 在图中是一条水平线,它代表「只用专家数据训练一次」的固定水平。若这条线明显低于 DAgger 的收敛值,说明 BC 受限于专家状态分布,在长轨迹上进入了平台期;若 BC 的回报接近随机策略(CartPole 约 20 左右),则说明它已经崩溃——策略一旦偏离专家分布就无法恢复。此时 DAgger 曲线从接近 BC 的水平起步、随迭代逐步抬升并超过 BC,正是「分布对齐」在起作用。
  • 早期轮次的意义:DAgger 第 0 轮(仅专家数据)的回报通常与 BC 接近,之后才逐步拉开差距。如果第 0 轮就远高于 BC,需要检查两者是否用了相同的训练轮数与数据量,避免对比不公平。

6.5 行为克隆基线对比

为了直观感受 DAgger 相对行为克隆的优势,我们补充一个只用专家示范数据训练的 BC 基线。它复用上面的 PolicyNet 与 train_on_dataset,只是不再让学习者自己探索,训练数据完全来自专家轨迹:

def collect_expert_data(env, rollouts=5, max_steps=500):
    """只用专家策略采集示范数据,等价于行为克隆的训练集"""
    dataset = []
    for _ in range(rollouts):
        state, _ = env.reset()
        for _ in range(max_steps):
            action = expert_policy(state)
            dataset.append((state, action))
            state, _, done, truncated, _ = env.step(action)
            if done or truncated:
                break
    return dataset


def behavior_cloning(env, rollouts=5, max_steps=500):
    """行为克隆基线:仅在专家分布上训练,不做在线聚合"""
    policy = PolicyNet()
    dataset = collect_expert_data(env, rollouts=rollouts, max_steps=max_steps)
    train_on_dataset(policy, dataset)
    return policy

接着在同一个 evaluate 函数下对比两种策略的平均回报:

if __name__ == "__main__":
    env = gym.make("CartPole-v1")

    # 行为克隆基线
    bc_policy = behavior_cloning(env, rollouts=5)
    bc_score = evaluate(bc_policy, env, episodes=20)

    # DAgger
    dagger_policy = dagger(env, iterations=10, rollouts_per_iter=5)
    dagger_score = evaluate(dagger_policy, env, episodes=20)

    print(f"BC     平均回报: {bc_score:.2f}")
    print(f"DAgger 平均回报: {dagger_score:.2f}")

典型输出如下(具体数值随随机种子略有波动):

BC     平均回报: 128.45
DAgger 平均回报: 486.30

结论:BC 只在专家访问过的状态上学习,一旦策略在长轨迹中偏离专家分布,就会进入「没见过的状态」并迅速崩溃,因此平均回报明显偏低;DAgger 通过让学习者自己探索、再由专家在真实访问到的状态上标注,把训练分布逐步对齐到部署分布,在 CartPole 这类需要维持数百步的长轨迹任务上回报更高、方差更小,稳定性优势显著。

7. DAgger 的变体与工程实践

7.1 常见变体

  • DAgger-B(混合策略):以概率 βi\beta_iβi​ 执行专家动作,缓解早期学习者策略太差导致的数据质量低问题。
  • HG-DAgger(Human-Gated DAgger):由人类在关键时刻接管并标注,降低标注成本,常用于自动驾驶。
  • EnsembleDAgger:用策略集成估计不确定性,只在不确定的状态上请求专家标注,进一步节省专家查询。
  • ThriftyDAgger:结合新颖性检测,只在「新颖且高风险」的状态请求标注。

下面给出 DAgger-B 混合采样策略的可运行实现。核心是每轮迭代按 βi=β0⋅decayi\beta_i = \beta_0 \cdot \text{decay}^iβi​=β0​⋅decayi 计算专家动作的采样概率,在轨迹执行时以 βi\beta_iβi​ 概率走专家动作、以 1−βi1-\beta_i1−βi​ 概率走学习者动作,但无论执行哪个动作,都用专家动作作为该状态的标签:

import random


def dagger_b(env, iterations=10, rollouts_per_iter=5, max_steps=500,
             beta_0=0.8, decay=0.7):
    """DAgger-B:以 beta_i 概率执行专家动作,1-beta_i 执行学习者动作。

    beta_i = beta_0 * decay^i,随迭代指数衰减:
    - 早期 beta_i 接近 1,轨迹主要由专家驱动,采集到的状态集中在
      「正常操作区间」,避免学习者早期策略太差、轨迹刚起步就失败,
      导致聚合数据集里全是濒临崩溃的低质量状态;
    - 后期 beta_i 趋近 0,轨迹逐渐由学习者主导,训练分布平滑地
      过渡到学习者自身的部署分布,兼顾数据质量与分布对齐。
    """
    policy = PolicyNet()
    dataset = []

    # 第 0 轮:用专家示范初始化(与标准 DAgger 一致)
    for _ in range(rollouts_per_iter):
        state, _ = env.reset()
        for _ in range(max_steps):
            action = expert_policy(state)
            dataset.append((state, action))
            state, _, done, truncated, _ = env.step(action)
            if done or truncated:
                break

    train_on_dataset(policy, dataset)

    for i in range(iterations):
        # 当前轮次的专家动作执行概率,随迭代指数衰减
        beta_i = beta_0 * (decay ** i)
        new_samples = []

        for _ in range(rollouts_per_iter):
            state, _ = env.reset()
            for _ in range(max_steps):
                expert_action = expert_policy(state)

                # 混合采样:以 beta_i 概率执行专家动作,否则执行学习者动作
                if random.random() < beta_i:
                    exec_action = expert_action
                else:
                    exec_action = policy.act(state)

                # 标签始终来自专家:无论谁执行动作,都记录专家在该状态的动作
                new_samples.append((state, expert_action))

                # 用实际执行的动作推进环境,从而决定下一状态
                state, _, done, truncated, _ = env.step(exec_action)
                if done or truncated:
                    break

        dataset.extend(new_samples)
        train_on_dataset(policy, dataset)
        print(f"Iter {i+1}: beta_i = {beta_i:.3f}, dataset size = {len(dataset)}")

    return policy

这段实现的关键点在于**「执行动作」与「标签动作」解耦**:环境由混合策略推进(早期偏向专家,保证轨迹足够长、状态分布合理),而写入数据集的标签始终是专家动作,因此不会把学习者的错误动作当成监督信号。随着 βi\beta_iβi​ 衰减,采集到的状态分布从专家分布平滑过渡到学习者分布,既缓解了早期数据质量问题,又保留了 DAgger 对齐部署分布的核心优势。

7.2 工程落地建议

  1. 控制专家查询预算:真实场景中专家标注昂贵,优先用不确定性采样筛选状态。
  2. 数据回放与平衡:聚合数据集会越来越大,注意采样平衡,避免早期数据淹没新数据。
  3. 安全约束:学习者探索时可能进入危险状态,需加入安全护栏或仿真环境预训练。
  4. 与强化学习结合:DAgger 提供良好初始化,可再接 RL 微调(如 AWAC、IQL 等离线到在线方法)。

7.3 常见失败模式与排查

DAgger 在论文里看起来很美,但真正落地时,失败往往不是「算法不对」,而是数据、专家和预算这三件事出了岔子。下面列出 4 个最典型的失败场景,每个都按「现象 → 原因 → 排查/缓解手段」展开。

场景一:专家标注噪声导致策略退化
  • 现象:训练集越来越大,训练损失持续下降,但评估回报不升反降,甚至出现「训练集准确率 95%、实际回报却不如 BC」的诡异情况。
  • 原因:专家本身不完美(人类标注抖动、规则专家在边界状态犹豫、特权信息策略与真实动作空间不一致),学习者把噪声当成真值去拟合,聚合数据越多,噪声被放大得越厉害。
  • 排查/缓解手段:
    • 抽样人工复核一批专家标签,统计与学习者预测不一致的样本中,有多少其实是专家标错;
    • 对专家标签做平滑或多数投票(多次查询同一状态取众数);
    • 引入标签置信度,低置信样本降权或直接丢弃;
    • 用集成策略的预测一致性做过滤,只保留「专家与集成都认可」的样本。
场景二:聚合数据集类别不平衡
  • 现象:策略在多数动作上表现正常,但在少数关键动作(如 CartPole 中某一方向的推力、自动驾驶中的急刹)上几乎从不触发,长轨迹中一旦需要该动作就崩溃。
  • 原因:学习者早期策略偏向某一动作,导致采集到的状态-动作对严重偏斜;而 DAgger 是「全量保留」,早期偏斜数据会持续稀释后期数据。
  • 排查/缓解手段:
    • 统计聚合数据集中各动作的频次分布,画出直方图;
    • 训练时使用类别加权损失或按动作频次做重采样;
    • 对每轮新数据设置最小配额,保证稀有动作有足够样本;
    • 结合不确定性采样,优先在稀有动作相关状态上请求专家标注。
场景三:学习者早期崩溃导致数据质量差
  • 现象:前几轮迭代回报极低(几乎随机),采集到的轨迹很短,聚合数据集里全是「刚起步就失败」的状态,后续训练难以恢复。
  • 原因:初始策略太弱,学习者访问到的状态集中在「濒临失败」的区域,专家在这些状态上的标注虽然正确,但分布过于集中,无法覆盖正常操作区间。
  • 排查/缓解手段:
    • 采用 DAgger-B 混合策略,早期以较高概率 βi\beta_iβi​ 执行专家动作,随迭代衰减;
    • 先用 BC 在专家示范上充分预训练,再启动 DAgger 迭代;
    • 监控每轮平均轨迹长度,若长期不增长则说明数据分布有问题;
    • 在仿真环境中先做课程学习(curriculum),逐步增加任务难度。
场景四:专家查询预算耗尽
  • 现象:迭代进行到一半,专家查询额度用完,被迫停止聚合,最终策略停留在「半成品」状态,回报远低于预期。
  • 原因:DAgger 每轮都要对全部访问状态查询专家,查询量随迭代轮数与轨迹长度线性甚至超线性增长,预算规划不足时很容易中途断粮。
  • 排查/缓解手段:
    • 提前估算总查询量:迭代轮数 × 每轮轨迹数 × 平均轨迹长度,与预算对比;
    • 使用 EnsembleDAgger / ThriftyDAgger,只在不确定性高或新颖的状态上查询;
    • 对状态做聚类或去重,避免对相似状态重复查询;
    • 设置查询预算上限,超出后自动切换到「仅用已有数据继续训练」模式。
排查清单
检查项观察指标异常信号优先动作
专家标签质量抽样复核一致率一致率 < 90%平滑/投票/降权低置信样本
动作类别分布各动作频次直方图某动作占比 < 5%类别加权或重采样
早期策略强度前 3 轮平均轨迹长度长期接近最小值启用 DAgger-B 或 BC 预训练
查询预算消耗已用查询 / 总预算消耗速度 > 预期 1.5 倍切换不确定性采样策略
训练-评估差距训练损失 vs 评估回报损失降但回报不升检查分布偏移与标签噪声

小结:DAgger 的失败大多不是「算法失效」,而是「数据管道失效」。把专家质量、类别平衡、早期策略强度和查询预算这四件事盯住,再配合上面的排查清单逐项核对,绝大多数问题都能在迭代早期被发现并纠正。

8. 总结

DAgger 用「学习者探索 + 专家标注 + 数据聚合」的简洁思路,优雅地解决了行为克隆的分布偏移问题,并从理论上把复合误差从 O(ϵT2)O(\epsilon T^2)O(ϵT2) 降到 O(ϵT)O(\epsilon T)O(ϵT)。

它的核心贡献可以概括为三点:

  • 问题定位准确:明确指出 BC 的失败根源是训练与测试状态分布不一致;
  • 方法简单有效:只需在策略访问的状态上补充专家标签;
  • 理论保证扎实:通过 no-regret 在线学习框架给出收敛性证明。

当然,DAgger 的代价是需要在线访问专家,这在很多真实场景中并不便宜。因此后续的 HG-DAgger、EnsembleDAgger、ThriftyDAgger 等变体,本质上都是在「降低专家查询成本」这一方向上做文章。理解 DAgger 的思想,是进入现代模仿学习与智能体训练的重要一步。

9. 参考资料

  1. Ross, S., Gordon, G. J., & Bagnell, J. A. (2011). A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning. AISTATS 2011. 提出 DAgger 算法,将模仿学习归约为 no-regret 在线学习,把复合误差从 O(ϵT2)O(\epsilon T^2)O(ϵT2) 降到 O(ϵT)O(\epsilon T)O(ϵT),是本文全部内容的理论源头。

  2. Kelly, M., Sidrane, C., Driggs-Campbell, K., & Kochenderfer, M. J. (2019). HG-DAgger: Interactive Imitation Learning with Human Experts. ICRA 2019. 提出 Human-Gated DAgger,由人类专家在关键时刻「接管」并标注,在保证安全的同时显著降低标注成本,是自动驾驶等高风险场景的代表性工作。

  3. Menda, K., Driggs-Campbell, K., & Kochenderfer, M. J. (2020). EnsembleDAgger: A Bayesian Approach to Safe Imitation Learning. IROS 2019(arXiv 2018). 用策略集成估计认知不确定性,只在集成分歧大的状态上请求专家标注,在提升安全性的同时减少专家查询次数。

  4. Hoque, R., Balakrishnan, A., Doan, E., Brandt, E., & Goldberg, K. (2022). ThriftyDAgger: Budget-Aware Novelty and Risk Gated Imitation Learning. CoRL 2021. 结合新颖性检测与风险估计,只在「新颖且高风险」的状态请求专家干预,并显式考虑专家查询预算,适合真实机器人部署。

  5. Ross, S., & Bagnell, J. A. (2010). Efficient Reductions for Imitation Learning. AISTATS 2010. 系统给出模仿学习的归约框架与误差分析,为 DAgger 的后续理论推导提供了基础工具(如性能差分引理与状态分布差异分析)。

说明:以上文献按「原始论文 → 降低专家成本的三类代表性变体 → 理论前置工作」的顺序排列,便于按需追溯。若需进一步扩展,可关注基于不确定性采样、主动学习与离线到在线微调(如 AWAC、IQL)方向的后续研究。

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址