轨迹规划 on 朝花夕拾

SparseDriveV2: Scoring is All You Need for End-to-End Autonomous Driving

Mon, 20 Apr 2026 00:00:00 +0000

一、这篇论文在讲什么？

核心问题

端到端自动驾驶的多模态规划中，江湖上原本分为两派：

派系	代表方法	优点	缺点
静态词表派	VADv2、Hydra-MDP、DriveSuprim	算力友好，简单高效	颗粒度太粗，动作空间覆盖不足
动态生成派	ipad（回归）、DiffusionDrive、GoalFlow（扩散/流匹配）	极其精细，性能霸榜	模型臃肿，需要额外网络或疯狂迭代降噪

作者的灵魂拷问

动态生成真的是必需的吗？如果我把静态词表塞得密不透风，能不能打败它们？

SparseDriveV2 的答案

静态词表只要足够密，打分机制就能一统天下！ 纯粹的打分范式（Purely Scoring-based），照样拿 SOTA！

形象的比喻：

动态生成派：像一个"现场作画"的艺术家，每次都要从头画一幅精细的作品，耗时耗力
SparseDriveV2：像一个"菜单点菜"的食客，只要菜单够厚（词表够密），就能精准选中自己想要的那道菜

二、暴力扩容实验：用数据说话

为了验证"静态词表的潜力是无穷的"这个猜想，作者拿经典的 Hydra-MDP 模型做了一场"大力出奇迹"实验：

轨迹锚点数量	NAVSIM v2 EPDMS 得分
1024	85.02
2048	↑
4096	↑
8192	↑
16384	87.35
32768	💥 OOM（显存爆了）

结论：性能一路看涨，完全没有遇到瓶颈！限制它的只是你的算力和显存！

于是，SparseDriveV2 闪亮登场，它带来了两个改变游戏规则的核心创新，彻底打破了这个内存墙。

三、核心方法：两大创新

创新一：可扩展的词汇表征 —— 轨迹"解剖术"

一条轨迹包含两个维度：

空间几何：你去哪儿？（路径）
时间演进：你开多快？（速度）

既然完整的轨迹太多会导致内存爆炸，那就把它们拆了！

轨迹因式分解（Factorization）

组成部分	定义	采样方式
几何路径 (Path, $p$)	剥离时间，只看地上的车辙印	在最大空间长度 $S_{max}$ 内，每隔固定空间间隔 $\Delta s$ 采一个点
速度配置 (Velocity, $v$)	剥离空间，只看迈速表	在总时间 $T$ 内，每隔固定时间 $\Delta t$ 记录一个平均速度

积木重组：如何还原轨迹？

当需要还原轨迹时，通过计算时间步 $t$ 时的累计行驶距离： $$s_t = \sum v_k \Delta t$$

然后在路径 $p$ 上进行距离插值，就能完美拼出完整的时空轨迹 $\tau$！

形象比喻：就像玩乐高积木，你不需要为每种组合单独准备一个成品，只需要准备有限数量的"路径积木"和"速度积木"，然后按需组装即可！

创新二：丝滑的打分策略 —— 大浪淘沙

面对几十万条轨迹，一个一个打分肯定会死机，于是作者设计了**“漏斗式"打分法**：

┌─────────────────────────────────────────────────────┐
│  第一层：场景编码 (Scene Encoding)                    │
│  - 用 ResNet 提取多视角图像特征                       │
│  - 编码自车状态                                       │
└─────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────┐
│  第二层：粗粒度解耦打分 (Coarse Factorized Scoring)   │
│  - 路径打分：MLP + 场景特征 → Top-K_p 个路径          │
│  - 速度打分：MLP + 场景特征 → Top-K_v 个速度          │
│  - 筛掉离谱组合（高速上猛打方向盘、拥堵路段狂飙）       │
└─────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────┐
│  第三层：细粒度轨迹打分 (Fine-Grained Scoring)        │
│  - 轨迹重条件化（Re-conditioning）                   │
│  - 可变形聚合（Deformable Aggregation）              │
│  - 高精度时空依赖推理                                 │
│  → 选出最终冠军轨迹                                   │
└─────────────────────────────────────────────────────┘

为什么需要"轨迹重条件化”？

高速行驶和急转弯之间存在物理冲突，路径和速度不是绝对独立的！

所以作者引入了轨迹重条件化（Trajectory Re-conditioning），用可变形聚合让组合后的轨迹特征再次与场景特征互动，进行高精度的时空依赖推理，最终给出精准打分！

四、词汇构建：从数据到锚点

两步聚类法

作者在海量人类驾驶数据中，用 K-Means 聚类算法 分别聚类出：

$N_p$ 个路径锚点：代表人类常见的行驶路径形态
$N_v$ 个速度锚点：代表人类常见的速度配置

奇迹时刻：排列组合

把它们两两排列组合！

$$\text{总轨迹数} = N_p \times N_v$$

只需极小的内存，就能组合出包含几十万条候选轨迹的超高密度轨迹词表！

五、训练与推理

训练秘籍

损失函数：基于距离的软分类交叉熵损失（CE Loss）

评估维度	距离度量
路径评估	点到点的平均平方距离（$L_2$ 距离）
速度评估	绝对误差（$L_1$ 距离）
细粒度轨迹评估	$L_2$ 距离

额外监督：还请了一位"基于规则的老师（Rule-based Teacher）“来传授心法：

安全性
行驶进度
舒适度
交通规则遵守度

使用二元交叉熵（BCE）损失进行监督。

推理流程

综合这些分数，选出"选秀冠军"直接控车！

六、实验设置：赛场与装备

主战场 NAVSIM

配置	数值
路径词表 $N_p$	1024（1米间隔，最长50米）
速度词表 $N_v$	256（0.5秒间隔，最长4秒）
总候选轨迹	262,144 条
与前人对比	比常用的 8192 个锚点密 32 倍！

推流过滤魔法

26万条轨迹怎么算？

层级	筛选策略	结果
第一层	Top 128 路径 + Top 64 速度	筛掉大部分离谱组合
第二层	Top 20 路径 + Top 20 速度（v2加速：Top 10 速度）	形成高质量子集
最终	细粒度打分	只给 400 条最靠谱的轨迹打分

轻量级装备

配置项	数值
骨干网络	ResNet-34（仅 21.8M 参数）
输入分辨率	256 x 512
训练设备	8 张 NVIDIA L20 GPU
Batch Size	128
学习率	$1 \times 10^{-4}$
权重衰减	0
训练 Epochs	10

七、主打战绩：越级挑战

NAVSIM v1 榜单

PDMS 终极高分：92.0

完爆其他打分方法和动态生成方法
“以下犯上”：用袖珍的 ResNet-34 干翻了配备 V2-99 骨干网络（96.9M参数）的 GoalFlow 和 Hydra-MDP！

NAVSIM v2 榜单

模型	EPDMS 分数
SparseDriveV2	90.1
DiffusionDriveV2（前任霸主）	87.5

特别是在 EP（驾驶进度） 指标上进步神速，证明了致密词表真的能覆盖更广的动作空间！

Bench2Drive（闭环测试）

指标	分数
驾驶得分	89.15
成功率	70.00%
多能力得分	67.67%

全面碾压 TCP-traj 和 DriveAdapter 等一众强敌，展现了强大的复杂场景泛化能力。

八、消融实验：抽丝剥茧

词表密度实验

词表大小	EPDMS 分数
512 × 128	88.7
…	↑
1024 × 256	90.1

结论：词表越密，效果越好！

关键组件实验

配置	效果
可变形聚合（DFA）	✅ 提升
轨迹重条件化（Re-conditioning）	✅ 提升
DFA + Re-conditioning	🏆 黄金搭档

九、附录彩蛋：Bench2Drive 闭环实验细节

配置调整

配置项	数值
路径锚点最大长度	15 米
速度视野	3 秒
骨干网络	ResNet-50
训练设备	16 张 L20 显卡
输入	6 个摄像头（256 x 704）
辅助任务	3D 目标检测、在线建图、运动预测

两段式训练

第一阶段：100 个 Epoch 的感知训练
第二阶段：10 个 Epoch 的感知与规划联合训练（纯模仿学习，没用规则老师监督）

学习率分别为 $4 \times 10^{-4}$ 和 $3 \times 10^{-4}$。

如何控车？

控制维度	策略
横向控制	“随速可变目标距离”：$d = 0.5 \times \text{自车速度} + 2.5$，寻找路径上的预瞄点打方向盘
纵向控制	直接取速度配置里的第一个速度作为目标油门/刹车

定性结果展示

与基线相比（红线），SparseDriveV2 的轨迹（蓝线）：

更贴近人类老司机（绿线）
急转弯更平滑
交通效率更高
不会像呆子一样停在原地！

坦诚的局限性：在缺乏导航信息的情况下，系统偶尔也会"迷路”。

十、个人思考与疑问

值得学习的亮点

极简哲学：用最纯粹的打分思路，证明了"简单方法 + 大规模"可以打败"复杂方法 + 小规模"
因式分解的智慧：把轨迹拆成路径和速度两个维度，巧妙地绕过了显存爆炸的问题
漏斗式打分：三层筛选机制既保证了计算效率，又没有牺牲最终精度

待探索的问题

词表密度的极限：如果显存继续增大，词表密到什么程度会开始出现边际效应递减？
路径和速度的耦合：重条件化机制是否可以进一步优化，更好地捕捉两者的深层关联？
与扩散模型的融合：能否将 SparseDriveV2 的致密词表思想与扩散模型的生成能力结合起来？

参考链接

论文原文：https://arxiv.org/pdf/2603.29163
相关工作：Hydra-MDP, VADv2, DiffusionDrive, GoalFlow

DiffusionDriveV2: Truncated Diffusion Model for End-to-End Autonomous Driving

Tue, 17 Mar 2026 00:00:00 +0000

一、这篇论文在讲什么？

核心问题

自动驾驶规划面临一个经典的两难困境：多样性 vs 质量

太保守：只会"死记硬背"人类司机的走法，遇到新情况就傻眼
太发散：想象力太丰富，画出各种会撞车的方案

DiffusionDriveV2 的答案

用扩散模型生成多条候选路径（多样性），再用强化学习像严厉的教练一样筛选（质量）

形象的比喻：射箭比赛

以前的模型：只盯着靶心射一箭，射偏了就没招了
DiffusionDriveV2：一次性朝靶心周围射出一把箭（多样性），然后剪掉那些射到观众席的箭（质量约束），最后选出最准的一支

二、核心方法：三招绝学

第一招：尺度自适应乘法噪声 —— 让"脑洞"更顺滑

以前的做法（加法噪声）：在路径上乱加干扰，结果路径变得像毛刺一样，车开起来会剧烈抖动

V2 的创新： $$\tau’ = (1 + \epsilon_{mul})\tau$$

生动理解：

近处（车头）：抖动小，因为车头方向需要精确控制
远处（目标点）：抖动大，因为远处的路径本身就有不确定性

这符合开车时"微调方向、远方模糊"的真实物理规律。

第二招：Intra-Anchor GRPO —— 窝里斗，选优胜者

核心逻辑：不比绝对高低，只比相对好坏

流程：

针对同一个意图模板（比如"左转"），生成 8 条略有不同的路径
裁判给这 8 条路径打分（是否撞车、是否开出马路、乘客稳不稳）
计算"相对优势"：$A = \frac{\text{你的分数} - \text{平均分}}{\text{差异度}}$
表现比平均好的，优势值为正；比平均差的，为负

为什么要"组内"比？

“左转"和"直行"的分数没有可比性。左转天生就比直行难。如果放在一起比，模型可能会为了拿高分而只学直行（模式崩溃）。

临摹字帖的比喻：

想象你在练书法，桌上有 64 张不同的字帖（Anchors）：一张是"一"字，一张是"之"字，一张是"永"字……

生成过程：你拿一张"永"字的字帖，临摹了 8 遍。虽然每遍写得都有点细微差别（加了随机噪声），但因为你都是照着"永"字写的，这 8 张纸就被归为 “永字组”
组内 GRPO：老师（Reward）过来看这 8 张"永"字，选出写得最漂亮的一张，给你奖励
拒绝跨组比较：老师不会拿你写的"永"字去和隔壁桌写的"一"字比谁更漂亮，因为它们根本不是一个字，没法比

第三招：Inter-Anchor Truncated GRPO —— 守底线，撞车必罚

虽然"窝里斗"能选出最好的左转方案，但如果所有的左转方案都会撞上护栏怎么办？

这一招建立了全局底线：不管你是哪种意图，只要撞车，通通判死刑（给极低的负分）。

三、Mode Selector：最后拍板的那个人

Intra-Anchor GRPO 确保了每个意图都能产生高质量的路径，但车只能选一条路走。谁来拍板？

Mode Selector 就是那个"主裁判”，它的工作是：

1. 怎么选？—— 综合多维度打分

结合三类关键信息进行"面试"：

路径本身：弯曲程度如何？是否平滑？
环境背景（BEV Features）：通过交叉注意力，看看路附近有没有障碍物、马路牙子或红绿灯
任务目标：导航让你左转，那左转组的路径天生得到更高的"意图分"

2. 技术实现

MLP 打分：经过特征融合后，通过 MLP 给每条路径打分
粗选+精选（Coarse-to-fine）：先快看一眼，淘汰明显不行的；剩下的再仔细对比

3. 训练标准

BCE Loss（对错分）：告诉它哪条路最接近人类司机的真值
Margin-Rank Loss（排序分）：不要求算出绝对好坏分，而是要求能排对顺序

如果没有这个 Mode Selector，光有 GRPO，车子可能会在"左转"和"直行"之间反复横跳，不知道该听谁的。

四、GRPO vs DPO：两种"教导方式"的对比

特性	DPO (直接偏好优化)	GRPO (组相对策略优化)
数据形式	成对数据（A > B）	组数据（A, B, C, D…）
学习方式	离线学习	在线探索
核心逻辑	隐式奖励	显式奖励
比喻	看录像带学习	队内选拔赛

为什么论文选 GRPO 而不是 DPO？

解决模式崩溃：GRPO 通过组内归一化，强制保留每个意图的独特性
不需要 Critic 网络：GRPO 利用"组平均分"代替了评论员，更简单、更省内存
动态进化：在扩散模型复杂的生成空间里，GRPO 能让模型不断发现"原来这样走比刚才那样走更好"

五、Reward 函数：交规考试式的打分

GRPO 的 Reward 是人工定义的规则计算的，不需要神经网络：

具体规则

指标	含义	判定方式
NC (No Collision)	碰撞惩罚	如果撞到车/行人/护栏，给巨大负分
DAC (Drivable Area Compliance)	合规性	车轮是否压到马路牙子、是否逆行
EP (Ego Progress)	进度得分	鼓励往前走，走得越远且符合限速，得分越高
C (Comfort)	舒适度	路径平滑度、加速度和急转弯程度
TTC (Time To Collision)	时间到碰撞	离前车的距离和相对速度是否安全

为什么不用神经网络打分？

客观标准明确：自动驾驶"撞没撞车"是物理事实，用规则算比用模型猜更准确、可靠
计算速度快：规则计算只是几行物理公式，不需要运行庞大的神经网络
避开"幻觉"：AI 模型可能产生幻觉觉得撞车也挺好，但物理规则是铁律

六、技术演进：三代扩散模型的对比

特性	DiffusionPlanner	DiffusionDrive V1	DiffusionDriveV2
起始状态	纯随机噪声（从 0 到 1 创造）	预定义锚点（从半成品加工）	锚点 + 尺度自适应噪声
去噪步数	多步（通常 10+ 步，慢）	极少步（1-2 步，快）	极少步（1-2 步，快）
多样性保证	扩散模型天然属性（不稳定）	64 个锚点强制分区（稳定）	锚点分区 + GRPO 保护意图
学习范式	模仿学习 (IL)	模仿学习 (IL)	模仿学习 + 强化学习 (RL)
存在痛点	算得慢、容易模式崩溃	容易产生会撞车的低质轨迹	系统复杂度高（训练难）

生动理解三代的区别

A. 关于"噪声"的艺术

DiffusionPlanner：在沙堆里找金子，范围太大，容易迷失
DiffusionDrive：给沙堆围了 64 个小栅栏，让你在栅栏里找，效率高了，但栅栏里可能混进了石头
DiffusionDriveV2：不仅有栅栏，还发明了"乘法噪声"，近处抖动小，远处抖动大，符合开车物理规律

B. 关于"教导方式"的变革

前两代：看人画画，只知道老师没往墙上撞，不知道为什么不撞
V2 时代：引入"警察罚款"，如果你画到墙上，GRPO 教练会狠狠扣分

七、架构拓扑：从模糊到精确

DiffusionPlanner：模糊的一段式（Monolithic）

传感器数据 → 特征提取 → 扩散解码器

像一个"黑盒"，缺乏中间变量，人类很难理解它为什么要这么开。

DiffusionDrive V1：清晰的二段式（Perception-then-Plan）

传感器 → BEV 特征图 + 目标检测 → 锚点扩散

有了明确的分工。先通过感知算法把世界变成"鸟瞰图"，规划器再在这张图上"画画"。

DiffusionDriveV2：精密的"多级反馈"二段式

传感器 → 高精度 BEV → 组内并行扩散（GRPO） → 模式选择

在 V1 基础上增加了"选优级"，形成了"感知 → 粗规划 → 精规划"的三级跳。

八、传感器融合：如何构建 BEV？

特性	DiffusionPlanner	DiffusionDrive V1	DiffusionDriveV2
输入源	单视角或视角特征拼接	多相机环视（6 颗摄像头）	相机 + LiDAR（多模态对齐）
特征空间	图像空间	BEV 空间（LSS 方案）	时序对齐 BEV（ResNet-34）
融合方式	简单的特征拼接	空间投影	时空注意力融合

V2 的技术细节

骨干网络：对齐的 ResNet-34，通过 LSS（Lift-Splat-Shoot）把 6 颗摄像头的图像"拍扁"到地面
时序对齐：把过去 2 秒的 BEV 特征根据自车运动进行"空间平移"，让不同时间点的特征在同一个坐标系下重叠

九、规划逻辑的信息流

三重交互机制

DCA（全景扫描）：轨迹看 BEV 特征图，快速定位周围是大街还是小巷
Agent-Wise Attention：轨迹与 50 个障碍物 Query 进行 1 对 1 谈话，进行厘米级碰撞检测
Map-Wise Attention：轨迹与车道线向量对齐，确保遵守交通规则

生动比喻：

BEV 交互是让你"别撞墙"

Map 交互是让你"守交规"

十、前后帧一致性：如何拒绝"精神分裂"？

1. 时序特征融合

输入包含过去几帧（比如过去 2 秒）的图像或点云，通过 Temporal Attention 把过去的特征"存"在当前特征向量里。

比喻：你开车时，脑子里其实存着前 2 秒路口的样子，你看的是一部"连贯的电影"。

2. Anchors 作为"定海神针"

64 个锚点（直行、左转等模板）是固定不变的。每一帧都从相同的锚点出发，起步点不乱跳。

3. 截断扩散的功劳

推理时只走 2 步（甚至 1 步），步数越少，生成过程就越接近确定性逻辑。

4. GRPO 带来的"决断力"

通过组内对比，极大拉开了"好路径"和"坏路径"的分数差距，让决策变得非常"笃定"。

十一、实验结果

在自动驾驶界最有名的考场 NAVSIM 进行考试：

PDMS 分数：91.2，刷新世界纪录
骨干网络：即使使用较小的 ResNet-34，表现也超过了拥有巨大骨干网络的模型

十二、关键技术实现：Multi-Head Attention

为什么要用多头？

单头注意力：像一把手电筒，盯着行人看，可能就没注意到红绿灯

多头注意力：像一个专家顾问团

1号头（安全专家）：盯着障碍物和距离
2号头（导航专家）：盯着车道线和路标
3号头（舒适专家）：盯着路面平整度和坡度

核心代码逻辑

# 多头拆分：把 [batch, seq_len, d_model] 变成 [batch, num_heads, seq_len, head_dim]
Q = Q.view(batch_size, -1, num_heads, head_dim).transpose(1, 2)

# 计算注意力分数
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)

# 为什么除以 sqrt(d_k)？
# 防止分数值过大，导致 Softmax 进入饱和区（梯度消失）
# 就像"音量调节旋钮"，让模型保持"理智"

十三、个人思考与疑问

值得学习的亮点

锚点机制：把扩散模型的"混沌"约束在 64 个意图分区里，既保证多样性又控制计算量
GRPO 的巧妙应用：借用 DeepSeek-R1 的技术，解决了模仿学习"不识好歹"的问题
乘法噪声：一个看似微小的数学改变，却让轨迹在物理平滑度上直接降维打击前代

待探索的问题

GRPO 的组大小如何选择？8 条还是 16 条？对性能和效率的影响如何？
Mode Selector 是否可以引入时序记忆，进一步稳定决策？
如何处理极端场景（如突然出现的障碍物）？

参考链接

论文原文：DiffusionDriveV2
相关工作：DiffusionPlanner, DiffusionDriveV1, DeepSeek-R1 (GRPO)

本笔记基于 AI 辅助的论文讨论整理而成，保留了讨论中的生动比喻和技术细节。

Epona: Autoregressive Diffusion World Model for End-to-End Autonomous Driving

Tue, 17 Mar 2026 00:00:00 +0000

端到端自动驾驶的视频生成与轨迹规划

🎯 一句话概括

Epona 是一个自回归扩散世界模型，它像拍连续剧一样根据历史画面预测未来，同时用扩散模型保证每一帧画质高清——不仅能"脑补"出未来 2 分钟的驾驶场景，还能学会"红灯停、避让行人"等物理规则。

🧠 核心设计理念

为什么需要 Epona？

在自动驾驶领域，存在两类模型各有优劣：

模型类型	优势	劣势
扩散模型	画质逼真、细节丰富	短视，难以生成长视频，不懂数理逻辑
自回归 Transformer	懂因果、能长程推理	图像压缩粗糙，画质模糊

Epona 的思路：为什么不能兼得？于是采用 “自回归 + 扩散” 混合架构：

像写连续剧一样（自回归）根据历史预测未来
同时用扩散模型保证每一帧画质高清

三大核心创新

分工明确：时空处理分离，效率大幅提升
异步生成：轨迹规划和视频生成分开进行
连锁前向训练：解决误差累积问题，能生成长达 2 分钟的视频

🏗️ 架构详解

Epona 由三个核心模块组成，像一个精密配合的团队：

┌─────────────────────────────────────────────────────────────┐
│                        Epona 架构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   历史 T 帧 ──┐                                              │
│               │    ┌─────────┐                              │
│   历史动作 ────┼───►│   MST   │──► 特征 F                     │
│               │    │(记忆大师)│       │                      │
│               ┘    └─────────┘      │                       │
│                                     │                       │
│                          ┌──────────┴──────────┐            │
│                          ▼                     ▼            │
│                   ┌──────────┐          ┌──────────┐        │
│                   │ TrajDiT  │          │  VisDiT  │        │
│                   │(领航员)   │          │ (画师)    │        │
│                   └────┬─────┘          └────┬─────┘        │
│                        │                     │              │
│                        ▼                     ▼              │
│                   未来轨迹              下一帧画面             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

📚 2.1 MST (Multimodal Spatiotemporal Transformer)

🎭 角色：超级记忆大师

MST 的任务是将过去复杂的视频画面和驾驶操作，压缩成一个精炼的特征向量。就像一个记忆力超群的人，看一眼就能记住所有关键信息。

输入预处理

原始输入：
├── 视觉：过去 T 帧 (如 10 帧) 图像，分辨率 512×1024
└── 动作：每帧对应的历史轨迹（速度、方向盘转角等）

DCAE 压缩处理：
├── 图像压缩 16 倍：512×1024 → 32×64 特征图
├── 铺平成 Token：32×64 = 2048 个视觉 Token (记作 L)
└── 动作投影：动作向量映射到同维度 Token

最终输入张量 E：
├── 形状：[Batch, T, (L+3), D]
├── L+3 = 2048 个视觉 Token + 3 个动作 Token
└── D = 特征维度

🔄 时空分离处理 —— “先看时间，再看空间”

MST 不是同时处理时空，而是交替进行，像这样：

步骤 A：时间层 —— “串联历史”

目标：让图像中同一个坐标位置的像素点，去查阅自己在过去 $T$ 帧的变化。

# 输入变换
原始形状：[B, T, S, D]    # S 是空间 Token 数 L+3
变换后：[(B * S), T, D]   # 把空间维度和 Batch 绑在一起

# 物理含义
现在模型眼里的"一个样本"，不再是整段视频，
而是视频中某个特定位置的像素点随时间的变化序列。

# 关键技术：Causal Mask（因果遮罩）
第 5 帧的像素只能看第 1, 2, 3, 4 帧的自己，不能偷看第 6 帧。

步骤 B：空间层 —— “理解当下”

目标：把每一帧看作独立的图片，让图像里的车、路、树木以及动作指令 Token 进行全注意力交互。

# 输入变换
变换后：[(B * T), S, D]   # 把时间维度和 Batch 绑在一起

# 多模态融合
视觉信息和动作意图在此处深度融合。

📍 3D 位置编码 (EmbedND)

Epona 使用分块对角旋转位置编码 (RoPE) 来编码时空位置：

def EmbedND(dim, theta, axes_dim):
    """
    为视频中的每个像素点生成 3D 位置嵌入
    维度分配示例：[Time: 2维, Height: 2维, Width: 2维]
    """
    for i, (pos, dim) in enumerate(zip(axes, axes_dim)):
        out.append(rope(pos, dim, theta))
    return torch.cat(out, dim=-1)

形象例子：假设要给坐标 (t=5, h=10, w=20) 的像素编码：

循环 1 (Time):   Embed(5)  → [0.1, 0.9]
循环 2 (Height): Embed(10) → [0.5, 0.5]
循环 3 (Width):  Embed(20) → [0.8, 0.2]

最终拼接：[0.1, 0.9, 0.5, 0.5, 0.8, 0.2]

这样，最终向量同时包含时间、高度和宽度信息，互不干扰。

输出

经过 $N$ 层循环后，提取序列中最后一帧的特征 $\mathbf{F}$。这是包含丰富历史语义和当前状态的高维特征向量，作为后续两个模块的基石。

🚗 2.2 TrajDiT (Trajectory Planning DiT)

🎭 角色：决策中枢 & 老司机

拿到 MST 给的局面 $\mathbf{F}$，在不生成图像的情况下，极速规划出未来 3 秒怎么开。

架构：双流融合

这是一个专门"画线"（轨迹）的轻量级扩散模型。

输入准备：
├── 条件 (Cond)：来自 MST 的特征 F
└── 噪声 (Input)：随机高斯噪声 x_T（代表未来轨迹的草稿）

双流阶段 (Dual-Stream Phase)：
├── 环境流：处理特征 F
├── 轨迹流：处理噪声轨迹
└── 通过 Cross-Attention 交换信息

单流阶段 (Single-Stream Phase)：
├── 两条流拼接，深度混合推理
└── 确保轨迹与环境严丝合缝

🔧 Modulation 调制机制

Modulation 是将时间嵌入转化为神经网络控制参数的关键组件：

class Modulation:
    def __init__(self, dim, double):
        self.multiplier = 6 if double else 3
        self.lin = nn.Linear(dim, dim * self.multiplier)

    def forward(self, vec):
        out = self.lin(vec.silu()).chunk(self.multiplier, dim=-1)
        return out  # 返回 (shift, scale, gate) 组

参数含义：

Shift (β)：偏移量，平移特征
Scale (γ)：缩放因子，拉伸/压缩特征
Gate (α)：门控值，控制残差连接强度

📊 DoubleStreamBlock vs SingleStreamBlock

特性	DoubleStreamBlock	SingleStreamBlock
数据流	两条独立流 (环境+轨迹)	一条混合流
调制参数	每条流 6 个，共 12 个	仅 3 个
结构	串行逻辑	并行逻辑
用途	TrajDiT 前期，保护环境特征	TrajDiT 后期/VisDiT，高效推理

在 DoubleStreamBlock 中：

# 轨迹流
img_mod1 → 控制 Attention 的 AdaLN 和门控
img_mod2 → 控制 MLP 的 AdaLN 和门控

# 环境流
cond_mod1 → 控制 Attention 的 AdaLN 和门控
cond_mod2 → 控制 MLP 的 AdaLN 和门控

🎨 2.3 VisDiT (Next-frame Prediction DiT)

🎭 角色：超写实画师

根据 MST 的特征和 TrajDiT 的轨迹规划，生成下一帧图像。

输入准备

画布噪声：随机高斯噪声潜变量 Z_{T+1}
环境参考：MST 的特征 F
动作指令：TrajDiT 预测的轨迹（关键！）

核心机制：动作调制

轨迹向量转化为控制神经网络的旋钮参数：

# 轨迹向量转化为缩放因子和偏移量
Input = Input * Scale(a) + Shift(a)
# 通过 AdaLN 注入到 Transformer 每一层

如果规划是"左转"，调制会强迫网络关注左侧特征
保证生成画面与规划动作一致

⏱️ 分辨率感知的时间偏移 (get_schedule)

这是一个**“智能时间管理大师”**：

def get_schedule(num_steps, image_seq_len, base_shift=0.5, max_shift=1.15):
    timesteps = torch.linspace(1, 0, num_steps + 1)  # 基础进度条

    if shift:
        mu = get_lin_function(base_shift, max_shift)(image_seq_len)
        timesteps = time_shift(mu, 1.0, timesteps)   # 偏移

    return (1 - timesteps).tolist()

为什么需要它？

痛点：画大图比画小图更难，需要在"宏观构图"阶段多花点时间
解决方案：根据序列长度自动调整时间表
- 序列长（大图）：在高噪声阶段停留更久，先定大轮廓
- 序列短（小图/轨迹）：匀速搞定即可

在 Epona 中：

TrajDiT：序列短，时间表几乎不偏移
VisDiT：序列长（2048 Token），显著偏移

时序感知解码

使用 Temporal-aware DCAE Decoder 解压潜变量
参考上一帧的潜变量，消除频闪和抖动
输出 512×1024 高清图像

🎓 关键技术细节

3.1 傅立叶嵌入 (timestep_embedding)

将低维动作数据映射到高维空间，增强神经网络对细微变化的感知能力：

def timestep_embedding(t, dim, max_period=10000):
    t = time_factor * t
    half = dim // 2
    freqs = exp(-log(10000) * arange(0, half) / half)
    args = t[:, None] * freqs[None]
    embedding = cat([cos(args), sin(args)], dim=-1)
    return embedding

原理：

原始输入：低维向量
输出：高维特征，包含从低频到高频的丰富信号
效果：神经网络能"看到"微小变化

3.2 RoPE vs 正弦编码

特性	正弦编码	RoPE
相对位置感知	弱	强（点积只取决于相对距离）
长度外推性	差	好（周期性，不死记硬背）
维度解耦	难	优雅（分块对角矩阵）

3.3 连锁前向训练 (Chain-of-Forward Training)

痛点：自回归模式的误差累积——第一帧歪一点，第 100 帧就崩了

解决方案：

训练时偶尔用模型自己生成的（有瑕疵的）预测结果作为下一轮输入
模型被迫学会自我修正

效果：能生成长达 2 分钟不崩坏的视频

🔄 完整推理流程

def step_eval(latents, rel_pose, rel_yaw):
    # 1. MST 编码：压缩历史信息
    stt_features, pose_emb = model.evaluate(latents, poses, yaws)

    # 2. TrajDiT 规划：决定未来怎么走
    noise_traj = randn(...)
    predict_traj = traj_dit.sample(noise_traj, traj_ids, stt_features)

    # 3. 提取下一步动作
    predict_pose, predict_yaw = predict_traj[:, 0:1, ...]
    pose_emb = model.get_pose_emb(predict_pose, predict_yaw)

    # 4. VisDiT 生成：脑补下一帧画面
    noise = randn(...)
    predict_latents = dit.sample(noise, img_ids, stt_features, pose_emb)

    return predict_traj, predict_latents

📊 实验成果

指标	结果
视频生成 FVD	7.4 (优于 Vista 7.9, 远超 DriveGAN 73.4)
视频长度	2 分钟且逻辑连贯
物理理解	自学懂"红灯停"、“避让行人"等规则
规划能力	NAVSIM 评测超过多个专门规划模型

💡 总结

Epona 通过 MST（压缩理解）、TrajDiT（规划导航） 和 VisDiT（受控绘图） 三者的精密配合，实现了从"看懂路"到"决定怎么开"再到"脑补未来后果"的完整闭环。

它不仅是一个视频生成器，更是一个具备潜力的端到端自动驾驶大脑。

📎 相关链接

论文：Epona: Autoregressive Diffusion World Model for Autonomous Driving
相关工作：[[World4Drive - 无需感知标注的端到端世界模型]]、[[LAW - Latent World Model for E2E Driving]]

HiP-AD: Hierarchical and Multi-granularity Planning with Deformable Attention

Tue, 17 Mar 2026 00:00:00 +0000

一、这篇论文在讲什么？

核心问题：AI司机的"偏科"痛点

现在的端到端自动驾驶（E2E-AD）界有个普遍的怪现象：“应试教育"满分，“实战上路"拉胯。

开环测试（开卷考试）：给一段历史视频，让 AI 画出未来的行驶轨迹（Waypoints）。大家都画得很好，碰撞率（Collision Rate）极低，甚至能降到 0.1%。
闭环测试（实车上路）：把 AI 扔进仿真软件（比如 Bench2Drive）里真刀真枪地开。结果呢？成功率不到 35%！遇到路口就犹豫不决（超时死机），遇到突发情况就抓瞎。

问题根源

作者一针见血地指出：目前的 AI 在"规划（Planning）“时，和"感知（Perception）“的交互太弱了！而且预测出来的轨迹太单调（只有稀疏的几个点），根本不够用来做精细的车辆控制。

HiP-AD 的答案

用 “分层多粒度预测” + “顺着轨迹看图像（PDA）” + “三合一圆桌会议（统一解码器）”，彻底打通感知与规划的任督二脉

二、核心方法：老司机的三大独门绝技

绝技一：多把量尺看世界 —— 分层与多粒度规划

以前的 AI 预测轨迹，就是每秒打几个点（时间路点，Temporal Waypoints）。这就好比司机只知道"我 3 秒后要到那个路口”，但他不知道这 3 秒内方向盘该打几度。

HiP-AD 彻底改变了玩法，它不仅预测时间，还把轨迹拆解成了 三大维度（模态），并且每个维度都有 不同的颗粒度：

模态	关注点	颗粒度划分	用途
空间路点	“路径"怎么走	密集（2m一个点）& 稀疏（5m一个点）	密集点做精准方向盘微调（横向控制），稀疏点看宏观大局
时间路点	“什么时候到哪”	高频（5Hz）& 低频（2Hz）	高频应对紧急情况，低频规划长程
驾驶风格路点	“车速和动作”	慢/中/快（0-4, 4-10, 10+ m/s）	应对超车、紧急刹车等复杂场景

控车策略：AI 会用空间路点控制方向盘（横向），用时间和驾驶风格路点控制油门刹车（纵向），完美解决由于轨迹点太稀疏导致的"车辆犹豫"问题！

绝技二：指哪打哪的目光 —— 规划可变形注意力（PDA）

以前的 AI 规划器在看周围环境时，是"全局乱瞟”（Global Attention），不仅计算量大，还容易抓不到重点。

HiP-AD 的做法极其聪明——它利用了几何学物理规律：

先把系统预测出的 3D 未来轨迹点（Waypoints），通过相机参数，投影映射到 2D 的多视角环视图像上
然后，只在这些 “车轮即将压过” 的图像物理位置附近，去采样提取图像特征

生动比喻：

这就像老司机在开车时，目光会死死盯住自己即将开过去的那条车道线和前方的障碍物，而不是去看天上的云彩。

数学表达： $$\text{PDA}(Q_p, F) = \sum_{i \in \mathcal{V}} \text{DeformAttn}(Q_p, \mathcal{P}(A_p), F_i)$$

规划主脑有一条预测出的未来 3D 轨迹（$A_p$）。它把这条未来轨迹用函数 $\mathcal{P}$ 投影到多视角的图像（$F$）上，然后只在"未来车轮即将压过的图像像素点"周围提取特征！

绝技三：超级大脑圆桌会议 —— 统一解码器（Unified Decoder）

传统的框架是流水线作业：先做感知（找车、找线）→ 再做预测 → 最后做规划。不仅慢，信息还会衰减。

HiP-AD 搞了一个 “单解码器”，把所有任务拉进一个群里并行开会！

入场的三大"代表”（输入配置）

代表	符号	职责	初始坐标（Anchors）
🚗 动态物体代表	Agent Query ($Q_a$)	找周围移动的车、人	3D 边界框（Box Anchors）
🛣️ 静态地图代表	Map Query ($Q_m$)	找车道线、斑马线	聚类算法生成的折线（Polyline Anchors）
🧠 自动驾驶主脑代表	Planning Query ($Q_p$)	决定咱们自己的车往哪开	未来 $T$ 个时间点的行驶轨迹折线

圆桌会议的三大议程

每个 Decoder Layer 都包含以下三个关键环节：

🕒 议程一：翻阅历史案卷 —— 时序交互模块

老司机开车绝不能只看眼前，得记得上一秒旁边有辆车想加塞。

技术动作：

代表们（Queries）首先会和 上一帧历史保留下来的重要特征 进行 交叉注意力（Cross-Attention） 计算
为了防止历史信息太多把脑袋撑爆，系统用了一个 Top-$k$ 选择机制，只保留上一帧最有价值的线索
给主脑开小灶：规划代表（Planning Query）不但要回顾自己的历史，还会额外增加一次跨任务的 Cross-Attention，专门去盯住历史帧里的感知信息

🗣️ 议程二：圆桌激烈讨论 —— 协同交互模块

看完历史，大家得互相通气了。主脑需要知道哪里有车、哪里是实线，才能规划路线。

核心技术细节 —— 几何物理融合（公式 1）：

$$\text{Attention}(Q, K, V) = \text{Softmax}\left(\frac{QK^T}{\sqrt{C}} - \tau D\right)V$$

常规的注意力机制只有前半部分，决定谁和谁更相关。但这里多了一个极其关键的 “惩罚项”：$- \tau D$

$D$ 是什么？ 两个物体在真实 3D 物理世界里的 欧几里得距离（比如动态车与车之间、车与车道线之间）
$\tau$ 是什么？ 通过多层感知机（MLP）学习出来的系数
精妙之处：如果一辆车离你很远（$D$ 很大），那么它在注意力分数里就会被狠狠扣分。这强迫 AI 司机 “把有限的注意力集中在离自己最近、最危险的物体上”！

主脑的特权：这个距离惩罚对感知代表有效，但对 规划代表没有距离限制！为什么？因为作为最高决策者，规划主脑必须有统揽全局的视野。

🎯 议程三：去图像里找证据 —— 任务可变形注意力模块

讨论出了初步结果，代表们需要带着目前的猜测，去原始的摄像机画面里 “精准取证”，刷新自己的认知。

感知代表的做法：把 3D 锚点顺着预设高度，利用相机参数 投影到 2D 环视图像上，然后在投影落下的那个点附近采样提取图像特征。

规划主脑的终极奥义（PDA）：

把预测的"未来 3D 行驶轨迹路点"投影到多个摄像头画面上
让主脑自己学习：在轨迹周围哪些像素点最值得关注？
目光死死盯住"车轮即将压过的未来路线"周围的画面！提取图像特征。

三、伪代码实现：老司机的脑神经

import torch
import torch.nn.functional as F

def Unified_Decoder(
    image_features,   # [多视角环视图像特征 F] (监控录像)
    queries,          # [动态物体Qa, 静态地图Qm, 规划主脑Qp] (拿着清单的代表)
    anchors,          # [动态框Aa, 静态线段Am, 未来轨迹Ap] (各自关注的3D物理坐标)
    history_memory,   # [上一帧存下来的重要记忆]
    camera_params,    # [相机的内外参矩阵] (用于3D到2D的投影)
    num_layers=6      # 会议通常要开好几轮 (堆叠6层Decoder)
):
    # --- 会议前奏：代表入场 ---
    Qa, Qm, Qp = queries
    Aa, Am, Ap = anchors

    # 🔄 开始循环开会：每一层 Decoder 都在进行信息的深度融合
    for layer in range(num_layers):

        # =========================================================
        # 🕒 议程一：时序交互模块 (Temporal Interaction Module)
        # 目标："温故知新"，看看上一秒发生了什么。
        # =========================================================

        # 1. 脑容量有限，用 Top-k 机制挑选上一帧最有价值的记忆点
        hist_k_agent, hist_k_map, hist_k_plan = select_top_k(history_memory)

        # 2. 感知代表各自查阅自己的历史卷宗 (Cross-Attention)
        Qa = CrossAttention(query=Qa, key=hist_k_agent, value=hist_k_agent)
        Qm = CrossAttention(query=Qm, key=hist_k_map,   value=hist_k_map)

        # 💡 3. 【老司机的特权】规划主脑不仅看自己的历史轨迹，
        #    还要盯着历史的感知环境！
        Qp_self_hist = CrossAttention(query=Qp, key=hist_k_plan, value=hist_k_plan)
        Qp_perc_hist = CrossAttention(
            query=Qp,
            key=concat(hist_k_agent, hist_k_map),
            value=concat(hist_k_agent, hist_k_map)
        )
        Qp = combine_features(Qp_self_hist, Qp_perc_hist)

        # =========================================================
        # 🗣️ 议程二：协同交互模块 (Collaborative Interaction Module)
        # 目标：统一的圆桌会议，互相通气，引入"物理距离惩罚"！
        # =========================================================

        # 1. 把所有人拉进一个群里
        Q_all = concat(Qa, Qm, Qp)
        A_all = concat(Aa, Am, Ap)

        # 2. 计算纯粹的注意力分数 (谁跟谁有关联)
        attn_scores = torch.matmul(Q_all, Q_all.transpose(-2, -1)) / math.sqrt(C)

        # 💡 3. 【核心技术细节：公式(1)】计算真实物理世界中 3D 锚点之间的距离矩阵 D
        D_matrix = calc_euclidean_distance_3d(A_all, A_all)

        # ⚠️ 【主脑特权掩码】规划主脑(Qp)看所有人都不受距离限制
        D_matrix = apply_planning_mask(D_matrix, mask_value=0.0)

        # 4. 用一个小网络学习一个动态系数 tau (控制惩罚力度)
        tau = MLP(Q_all)

        # 5. 施加物理距离惩罚！距离越远的物体，注意力得分被扣得越惨
        penalized_scores = attn_scores - (tau * D_matrix)
        attn_weights = F.softmax(penalized_scores, dim=-1)

        # 6. 根据惩罚后的权重，大家交换情报
        Q_all_updated = torch.matmul(attn_weights, Q_all)

        # 7. 散会，大家拿着更新后的情报各自归位
        Qa, Qm, Qp = split_queries(Q_all_updated)

        # =========================================================
        # 🎯 议程三：任务可变形注意力模块 (Task Deformable Attention Module)
        # 目标：拿着讨论结果，去图像画面里"精准取证"。
        # =========================================================

        # 1. 感知代表去找车和线：把 3D 的框和线投影到 2D 图像上
        P_a_2d = project_3D_to_2D(Aa, camera_params)
        P_m_2d = project_3D_to_2D(Am, camera_params)
        Qa = DeformableAttention(query=Qa, reference_points=P_a_2d, features=image_features)
        Qm = DeformableAttention(query=Qm, reference_points=P_m_2d, features=image_features)

        # 💡 2. 【核心技术细节：公式(2) PDA】规划主脑的终极绝技！
        #    把预测的"未来3D行驶轨迹路点"投影到多个摄像头画面上
        P_p_2d = project_trajectory_to_2D(Ap, camera_params, predefined_heights)

        # 让主脑自己学习：在轨迹周围哪些像素点最值得关注？
        sampling_offsets, sampling_weights = MLP_predict_offsets_weights(Qp)

        # 施展 PDA：目光死死盯住"车轮即将压过的未来路线"周围的画面！
        Qp = PDA_DeformableAttention(
            query=Qp,
            reference_points=P_p_2d,
            offsets=sampling_offsets,
            weights=sampling_weights,
            features=image_features
        )

        # 🔄 层级收尾：更新代表们的 3D 坐标锚点
        Aa = update_anchors(Aa, Qa)
        Am = update_anchors(Am, Qm)
        Ap = update_anchors(Ap, Qp)  # 轨迹越来越精确

    # 🚪 整个开会流程结束，输出给外面的业务部门 (Heads) 去执行
    update_history_memory(Qa, Qm, Qp)

    return Qa, Qm, Qp

伪代码里的三个"高光时刻”

议程一中的 combine_features(Qp_self_hist, Qp_perc_hist)：规划时不仅记得自己上一秒想怎么走，还直接调取了上一秒周围环境的原始记忆，没有中间商赚差价。
议程二中的 penalized_scores = attn_scores - (tau * D_matrix)：这就是论文里最惊艳的 几何物理融合。它强迫网络变成一个真正的司机——“不要看天上飞的鸟，看离你保险杠只有半米远的那辆车！”
议程三中的 PDA_DeformableAttention：传统的网络是在图像上撒网捞鱼，而这里是 “按图索骥”。沿着预测轨迹投影到 2D 上的路线，只在这个轨迹的左右两边提取图像特征。

四、秘密训练法：对齐匹配（Align Matching）

因为搞出了几十种不同粒度、不同模态的预测轨迹，训练的时候 AI 容易"精神分裂”，到底哪个才是最准的？

对齐匹配机制（公式 6）：

在训练时，采用 “赢家通吃”（Winner-takes-all） 的策略
先在所有的轨迹预测组里，找到和真实人类轨迹（Ground Truth）差距最小（L2 距离最小）的那组作为"学霸（Reference）"
然后，强迫其他所有的粒度组，都向这个"学霸"的模态对齐，共享匹配结果，把梯度有效地反向传播回去

五、战绩揭晓（实验结果）

这位练成神功的 HiP-AD 老司机去考场了，结果直接"屠榜"！

闭环终极测验（Bench2Drive 数据集）

指标	HiP-AD	第二名（DriveTransformer）
成功率	72.7%	35%（翻了一倍多）
驾驶得分	88.3	远超所有现有端到端模型

特殊技能考核

高难度科目	成功率
紧急刹车	83.33%
超车	84.44%
汇入车流	50%

不再像以前的模型那样遇到复杂路况就死机！

开环基础测验（nuScenes 数据集）

碰撞率：0.01% - 0.05%（极低）
感知和预测任务也拿到了顶尖分数，证明底盘依然极度扎实

六、总结与局限

一句话总结

HiP-AD 通过 “分层多粒度预测” + “顺着轨迹看图像（PDA）” + “三合一圆桌会议（统一解码器）”，彻底打通了感知与规划的任督二脉，解决了端到端自动驾驶在闭环仿真中不敢开、不会开的难题。

局限性（论文坦诚）

遇到后方突然高速冲过来的车辆时，系统有时候还是会反应不及（这确实也是人类司机的盲区）
目前还在仿真阶段，真车路测将是未来的星辰大海

参考来源

原论文：HiP-AD: Hierarchical and Multi-granularity Planning with Deformable Attention for End-to-End Autonomous Driving
讨论：Gemini 3.1 Pro Preview 对话记录

MomAD: Momentum-Aware Planning in End-to-End Autonomous Driving

Tue, 17 Mar 2026 00:00:00 +0000

论文标题：《Don’t Shake the Wheel: Momentum-Aware Planning in End-to-End Autonomous Driving》

一、这篇论文在讲什么？

核心问题：AI司机的"帕金森式哆嗦"

光看标题脑海里是不是就有画面了？没错，这篇论文解决的就是自动驾驶汽车**“疯狂画龙”、“方向盘乱抖”**的痛点！

现在的端到端自动驾驶模型（如UniAD、VAD等）存在一个致命弱点：“单帧依赖（One-shot prediction）”。

这就像一个新手司机，每开一秒钟都要重新做一次决定，完全不管上一秒自己是怎么想的。如果遇到短暂的视野遮挡（比如旁边大车挡了一下），或者感知模块稍微闪烁了一下，它就会立刻改变主意，导致车辆轨迹疯狂摇摆（Vehicle Trembling）。

Figure 1 的直观对比

规划模式	问题表现
确定性规划（a）	只给一条路，遇到突发情况容易撞
多模态规划（b）	给很多条路让你选，但每一帧都在不同轨迹间横跳，导致方向盘乱打
MomAD方案	用"动量"保持轨迹连贯性，同时保留多模态应对突发情况

核心洞察：老司机的"动量"智慧

人类老司机是怎么开车的？是有"惯性"和"动量"的！我们不会因为别人闪了一下大灯就猛打方向盘，我们会根据之前的行驶意图保持连贯性。

MomAD就是要赋予AI这种"老司机"的稳重感。

二、核心方法：MomAD的三大法宝

MomAD框架是怎么做到"稳如老狗"的？核心在于三大技术模块：

法宝一：拓扑轨迹匹配（TTM - Topological Trajectory Matching）

核心目标：在K个候选轨迹中，找出一个跟上一帧意图最"顺滑"衔接的轨迹。

1. 坐标系转换

因为车一直在往前开，前一帧和当前帧的坐标系不一样了。TTM第一步就是把历史轨迹转换到当前的自车坐标系下：

$$T_{past_aligned} = R^{-1}(T_{past} - \Gamma)$$

其中 $R^{-1}$ 是旋转矩阵的逆，$\Gamma$ 是位移向量。

2. 为什么不用简单的欧式距离？

很多模型比对轨迹时用的是欧氏距离（按点算距离），但这玩意儿在过弯道时极其不准，容易被局部干扰。

3. 引入豪斯多夫距离（Hausdorff Distance）

TTM祭出了这个大杀器！豪斯多夫距离测量的是两条轨迹间最大偏差的最小值（最坏情况下的对齐程度）。

$$d_H(T_a, T_b) = \max{d_{forward}(T_a, T_b), d_{backward}(T_b, T_a)}$$

生动比喻：

豪斯多夫距离不仅看两个点离得近不近，更看整个轨迹的"形状（拓扑结构）“像不像。这就像比对两条弯曲的山路，不是看某个点对齐没，而是看整体走势是否吻合。

通过豪斯多夫距离，TTM选出那条和历史轨迹最吻合的当前候选轨迹。

法宝二：动量规划交互器（MPI - Momentum Planning Interactor）

核心目标：光选出来还不够，还要把历史的"经验（动量）“注入到当前的Query中。

子模块A：长时序查询混合器（Long-horizon Query Mixer）

它把历史的规划Query取出来，通过多层感知机（MLP）和**LSTM（长短期记忆网络）**进行时序演化：

# 用Sigmoid处理历史分数，并与历史Query做逐元素乘法（融合历史置信度）
historical_fusion = torch.sigmoid(S_past) * self.mlp_mixer(Q_past)

# 用LSTM模拟时序上的演化
Q_past_prime, _ = self.lstm(historical_fusion.unsqueeze(0))

这就像是把过去几秒钟的环境理解和别人车辆的意图"浓缩"了起来。

子模块B：交叉注意力融合

用选中的当前Query作为主动方，去和浓缩好的历史信息做交叉注意力计算：

# Q: 当前选出的最优 Query
# K, V: 经过时序演化的历史 Query
Q_tilde_p_star_t, _ = self.cross_attention(
    query=Q_p_star_t,
    key=Q_past_prime,
    value=Q_past_prime
)

关键理解：

当前帧只提供 query（此刻我想怎么走），而 key 和 value 全是上一帧经过LSTM提纯的记忆（我过去几秒是怎么打算的）。这一步让模型长了"脑子”，不再是只会看眼前的金鱼记忆！

法宝三：鲁棒实例去噪（Robust Instance Denoising）

核心目标：锻炼模型对感知噪声的抵抗能力。

既然感知模块提供的特征（比如其他车的位置、车道线）可能不准，那就在训练时"折磨"它！

# 训练期间加入高斯噪声扰动
if self.training and self.use_noise:
    noise = torch.randn_like(features_t) * 0.1  # 论文消融实验中噪声比例为0.1最优
    features_t = features_t + noise

作用机制：

让模型在训练时就习惯看"模糊、抖动"的世界。在测试时，这个去噪能力让规划预测器对环境波动极度免疫，即使遇到临时遮挡或漏检，依然能画出平滑的轨迹。

三、全新标尺：怎么量化"稳不稳”？

传统指标的局限性

以前的评价指标只看"当前帧准不准"，不看"前后帧连不连贯"。

TPC（轨迹预测一致性）定义

轨迹预测一致性（Trajectory Prediction Consistency）：在重叠的时间段内，计算"当前预测的轨迹"和"上一帧预测的轨迹"之间的平方差，然后再用真实的验证集轨迹做掩码过滤。

$$TPC = \frac{1}{N}\sum_{t}||T_{pred}^{t} - T_{pred}^{t-1}||^2 \cdot Mask$$

TPC越低，说明车开得越平顺，乘客越不容易晕车！

四、狂飙的成绩单

4.1 首创"弯道数据集（Turning-nuScenes）"

作者发现原来的nuScenes数据集里直道太多了，看不出谁更稳。于是专门把"转弯"的场景挑出来做测试（转弯最容易方向盘发抖）。

惊人数据（Table 3）：

预测未来6秒的轨迹，MomAD相比之前的SOTA模型（SparseDrive），碰撞率暴降了26%
TPC指标大幅优化了0.97米（提升33.45%）

4.2 长时间预测远超同行

预测1-2秒不算啥，预测4-6秒还能保持稳定才叫牛。随着时间拉长，其他模型误差飙升，而MomAD依然保持着极高的平滑度。

4.3 闭环路测（Bench2Drive）

在CARLA模拟器里跑闭环（Table 4），包含超车、避让等44个交互场景：

成功率提高了惊人的16.3%
舒适度提升了7.2%

4.4 消融实验亮点

历史帧数消融（Table 7）：

历史帧不是越多越好。作者发现融合前 $t=2$ 帧的历史信息时，效果达到巅峰；如果融合 $t=3$ 帧，反而因为历史太久远引入了不确定性，导致效果下降。这叫"恰到好处的记忆"。

噪声注入消融（Table 6）：

加了Robust Instance Denoising模块后性能稳步提升，验证了训练时加噪对抵抗感知闪烁的有效性。

五、深度讨论：历史意图引入的"因果混淆"陷阱

一个极其犀利的专家级问题

引入历史意图（也就是上一帧的Query或者轨迹）虽然能让车开得"稳"，但如果不加限制，模型会变成一个"闭着眼睛开车的瞎子"。

三大致命因果混淆陷阱

陷阱	现象	灾难后果
因果倒置（惯性覆盖）	“上一秒我在直行 → 所以这一秒我继续直行”	无视前方突然出现的外卖小哥，直接撞上去
捷径退化（恒等映射）	网络发现直接复制上一帧输出Loss就够低	感知模块退化，变成只会根据昨天猜今天的时间序列外推器
误差雪球（蝴蝶效应）	第1帧的小误判被后续帧不断放大	即使视野恢复清晰，模型也因为历史执念拉不回来

MomAD的破局之道

1. 架构约束：用交叉注意力逼迫模型"看路"

历史意图（提纯后的 $Q_{past}$）作为Key和Value
当前帧的初筛意图作为Query
融合后的Query必须再和当前帧最新的感知实例特征（$F_{ins}$）做二次深度融合

原理：历史只提供"底色"，生杀大权依然牢牢掌握在当前帧的感知特征手里。

2. 训练秘籍：历史Dropout

随机以一定概率把历史意图置为空，强制模型只凭当前帧的单帧图像去做规划。

原理：斩断捷径，让网络明白"不能总是指望抄前一秒的作业"。

3. 施加微扰：打破舒适区

Robust Instance Denoising实际上是一种因果干预，告诉模型要在噪声和历史之间找到真正的因果平衡点。

4. 终极验证：闭环评测

如果模型严重因果混淆，在闭环里不出10秒就会撞树。MomAD在Bench2Drive闭环测试中成功率提升16.3%，是克服因果混淆的最硬核证据。

六、为什么在"Query层面"融合历史？

问题本质

为什么MomAD选择融合历史Query，而不是直接把前后两帧的感知实例（几十个框）融合在一起？

直接融合感知实例的三大致命问题

1. 目标关联灾难

如果把 $t-1$ 帧和 $t$ 帧的实例特征直接堆叠，网络怎么知道上一帧的"框A"和这一帧的"框B"是同一辆车？

MomAD的高明之处：不在"环境（框）“层面做跨帧融合，而在"自我意图"层面做融合，巧妙地绕开了显式的多目标跟踪难题。

2. 信息过载与模式崩溃

把太多原始的环境特征直接丢给Planning Head，网络往往偷懒：

学会直接忽略历史特征，退化回单帧模型
或者预测出不左不右、直接撞墙的"平均轨迹”

MomAD通过TTM强制进行"信息漏斗"过滤：只把"你上一秒最想干的那件事"通过Query塞进去。

3. 缺乏"主观动量"

动量是属于主体的，不是属于环境的。只有交互历史Query，网络才能记住"我原本打算干什么"。

七、交叉注意力的工作机制

信息流动全景图

当前Query（我想怎么走）
    --查询--> 历史Key/Value（我过去怎么打算）
         ↓
    融合后的Query（吸收历史动量的"金丹"）
         ↓
    结合当前感知特征(F_ins)
         ↓
    Planning Head再次裂变，输出K条多模态轨迹

关键理解

被选中的Query是一个"时空锚点"，代表的是"自车当前最稳定、最符合物理惯性的综合运动状态"。

“一生万物"的多模态再生：这唯一一个被历史记忆开过光的Query，在和实例特征结合后，会再次裂变输出K条多模态轨迹。

八、潜在的失败模式

模式一：稀疏表示的"先天不足”——信息漏斗带来的强制失忆

稀疏Query架构的本质是一个"极度势利的安检员"。

预定义本体的诅咒：模型在设计之初，工程师会给它规定好能提取几类Query（车辆、行人、自行车、车道线、斑马线）。

边缘场景灾难：

当空中指示牌出现在画面里时，因为"空中指示牌的文字和状态"不在预定义的Query类别里，这个"安检员"把它当作垃圾扔掉了
越过指示牌后，历史记忆中根本不存在"刚才有个牌子"这件事
Planning Head完全不知道这是一条特定时段只能左转的可变车道

模式二：稀疏实例特征的材质丢失

$F_{ins}$ 虽然是一个256维的隐式特征向量（包含纹理、反光度、边缘锐利度等信息），但：

如果图像分辨率不够，或夜间噪点大，Deformable Attention没采样准
砖块和塑料袋的256维特征就会混淆
出于安全保守策略，自动驾驶车大概率会选择急刹或猛打方向盘避让那个塑料袋

这就是幽灵刹车问题的根源。

九、行业趋势与未来方向

从"空间单帧感知"到"时空连续决策"的跨越

四大解题流派

流派	代表作	核心思想
流式架构	StreamPETR, SparseDrive	不存庞大的图像特征，只存上一帧"提纯后的结果"
世界模型	GAIA-1, MILE, DriveDreamer	不仅预测方向盘和油门，还逼着预测未来的世界长什么样
反事实推断	基于CARLA的闭环端到端	故意把车推向危险边缘，看模型怎么救回来
4D占据栅格	OccNet, UniOcc	在3D体素空间里加上时间维度，预测场景流

终极前沿：Mamba（状态空间模型）

比Transformer更适合处理无限长序列：

Transformer算注意力机制，时间序列越长，算力呈 $O(N^2)$ 爆炸
Mamba可以在保持恒定显存占用的情况下，将历史感受野拉长到过去几十上百帧

进化方向

方向一：视觉-语言-动作大模型（VLA + LLM）

用大语言模型来记忆语义信息，用文本/概念来做记忆，而不是用几何框做记忆。

方向二：混合记忆架构

对动态物体用高效的Sparse Query，同时维护一个低分辨率的Dense BEV/Occupancy记忆网格作为兜底。

十、总结

《Don’t Shake the Wheel》这篇论文极其精准地抓住了端到端自动驾驶"缺乏时序一致性"的命门：

TTM（豪斯多夫拓扑匹配）：保证动作的连贯
MPI（交叉注意力记忆融合）：拓展视野的深度
TPC新指标：重新定义什么是"好"的自动驾驶

通过"Query与特征的强制二次校验（架构）" + “加噪与阻断（训练策略）"，在保证轨迹平滑的同时，保住了模型对突发危险的敬畏之心。

下一次，当你坐在一辆变道丝滑、转弯稳当的自动驾驶汽车里时，它的算法底层，或许就闪烁着这种"动量感知（Momentum-Aware）“的智慧光芒！

十一、深度追问：只输入历史环境特征能避免捷径学习吗？

一个极具诱惑力的假设

既然输入历史轨迹或历史运动状态都会导致模型走捷径，那是不是意味着：我不直接输入历史的轨迹结果，也不输入历史的运动状态，只输入历史的环境特征，就不会导致模型走捷径的行为？

这是一个非常敏锐的假设，逻辑看似完美：既然网络是个"偷懒的作弊狂”，那我干脆把"答案（历史轨迹）“和"公式（历史物理速度）“全给它藏起来，只给它看"历史风景（环境特征）"，逼着它每一帧都自己重新做题，这样不就能彻底根治"捷径学习（Shortcut Learning）“了吗？

残酷的真相：神经网络依然有 100 种方法找到捷径！

即使只输入历史的环境特征，神经网络依然能找到隐蔽的作弊路径：

捷径一：化身"视觉里程计”，反向推导隐藏数据

作弊手法： 当你把 $t-1$ 和 $t-2$ 的环境特征（周围的树木、静止的建筑物、车道线）喂给模型时，网络内部的 Self-Attention 或 3D 卷积会瞬间计算出这些静态物体在相邻两帧之间的像素位移。
物理学的降维打击： 如果一棵树在 0.1 秒内向后移动了 1 米，网络根本不需要你告诉它速度，它自己就能计算出"自车速度是 10 m/s，且没有打方向盘”。
最终结果： 网络在几层隐藏层之后，原封不动地把你辛苦藏起来的"自车历史状态和轨迹"重新还原了出来！

捷径二：患上"领头羊依赖症”

作弊手法： 训练数据集里，绝大部分时间车都是在跟车行驶。网络发现：“我只要死死咬住正前方那辆车，它的位置就是我的轨迹！”
致命灾难： 一旦前车是个闯红灯的疯子，你的模型会因为极度依赖"前车环境特征"而毫无判断力地跟上去，直接车毁人亡。

捷径三：“静态环境假象"导致的感知休眠

作弊手法： 网络发现 $t-1$ 的环境和 $t$ 的环境有 99% 是一模一样的，何必费劲去处理当前帧的那 1% 的变化？
致命灾难： 这就是为什么很多只输入环境特征的模型，在遇到"鬼探头"时反应总是慢半拍。

核心结论

解决因果混淆，不能靠"堵（隐藏信息）"，只能靠"疏（机制约束）“和"骗（对抗训练）"！

只要输入序列包含时间维度，神经网络就一定能复原出物理运动学捷径。因此，现代端到端自动驾驶的哲学已经变成了：我不怕你知道历史，我怕你沉迷历史。

十二、Cross-Attention 的数学本质：为什么"当前为主，历史为辅”？

权力的游戏：谁掌握 Query，谁就掌握"生杀大权”

在 Cross-Attention 的公式中： $$Attention(Q, K, V) = Softmax(\frac{Q K^T}{\sqrt{d}}) V$$

这三个字母的地位是绝对不平等的：

Query (Q) 是"带资进组的甲方/大老板”：它是主动方，带着当下的需求去数据库里发起检索。
Key (K) 和 Value (V) 是"被动的资料库/顾问"：它们只能安静地躺在那里，等待被点名。

在 MomAD 的架构中：

当前帧提取的初筛意图 = Query (大老板)：代表"我此时此刻眼前看到的战况"
历史意图 = Key/Value (历史顾问)：代表"我过去几秒钟的惯性和计划"

致命对比：如果用 Concat 或 Add 会怎样？

假设网络设计为：最终特征 = MLP(当前特征 + 历史特征)

网络的作弊手段： 网络会在 MLP 权重矩阵里，给"当前特征"分配极低权重（$0.01$），给"历史特征"分配极高权重（$0.99$）。
灾难结果： 不管当前帧发生什么，历史惯性都会强行碾压当前视觉，这就是典型的捷径学习。

Cross-Attention 凭什么能防作弊？ 因为它的融合是乘法约束（Dot Product $Q \cdot K^T$），而不是加法线性组合！

如果当前帧 $Q$ 看到前方空旷，历史 $K$ 也是直行，内积很大，历史 $V$ 被顺利吸收。
关键时刻： 如果当前帧 $Q$ 突然看到窜出来的行人，大老板 $Q$ 的特征向量会瞬间变成"紧急避让"。此时，“紧急避让的 $Q$” 和"历史直行的 $K$" 方向完全不一致，它们的内积会接近于 0！
物理绞杀： 经过 Softmax 后，这个历史顾问的权重会被死死地压在 $0.00001$，历史信息直接被乘法物理清零！

反向作死实验：如果把"历史"作为 Query 会怎样？

这被称为**“确认偏误的架构放大器”**！

历史（大老板）拿着"左转"的 $Q$，去当前帧的画面里死抠能支持它左转的证据。
哪怕当前画面里有一辆大卡车挡住了左转道，历史 $Q$ 也会对大卡车视而不见，只把注意力放在远处的左转红绿灯上，最终导致直接撞上卡车。

十三、模型的走捷径方法讨论

问题

有没有可能模型让当前帧的 Query变成一个无脑接受历史信息的傀儡，从而实现拷贝历史的捷径？

答案

Cross-Attention机制下理论上不可行。因为为了让V完全被采纳，我们需要构造出一个和历史K的内积为单位阵的Q，但是我们在构造当前帧的Q时，没有提供任何关于历史的信息，所以它没办法和历史K“串供”。所以理论上通过Cross-Attention去融合历史信息是可以防止模型走捷径照抄历史的。
但是如果是通过concat和mlp去获取历史信息，模型只需要把mlp网络中对应到历史信息的那部分权重调到0.99即可。所以concat+mlp是个很糟糕的融合历史的设计，很容易让模型走捷径。

十四、为什么 Dropout 和扰动仍然必不可少？

高级偷懒法：基于统计先验的"盲猜串供"

虽然 Cross-Attention 切断了 Q 提前看 K 的通道，但模型发现一个宇宙级统计规律：

自动驾驶的长尾诅咒： 汽车 95% 的时间都在沿着车道线匀速直行。
K 的高度同质化： 95% 的训练样本里，历史 $K$ 长得几乎一模一样（都是"直行"向量）。
Q 的终极摆烂策略： 把所有 $Q$ 都无脑映射成能和"直行K"完美匹配的形状，不就能拿 95% 的高分吗？

这叫"没有串供，但达成了默契"。 这种偷懒比直接改 MLP 权重更难被发现！

为什么必须上"酷刑"？

既然 Cross-Attention 无法阻止模型利用统计先验"盲猜"，就必须动用物理手段（拔网线和给历史下毒），打破这个 95% 的稳定预期：

第一道金牌：信息隔离墙（不准串供）

在生成当前候选 Query 时，网络绝对接触不到历史状态！它只能从当前帧的图像像素里提特征，强行生成一组代表当前意图的 Query。只有当这组无法作弊的 Query 生成完毕后，大门才打开，让它去和历史做 Cross-Attention。

第二道金牌：历史 Dropout（拔网线）

对付"摸鱼大师"最好的办法，就是时不时抽查它的真本事。

在训练迭代中，设置一个概率（比如 30%），强行把传入的历史特征（Key 和 Value）全部清零。
当网络正准备"无脑抱历史大腿"时，突然发现大腿没了！Loss 直接爆炸。
为了在"断电时刻"活下来，网络被迫疯狂压榨当前帧的图像编码器，让它必须具备极强的单帧看路能力。

第三道金牌：给历史"下毒"（MomAD 的灵魂——Robust Instance Denoising）

既然网络喜欢"无脑信任历史"，那我就故意让历史变得不可信。

在训练阶段，给输入的特征人为加上高斯噪声。
假设上一帧真实情况是"直行"，但扰动让历史顾问传递出"我要向左猛打方向盘"的错觉信号。
网络经过成千上万次"受骗"与"惩罚"，终于悟出：“历史顾问经常发神经，我必须坚决相信我这双眼睛看到的真相！”

十五、终局总结：架构防"小人"，训练防"懒汉"

防御层级	方法	防住什么	防不住什么
Concat + MLP	无防御	-	一切捷径
Cross-Attention (只用架构)	关上了串供的门	直接改参数躺平	统计先验盲猜
Cross-Attention + Dropout + 扰动	关门 + 放狗 + 拆门	几乎所有捷径	-

真正的护城河是组合拳： 物理隔离（不能提前偷看）+ 拔网线（History Dropout）+ 钓鱼执法（加噪声微扰）。

这三招齐下，才把端到端自动驾驶网络，从一个"只会复读的录音机"，逼成了一个"既懂历史规律、又对当下极其警惕的老司机"！