G3　逆博弈、Level-k 与预测-规划一体化¶

前两章把博弈规划的"正向"问题打透了：G1 给出理论底座（HJI、可达性、耦合 Riccati），G2 给出实时求解器（iLQGames、ALGAMES、SE-IBR）。但所有这些求解器都有一个**致命的隐含前提**——它们都假设**对手的代价函数已知**。iLQGames 要你写出对手的 \(\ell_j\)，ALGAMES 要你知道对手的约束，SE-IBR 要对对手的优化问题求灵敏度。可现实里，路口那辆车想直行还是右转、对向司机是激进还是谦让、行人会不会突然加速——这些**对手的真实意图和偏好，恰恰是未知的**。

这就是 G3 要解决的问题，也是 G1 §1.1 那"三次认知跨越"里**尚未兑现的第三跨**：从"代价已知"到"代价需推断"。我们要做的是**逆博弈（inverse game）**——不再是"给定代价求均衡"（正向），而是"给定观测到的行为，反推出对手的代价"（逆向）。一旦推断出对手代价，就能用 G2 的求解器预测它接下来会怎么做——而且这个"预测"天然考虑了 ego 的影响，因为它来自博弈均衡。

这一章给出四条主线，层层递进： - 逆博弈形式化（§3.1）——把"从轨迹反推代价"写成一个最大似然问题，核心技术是把 Nash 解看成代价参数的隐函数、用隐函数定理求导（G2 §2.6 的灵敏度在这里升级成完整的逆问题引擎）。 - Level-k / 认知层级（§3.2）——人类不是完美的 Nash 玩家，而是有限理性的。Level-k 用"我想你想我……"的有限层递归，给有界理性建模。 - GameFormer（§3.3）——把 Level-k 嵌进 Transformer 的 decoder，用端到端学习隐式逼近 Nash，拿下 Waymo/nuPlan 的 SOTA。 - 预测-规划一体化（§3.4）——把前三者收束成一个范式转变："预测"就是博弈均衡中对手的最优响应，"规划"就是 ego 的最优响应，两者同时求解，从根上消除传统"先预测后规划"管线的 frozen robot 病。

一条贯穿全章的主线是 G2 的求解器如何变成 G3 的"内层引擎"：逆博弈在外层推断对手代价、在内层调用 G2 的正向求解器算均衡，两者嵌套。理解了这个嵌套结构，你就能把"对手代价未知"这个 G1/G2 回避的难题，变成一个可以用梯度下降求解的推断问题。

本章是论文解读教学：以 Peters RSS 2021（逆博弈奠基）、GameFormer ICCV 2023（端到端范式）等几篇范式论文为骨架，用"论文原文→人话重讲→代码走读"的三栏式精读它们的核心贡献。重心是读懂这些论文**为什么这么设计、它们的范式转变在哪**。

前置自测¶

答不出 ≥ 2 题，建议先补相应前置再读本章。这 5 题对应本章反复用到的前置工具。

（来自 G2） 写出广义 Nash 均衡问题（GNEP）的 KKT 条件（含互补松弛）。如果把所有玩家的 KKT 堆叠成一个方程组 \(F(z)=0\)，这个 \(F\) 依赖哪些量？（→ G2 §2.5）
（来自 G2） SE-IBR 用隐函数定理算"对手最优响应对 ego 策略的灵敏度" \(\partial u_{-i}^*/\partial u_i\)。写出这个隐函数求导的公式。它为什么需要对手 KKT 系统的雅可比可逆？（→ G2 §2.6）
（来自 G2） iLQGames 输出什么形式的解（反馈还是开环）？它每步迭代解的子问题是什么？为什么说它是"iLQR 换内核"？（→ G2 §2.3）
（最大似然估计） 写出高斯噪声下的最大似然估计（MLE）目标。为什么 \(\arg\max_\theta \log p(\hat x\mid\theta)\) 在高斯噪声下等价于最小二乘 \(\arg\min_\theta\|x(\theta)-\hat x\|^2\)？（→ Part 0 / 概率基础）
（Transformer，软前置） Transformer 的交叉注意力（cross-attention）做什么？query/key/value 各来自哪里？（→ 深度学习基础；理解 §3.3 GameFormer 需要）

答案要点（自评用）： 1. GNEP 的 KKT：各玩家拉格朗日量对自身决策变量梯度为零 + 原始可行 + 对偶可行 + 互补松弛 \(\lambda_i g_i=0\)。堆叠后的 \(F(z)\) 依赖所有玩家的状态/控制、拉格朗日乘子、以及代价/约束的参数。 2. \(\partial u_{-i}^*/\partial u_i=-(\partial G/\partial u_{-i})^{-1}(\partial G/\partial u_i)\)，其中 \(G\) 是对手 KKT 残差。需雅可比 \(\partial G/\partial u_{-i}\) 可逆才能求逆（隐函数定理的前提）；它病态对应对手问题接近退化。 3. iLQGames 输出**反馈** Nash（带反馈增益）；每步解一个 LQ 博弈（耦合 Riccati）；"iLQR 换内核"指它把 iLQR 每步的 LQR 子问题换成 LQ 博弈子问题。 4. MLE 目标 \(\arg\max_\theta\log p(\hat x\mid\theta)\)；高斯噪声下 \(\log p\propto-\frac{1}{2\sigma^2}\|x(\theta)-\hat x\|^2+\text{const}\)，最大化它等价于最小化平方误差。 5. 交叉注意力让一组 query 去"查询"另一组 key/value：query 来自当前序列（如当前 agent），key/value 来自**另一**来源（如其他 agent 的预测 + 环境）；输出是按注意力权重对 value 的加权聚合。全部答得清楚 → 直接进 §3.1；第 1-3 题卡壳 → 回 G2 §2.3/§2.5/§2.6；第 5 题卡壳 → 读 §3.3 时补 Transformer 基础即可（软前置）。

本章目标¶

读完本章，你应当能够：

形式化逆博弈：写出逆博弈的最大似然形式——给定观测轨迹 \(\{\hat x_k\}\)，求代价参数 \(\hat\theta\) 使观测"在均衡意义下最可能"，并说清它与正向博弈、与传统 IRL 的关系。
吃透可微博弈求解器：解释如何把 Nash/GNE 解 \(\text{sol}(\theta)\) 看成 \(\theta\) 的隐函数、用隐函数定理算 \(\partial\text{sol}/\partial\theta\)，从而让逆博弈支持梯度下降；理解 Peters RSS 2021 怎么把 iLQGames 嵌进可微管道。
理解 Level-k / 认知层级：说清 Level-0（规则）→Level-k（对 Level-(k-1) 最佳响应）的递归，Cognitive Hierarchy 的 Poisson 混合，以及如何用贝叶斯在线估计对手的 k。
读懂 GameFormer 架构：画出 Level-k decoder 在 Transformer 中的注意力流——每层 decoder 对上一层输出做交叉注意力（最佳响应），并解释它为何能避开 iLQGames 的迭代收敛问题。
掌握"预测即均衡"范式：论证为什么传统"先预测后规划"会导致 frozen robot，以及博弈视角如何用"预测=对手最优响应、规划=ego 最优响应、两者同时求解"消除 prediction-planning 不一致。
会做技术选型：面对一个交互场景，判断该用可解释的逆博弈（iLQGames + MLE）还是端到端的 GameFormer，并说清各自的代价。

知识导航¶

本章的知识可以挂在一棵以"推断对手"为中心的树上。树根是 G3 的核心问题——"对手代价未知，如何从行为反推"；树干是两条互补的推断路线（可解释的逆博弈 vs 端到端的 GameFormer）；树枝是有界理性建模（Level-k）和范式收束（预测-规划一体化）。

                  对手代价未知 → 从观测行为反推（逆问题）
                                │
        ┌───────────────────────┼────────────────────────┐
   怎么反推代价              人类不是完美Nash            范式收束
        │                        │                        │
   §3.1 逆博弈形式化         §3.2 Level-k /            §3.4 预测-规划一体化
   （MLE + 隐函数定理，       Cognitive Hierarchy      （预测=对手最优响应，
    可微博弈求解器）         （有界理性的层级递归）      规划=ego最优响应）
        │                        │                        ↑
        │                        └──────────┐             │
        │                                   ↓             │
        └──────────────────→ §3.3 GameFormer ─────────────┘
                            （Level-k 嵌入 Transformer，
                             端到端隐式逼近 Nash，SOTA）

一条最重要的线索：G2 的正向求解器是 G3 的内层引擎。 §3.1 的逆博弈在外层用梯度下降优化代价参数、内层反复调用 G2 的 iLQGames 算均衡；§3.2 的 Level-k 每一层都是对下一层做一次"最佳响应"（本质是一次正向求解）；§3.3 的 GameFormer 把这个"逐层最佳响应"用 Transformer decoder 实现。理解了"逆 = 在正向外面套一层推断"，全章就串起来了。

推荐阅读路径： §3.1 是全章地基（逆博弈形式化 + 可微求解器），必须吃透，它直接接 G2 §2.6 的隐函数定理； §3.2 Level-k 是处理有界理性的核心工具，相对独立、可单独读； §3.3 GameFormer 是产业落地的端到端范式，依赖 §3.2 的 Level-k 概念 + Transformer 基础； §3.4 是范式收束，把全章拉回 G1 §1.1 的认知跨越，建议最后读以获得整体视角。

本章难度集中在 §3.1（逆博弈的隐函数微分）和 §3.3（GameFormer 架构）。若时间紧张，§3.3 的 Transformer 实现细节可先速读、抓住"Level-k decoder"的核心思想。

前置知识桥接¶

本章重度依赖 G2，这里把会反复取用的几个结论激活一下。

可微博弈与隐函数定理（G2 §2.6，本章核心工具）。 G2 的 SE-IBR 为了算"对手会让多少"，用隐函数定理对对手的 KKT 条件 \(G(u_{-i}^*,u_i)=0\) 求导，得到 \(\partial u_{-i}^*/\partial u_i=-(\partial G/\partial u_{-i})^{-1}(\partial G/\partial u_i)\)。本章 §3.1 把这个技巧**升级**：不再是对单个对手的响应求导，而是把**整个 Nash 解** \(\text{sol}(\theta)\) 看成代价参数 \(\theta\) 的隐函数，对 \(\theta\) 求导。公式同构——把 Nash 的 KKT 条件 \(F(\text{sol},\theta)=0\) 微分，得 \(\partial\text{sol}/\partial\theta=-(\partial F/\partial\text{sol})^{-1}(\partial F/\partial\theta)\)。这个梯度让逆博弈能用梯度下降优化 \(\theta\)。记住 G2 那个隐函数公式，§3.1 就是它的"对参数版"。

正向博弈求解器（G2 §2.3、§2.5）。 iLQGames 解反馈 Nash（解析 Riccati、毫秒级）、ALGAMES 解开环 GNE（AL 处理硬约束）。本章它们都成为**内层引擎**：逆博弈外层优化 \(\theta\)、每次都要调用一次正向求解器算出当前 \(\theta\) 下的均衡轨迹 \(x^*(\theta)\)，再和观测比对。所以"逆博弈贵不贵"很大程度取决于"正向求解快不快"——这就是为什么 G2 把求解器做到毫秒级如此重要。

frozen robot（G1 §1.1）。 把对手当不会反应的固定障碍，预测器会判定无安全间隙、ego 僵死不动。本章 §3.4 会给出这个老问题的最终解法——博弈视角下"预测=对手最优响应"，天然考虑 ego 影响，从根上消除 frozen robot。

Stackelberg + IRL（G2 §2.1，Sadigh 2016）。 Sadigh 2016 用 IRL 从人类轨迹学奖励、再用 Stackelberg 规划影响人类——这是"推断对手代价"思想的先声。本章 §3.1 的逆博弈是它的**严格化与一般化**：Sadigh 用 IRL（单边学人类奖励），Peters 2021 用逆博弈（联合推断所有玩家代价 + 通过 Nash 约束耦合）。下面会详谈这个关系。

如果跳过本章会怎样¶

两个具体场景，说明为什么这一章不能跳。

场景一：你用 G2 的 iLQGames 做了一个交互规划器，但它在真实路口表现糟糕。 你在仿真里给对手设了一组代价参数，iLQGames 跑得很好。一上真实道路，对手（人类司机）的真实代价和你设的不一样——有人激进、有人谦让、有人分心。你的求解器用**错误的对手代价**算均衡，预测的对手轨迹与实际南辕北辙，规划自然失效。跳过本章，你就没有办法**从对手的实际行为在线校正它的代价**——而这正是 §3.1 逆博弈、§3.2 Level-k 在线估计要解决的。

场景二：你想复现 Waymo/nuPlan 排行榜上的 SOTA 预测-规划方法。 当前自动驾驶预测-规划的 SOTA（如 GameFormer）核心思想是博弈论的——把多智能体的联合预测建模成 Level-k 博弈、用 Transformer 端到端实现。不懂逆博弈和 Level-k，你看不懂这些论文为什么这么设计、decoder 为什么要分层、为什么说它"隐式逼近 Nash"。跳过本章，你能跑通别人的代码，却说不清它和"先预测后规划"的传统管线差在哪、为什么更好。

预计阅读时间¶

模式	时间	说明
精读（含逆博弈 MLE 实验 + Level-k highway-env 实验 + GameFormer 论文精读）	20–28 小时（约 2 周）	完整训练本章目标列出的全部能力
速读（理解逆博弈 + Level-k + 预测即均衡的脉络，跳过 GameFormer 实现细节）	6–8 小时	抓住 §3.1 + §3.2 + §3.4 主线
速查（回头查逆博弈公式/Level-k 定义/GameFormer 架构）	—	用章末术语速查表与 API 速查表定位

§3.1　逆博弈的形式化：从行为反推代价　⭐⭐⭐　★ 本章地基¶

这一节解决什么问题：G2 的所有求解器都假设对手代价已知，可现实里它是未知的。这一节把"从观测到的行为反推对手代价"形式化成一个最大似然问题，核心技术是把 Nash 解看成代价参数的隐函数、用隐函数定理求导（G2 §2.6 灵敏度的"对参数版"）。这是全章地基——§3.2 的 Level-k、§3.3 的 GameFormer 都是它的不同实现路线。

动机：你不知道对手想要什么¶

设想你用 G2 的 iLQGames 做了一个路口交互规划器。仿真里一切完美——因为你**亲手设定**了对手的代价：它想多快通过、多在乎安全距离、多愿意让行，参数都是你填的。可一上真实道路，对手是人类司机，他的代价**你根本不知道**：这辆车的司机是赶时间的激进派，还是新手谦让派？他在乎和你保持多远？你用错误的对手代价去算 Nash 均衡，预测出的对手轨迹必然与实际南辕北辙，规划随之失效。

更糟的是，对手不会告诉你他的代价函数。你能观测到的，只有他的**行为**——他的车开过的轨迹。于是问题反过来了：能不能从观测到的轨迹，反推出产生这条轨迹的代价函数？ 这就是逆博弈（inverse game）。正向博弈是"给定代价求均衡轨迹"（G2 做的事），逆博弈是"给定均衡轨迹反推代价"——方向恰好相反。

反面案例：为什么不能"直接拟合一个预测器"¶

一个看似省事的替代方案：既然要预测对手轨迹，那我干脆收集一堆对手轨迹数据，训练一个神经网络预测器（输入历史轨迹、输出未来轨迹），不就绕过"推断代价"了吗？这正是传统"先预测后规划"管线的做法，它有两个根本问题（§3.4 详谈，这里先点出）：

其一，预测不考虑 ego 的影响。独立训练的预测器把对手轨迹当成一个**与 ego 无关**的量来预测——它学的是"对手过去怎么走、未来就怎么走"。但真实交互里，对手会**对 ego 的动作做反应**：你逼近，他让；你退让，他抢。一个不考虑 ego 影响的预测器，预测的是"对手在你不存在时会怎么走"——这直接导致 G1 §1.1 的 frozen robot（预测把所有间隙占满、ego 僵死）。

其二，预测器是黑箱、不可解释、不可外推。神经网络预测器学到的是轨迹的统计模式，不是对手的**意图**。换个没见过的场景（训练集没有的路口几何），它就失效；而且你无法问它"对手到底想要什么"。

逆博弈的不同在于：它推断的是对手的**代价函数（意图）**，而非直接预测轨迹。代价函数是一个**紧凑、可解释、可外推**的对手模型——一旦推断出"这个司机很激进、不在乎安全距离"，你就能用 G2 的求解器预测他在**任何**新场景下会怎么做，而且这个预测天然考虑了 ego 的影响（因为它来自博弈均衡）。

历史：从 Sadigh 的 IRL 到 Peters 的逆博弈¶

推断对手代价的思想，最早可追溯到 G2 §2.1 讲过的 Sadigh 2016——它用逆强化学习（IRL）从人类轨迹学出人类的奖励函数。但 Sadigh 的 IRL 是**单边**的：它学的是人类一方的奖励，把机器人当 Stackelberg leader。

把它严格化、一般化到**多智能体联合推断**的，是 Peters、Fridovich-Keil、Rubies-Royo、Tomlin、Stachniss 在 RSS 2021 的工作（"Inferring Objectives in Continuous Dynamic Games from Noise-Corrupted Partial State Observations"，扩展版发表于 IJRR 2023）——这是逆博弈范式的奠基。它的核心创新，是把"推断代价"和"博弈均衡"**耦合**起来：

论文原文（Peters RSS 2021 的核心主张，转述）：该方法通过 Nash 均衡约束，把每个玩家未知代价参数的估计，与未观测状态/输入的推断**耦合**在一起，从带噪、部分的状态观测中学习所有玩家的目标。

用人话重讲：Sadigh 的 IRL 单独学人类奖励、把机器人当 leader；Peters 的逆博弈把**所有玩家**（不分 leader/follower）的代价参数放在一起推断，并要求"推断出的代价所对应的 Nash 均衡，要能解释观测到的所有轨迹"。关键词是**耦合**——不是各学各的，而是通过"观测轨迹必须是某个 Nash 均衡"这个约束，把所有玩家的代价绑在一起联合求解。这就比单边 IRL 更贴近真实多车交互：路口每辆车都在对其他车反应，没有谁天然是 leader。

论文 → 代码桥接：Peters 2021 的实现把 iLQGames 嵌进一个可微优化管道——外层用梯度下降优化代价参数 \(\theta\)，内层每次调用 iLQGames 算出当前 \(\theta\) 下的 Nash 轨迹，再和观测比对、反传梯度。下面的理论小节会讲清这个"可微"是怎么做到的（隐函数定理），代码小节给出可运行的最小实现。

这条线后来枝繁叶茂：LUCIDGames（在线 UKF 逆博弈）、MaxEnt Games（有界理性）、Auto-Encoding Bayesian（贝叶斯后验）——都建在 Peters 2021 的"可微博弈 + 推断代价"地基上。

多视角理解（逆博弈 ↔ 心智理论 Theory of Mind）：逆博弈在做的事，和认知科学里的**心智理论（Theory of Mind, ToM）惊人地相似——ToM 指人类推断他人心理状态（信念、欲望、意图）的能力。相似之处：人开车时本能地"读"其他司机的意图（那辆车想并道、这个行人要过街），据此调整自己的行为——这正是从他人**行为**推断其**意图，与逆博弈从轨迹反推代价同构。代价函数就是机器版的"欲望/意图"。不同之处：人的 ToM 是快速、直觉、隐式的（一瞥就知道对方想干嘛）；逆博弈是显式、数学化的（写出 MLE、解优化）。GameFormer（§3.3）某种意义上更接近 ToM——它把这种推断**摊销**进神经网络，运行时一瞥（一次前向）就给出预测，像人的直觉。一句话：逆博弈是给机器人装上"心智理论"——让它能从他人行为读出他人意图，这是安全交互的认知前提。 这个类比的价值：它提醒你逆博弈不是抽象的数学游戏，而是在解决一个人类每天开车都在用的核心能力；也解释了为什么 §3.2 的 Level-k（"我想你想我"）天然属于这里——递归的信念推理正是 ToM 的核心。

理论：逆博弈的最大似然形式¶

把逆博弈写成精确的数学。先回顾**正向**博弈（G2）：

正向博弈：给定所有玩家的代价参数 \(\theta=(\theta_1,\dots,\theta_N)\)，求 Nash/GNE 均衡解 \(x^*(\theta)\)（均衡轨迹）。 G2 的 iLQGames、ALGAMES 干的就是这件事——\(\theta\) 进、\(x^*\) 出。

逆博弈：给定观测到的轨迹 \(\hat x_{1:T}\)（带噪、可能部分观测），求代价参数 \(\hat\theta\)，使得"观测轨迹在均衡意义下最可能"。写成最大似然估计（MLE）：

\[\hat\theta=\arg\max_\theta\ \log p(\hat x_{1:T}\mid\theta). \tag{3.1}\]

在高斯观测噪声假设下（观测 = 真实均衡轨迹 + 高斯噪声），最大化对数似然等价于最小化加权最小二乘：

\[\hat\theta=\arg\min_\theta\ \sum_k\big\lVert x_k^*(\theta)-\hat x_k\big\rVert_\Sigma^2, \tag{3.2}\]

其中 \(x_k^*(\theta)\) 是"假设代价参数为 \(\theta\) 时，正向博弈解出的均衡轨迹在时刻 \(k\) 的状态"，\(\Sigma\) 是观测噪声协方差（加权用）。

本质洞察（逆博弈 = 在正向求解外面套一层参数优化）：(3.2) 的结构值得盯住看——它是一个**双层结构**。外层：对代价参数 \(\theta\) 做优化（最小化"均衡轨迹与观测的偏差"）。内层：对每个候选 \(\theta\)，调用正向博弈求解器算出均衡轨迹 \(x^*(\theta)\)。换句话说，逆博弈 = 正向求解器（G2）+ 外层一个参数拟合循环。这解释了为什么 G2 把求解器做到毫秒级如此关键——逆博弈外层每走一步梯度，内层就要解一次完整的正向博弈；正向越快，逆博弈才越可行。也解释了 §3.1 和 G2 的关系：G2 是引擎，G3 是把引擎装进推断的车架。

与 IRL 的关系。 逆博弈和逆强化学习（IRL）数学上同源——都是"从行为反推代价/奖励"。区别在于**耦合结构**：IRL 通常推断单个智能体的奖励（把环境/他人当固定）；逆博弈推断**多个**智能体的代价，并通过 Nash 均衡约束把它们耦合——它假设观测轨迹是一个**多人博弈的均衡**，而非单人最优。所以逆博弈是"博弈版的 IRL"，更适合多车交互这种"人人都在对别人反应"的场景。一个实践提示：当场景里只有一个需要建模的对手、且它基本不对 ego 反应时（如 ego 在跟一辆几乎匀速的前车），单边 IRL 就够了，不必上完整逆博弈；只有当多 agent 真正相互反应、把谁当固定都会失真时，逆博弈的"通过 Nash 约束联合推断"才体现价值。选 IRL 还是逆博弈，取决于交互的耦合强度。

系统性分类（三种"从行为学习"的方法）：逆博弈、IRL、模仿学习都从观测行为学习，但学的东西和适用场景不同，常被混淆：

方法	学什么	对交互的假设	输出	适用
模仿学习（BC）	直接学"状态→动作"映射	不建模交互	一个策略（黑箱）	单 agent 模仿专家、数据多
逆强化学习（IRL）	学单个 agent 的奖励/代价	环境/他人当固定	一个代价函数	单 agent 意图推断、他人不反应
逆博弈（inverse game）	联合学所有 agent 的代价	观测是多人博弈均衡	多个代价 + 耦合	多 agent 相互反应（多车交互）

三者是递进的：模仿学习最浅（不问为什么，直接学动作），IRL 进一步（学动作背后的代价），逆博弈最深（学多个相互反应的 agent 各自的代价，并通过均衡约束耦合）。关键判据是"交互的耦合强度"：无交互→模仿学习；单向影响（他人不反应）→IRL；双向相互反应→逆博弈。误用的代价：在强交互场景用 IRL（把他人当固定），会像 §3.4 的 frozen robot 一样，学出"他人不会反应"的错误模型。

三栏式精读：Peters 2021 如何耦合"状态推断"与"参数估计"¶

Peters 2021 最精妙的设计，是处理"带噪 + 部分观测"的方式。真实观测往往不完整——可能只看到位置不看到速度、可能有遮挡缺帧。按论文解读教学的三栏式（论文原文 → 人话重讲 → 代码骨架），精读它怎么解决这个问题。

论文原文（转述）：该方法通过 Nash 均衡约束，把每个玩家未知代价参数的估计，与未观测状态/输入的推断**耦合**起来。通过把过去的状态估计与未来的状态预测耦合，该方法……

人话重讲：观测不全（比如只有部分时刻、部分维度），怎么办？朴素想法是"先补全状态、再估参数"，但这是错的——补全状态需要知道动力学和策略（依赖参数），估参数又需要完整状态，鸡生蛋。 Peters 的解法是**联合优化**：把"未观测的状态/输入"和"未知的代价参数"放进**同一个优化问题**，同时求解，并用 Nash 均衡约束把它们绑在一起。直觉：均衡约束规定了"给定参数，状态轨迹必须满足什么"，所以一旦参数对了，未观测的状态会被均衡约束自动"填"成一致的值；反过来，未观测状态填对了，参数的似然才高。两者在联合优化里相互校正、一起收敛。

代码骨架（联合优化变量 = 参数 + 未观测状态）：

# Peters 2021 的联合优化结构（概念骨架，非完整实现）
# 决策变量同时含：代价参数 θ + 未观测的状态/输入 z
def joint_objective(theta, z, partial_obs):
    full_traj = assemble_trajectory(z, partial_obs)      # 用 z 补全部分观测，得完整轨迹
    # 项1：完整轨迹要拟合观测到的那部分
    obs_loss = fit_observed_part(full_traj, partial_obs)
    # 项2：完整轨迹要满足 θ 下的 Nash 均衡约束（KKT 残差→0）
    nash_residual = nash_kkt_residual(full_traj, theta)  # 均衡约束把 θ 和 z 耦合
    return obs_loss + weight * nash_residual**2

# 同时对 (θ, z) 优化——参数估计与状态推断耦合求解
theta_hat, z_hat = minimize(joint_objective, init_theta, init_z, partial_obs)

本质洞察（均衡约束是"耦合剂"）：这个设计的关键，是 nash_kkt_residual(full_traj, theta) 这一项——它**同时**依赖待估参数 θ 和待补全状态（藏在 full_traj 里）。它扮演"耦合剂"：把"状态推断"和"参数估计"这两个本来分离的问题焊成一个。没有它，你只能先补状态再估参数（鸡生蛋）；有了它，均衡约束规定了 θ 和状态必须**联合自洽**，于是可以一起优化。这就是为什么论文标题敢说能处理"Partial State Observations"——它不要求完整观测，而是把缺失的部分当待估变量，靠均衡约束补齐。这也是 §3.1 陷阱 4（误以为需要完整观测）的正解所在：Peters 2021 的核心贡献正是用均衡约束耦合状态推断与参数估计，从而处理不完整观测。注意这比前面 demo 的"假设完整观测、只估参数"更进一步——真实部署时观测几乎总是部分的，这个联合优化结构才是它实用的关键。

关键技术：用隐函数定理让正向求解器可微¶

(3.2) 要用梯度下降求解，就得算 \(\nabla_\theta x^*(\theta)\)——均衡轨迹对代价参数的梯度。难点在于：\(x^*(\theta)\) 不是一个显式函数，而是正向博弈求解器的**输出**（一个优化/求根问题的解）。怎么对"一个求解器的输出"求导？

答案是 G2 §2.6 用过的**隐函数定理**，这里升级成"对参数版"。关键观察：Nash 均衡解 \(x^*(\theta)\) 满足博弈的 KKT 条件（一阶最优性），把它写成一个隐式方程：

\[F\big(x^*(\theta),\,\theta\big)=0, \tag{3.3}\]

其中 \(F\) 是所有玩家 KKT 条件堆叠成的残差（G2 §2.5 讲过——这正是把 GNEP 写成 MCP 的那个 \(F\)）。 \(F=0\) 对所有 \(\theta\) 恒成立（因为 \(x^*(\theta)\) 总是对应 \(\theta\) 的均衡），所以对 \(\theta\) 求全导：

\[\frac{\partial F}{\partial x^*}\cdot\frac{\partial x^*}{\partial\theta}+\frac{\partial F}{\partial\theta}=0\ \Longrightarrow\ \boxed{\ \frac{\partial x^*}{\partial\theta}=-\Big(\frac{\partial F}{\partial x^*}\Big)^{-1}\frac{\partial F}{\partial\theta}\ }. \tag{3.4}\]

这就是均衡解对参数的梯度——由 KKT 残差的两个雅可比算出：\(\partial F/\partial x^*\)（残差对解的雅可比，即博弈的"Hessian"）和 \(\partial F/\partial\theta\)（残差对参数的雅可比）。

本质洞察（隐函数定理 = 不解开求解器也能对它求导）：(3.4) 的威力在于——它让你**不必把正向求解器展开成显式公式**，就能对它的输出求导。你只需要知道均衡满足的 KKT 条件 \(F=0\)，对这个**隐式**条件求导，就得到了梯度。这正是 G2 §2.6 SE-IBR 那个 \(\partial u_{-i}^*/\partial u_i=-(\partial G/\partial u_{-i})^{-1}(\partial G/\partial u_i)\) 的同构升级——SE-IBR 是对"对手响应关于 ego 策略"求导，逆博弈是对"整个均衡关于代价参数"求导。公式形状一模一样：都是"\(-(\text{对解的雅可比})^{-1}(\text{对另一变量的雅可比})\)"。记住这个形状，你就掌握了**可微博弈（differentiable games）**的全部数学核心——它在逆博弈、SE-IBR、GameFormer 的训练里反复出现。

多视角理解（可微博弈 ↔ 可微优化 / 隐式层）：把 Nash 求解器变成"可微的一层"，这和深度学习里的**可微优化层**（如 OptNet、可微 MPC）是同一种思想。相似之处：都是把一个优化问题/求根问题当成网络里的一层，用隐函数定理（对 KKT/最优性条件求导）实现反向传播，而非把优化迭代展开。不同之处：可微博弈的"优化问题"是一个**多人博弈的均衡**（KKT 是所有玩家最优性的堆叠），比单人优化的 KKT 多了玩家耦合。一句话：逆博弈把 G2 的正向求解器变成了一个"可微层"，于是整个推断管线可以端到端用梯度下降训练——这也是 §3.3 GameFormer 能用神经网络端到端学博弈的数学许可。

代码走读：隐函数定理解析梯度 vs 有限差分¶

(3.4) 是逆博弈的数学核心，但它真的对吗、真的比有限差分好吗？用一个能跑的最小例子验证。取一个单时刻 2 玩家 LQ 博弈——玩家 \(i\) 代价 \(J_i=\tfrac12 q_i(x-\theta_i)^2+\tfrac12 r_i u_i^2\)，\(x=u_1+u_2\)，参数 \(\theta=(\theta_1,\theta_2)\) 是两人的目标。它的 KKT 条件（一阶最优）可以显式写出：\(F_i=q_i(x-\theta_i)+r_i u_i=0\)。

import numpy as np
q1, q2, r1, r2 = 1.0, 1.5, 0.8, 1.2

def solve_nash(theta):
    """正向：解 2 玩家 LQ 博弈的 Nash（联立两个 KKT 条件 F_i=0）。"""
    t1, t2 = theta
    A = np.array([[q1+r1, q1], [q2, q2+r2]])    # KKT 系数矩阵（= ∂F/∂u）
    b = np.array([q1*t1, q2*t2])
    return np.linalg.solve(A, b)                # [u1*, u2*]

theta = np.array([2.0, -1.0]); u_star = solve_nash(theta)

# —— 隐函数定理 (3.4): ∂u*/∂θ = -(∂F/∂u*)^{-1}(∂F/∂θ) ——
dF_du    = np.array([[q1+r1, q1], [q2, q2+r2]])   # ∂F/∂u（KKT 雅可比，与正向求解的 A 同）
dF_dtheta = np.array([[-q1, 0], [0, -q2]])         # ∂F/∂θ（F_i 对 θ_i 的偏导 = -q_i）
grad_analytic = -np.linalg.solve(dF_du, dF_dtheta) # 一次线性求解得全部梯度 ∂u*/∂θ

# —— 有限差分验证 ——
eps = 1e-6; grad_fd = np.zeros((2, 2))
for j in range(2):
    tp = theta.copy(); tp[j] += eps
    grad_fd[:, j] = (solve_nash(tp) - u_star) / eps
print(f"解析梯度:\n{np.round(grad_analytic,4)}")
print(f"有限差分:\n{np.round(grad_fd,4)}")
print(f"最大差异 = {np.max(np.abs(grad_analytic-grad_fd)):.2e}")   # 1.60e-10

跑出来，解析梯度与有限差分的最大差异仅 1.6×10⁻¹⁰（机器精度）——(3.4) 的隐函数定理梯度完全正确：

方法	\(\partial u^*/\partial\theta\)	代价
隐函数定理（解析）	\(\begin{bmatrix}0.804 & -0.446\\-0.446 & 0.804\end{bmatrix}\)	一次线性求解得全部梯度
有限差分	同（差异 1.6e-10）	每个参数维度多解一次博弈

本质洞察（解析梯度省的是"正向求解次数"）：解析梯度和有限差分结果一样，但代价天差地别。有限差分要对**每个参数维度**各扰动一次、各解一次正向博弈——参数有 \(d\) 维就要解 \(d+1\) 次博弈。隐函数定理只需在当前解处算两个雅可比、解一个线性系统，一次**就拿到对所有参数的完整梯度。逆博弈外层梯度下降要走很多步、参数可能高维（每个 agent 多个代价参数），这个差别是"能不能实用"的差别。这也呼应 §3.1 陷阱 2：有限差分不仅慢，尺度还可能病态导致发散；解析梯度又快又稳——这就是为什么 Peters 2021 等用可微求解器（解析梯度）而非黑箱差分。注意 dF_du 正好等于正向求解 solve_nash 里的系数矩阵 A——**正向求解和反向求梯度复用同一个 KKT 雅可比，这是可微优化层实现高效的关键。

代码走读：一个能跑的逆博弈 MLE¶

把上面的理论落成能跑的代码。按论文解读教学的三栏式（论文原文→人话→代码），这里走读一个最小逆博弈 MLE：观测两个智能体的轨迹，反推它们各自的目标点。为聚焦"逆"的逻辑，正向求解用一个简化的双积分器 + 比例控制（代表每个智能体趋向目标的最优策略），真实工程里这里换成 G2 的 iLQGames。

正向博弈（内层引擎）。 给定目标点参数 \(\theta=(g_1,g_2)\)，每个智能体用最优策略趋向自己的目标，rollout 出轨迹：

import numpy as np
dt, T, N = 0.2, 15, 2

def forward_game(theta, x0):
    """正向：给定目标点 θ=[g1(2), g2(2)]，每个 agent rollout 趋向目标的轨迹。
    （真实工程中这里换成 G2 的 iLQGames：θ 进、均衡轨迹出）"""
    g = [theta[:2], theta[2:]]                          # 两 agent 的目标点
    def rollout(g_i, x0_i):                              # 双积分器 [px,py,vx,vy]
        x = x0_i.copy(); traj = [x.copy()]
        for k in range(T):
            ux = 2.0*(g_i[0]-x[0]) - 2.5*x[2]            # 趋向目标的最优控制（代表该 agent 策略）
            uy = 2.0*(g_i[1]-x[1]) - 2.5*x[3]
            x = np.array([x[0]+x[2]*dt, x[1]+x[3]*dt, x[2]+ux*dt, x[3]+uy*dt])
            traj.append(x.copy())
        return np.array(traj)
    return rollout(g[0], x0[:4]), rollout(g[1], x0[4:])  # 两 agent 的轨迹

逆问题（外层参数优化）。 观测 = 真实目标下的轨迹 + 噪声；逆问题最小化 (3.2) 的轨迹偏差，梯度用有限差分近似（真实工程中用 (3.4) 的隐函数定理解析算）：

# 构造观测：真实目标 θ_true 下的轨迹 + 高斯噪声
x0 = np.array([0.,0,0,0, 3.,0,0,0])
theta_true = np.array([4.0, 2.0, 1.0, 3.0])            # 真实目标 g1=(4,2), g2=(1,3)
tr1_t, tr2_t = forward_game(theta_true, x0)
np.random.seed(1)
obs1 = tr1_t[:,:2] + 0.03*np.random.randn(T+1, 2)      # 观测位置（带噪）
obs2 = tr2_t[:,:2] + 0.03*np.random.randn(T+1, 2)

def loss(theta):                                        # (3.2) 的轨迹偏差
    tr1, tr2 = forward_game(theta, x0)
    return np.sum((tr1[:,:2]-obs1)**2) + np.sum((tr2[:,:2]-obs2)**2)

def grad(theta, eps=1e-5):                              # 有限差分梯度（≈ 隐函数定理 (3.4)）
    g = np.zeros(4); L0 = loss(theta)
    for i in range(4):
        tp = theta.copy(); tp[i] += eps
        g[i] = (loss(tp) - L0) / eps
    return g, L0

# 梯度下降反推（从错误初值 [0,0,0,0] 开始）
theta = np.zeros(4); lr = 0.02
for it in range(300):
    g, L = grad(theta)
    g = g / (np.linalg.norm(g)+1e-9)                    # 梯度归一化（防有限差分尺度爆炸）
    theta = theta - lr*g*max(1.0, np.sqrt(L))           # 自适应步长
print(f"反推 θ̂ = g1=({theta[0]:.3f},{theta[1]:.3f}), g2=({theta[2]:.3f},{theta[3]:.3f})")
print(f"真实 θ_true = g1=(4,2), g2=(1,3)，误差 ||θ̂-θ_true||={np.linalg.norm(theta-theta_true):.4f}")

跑起来看结果。 从完全错误的初值 (0,0,0,0) 出发，梯度下降反推：

量	结果
反推 \(\hat\theta\)	g1=(3.996, 1.986), g2=(0.998, 3.011)
真实 \(\theta_{\text{true}}\)	g1=(4, 2), g2=(1, 3)
参数误差 \(\lVert\hat\theta-\theta_{\text{true}}\rVert\)	0.0186

从一无所知的初值，逆博弈仅凭两条带噪轨迹就把两个智能体的目标点反推到误差 0.0186——这就是逆博弈的核心能力：观测行为 → 反推意图。推断出目标后，你就能用正向求解器预测它们在新场景下的行为，而这个预测天然考虑了交互。

本质洞察（轨迹越长，参数越可识别）：这个 demo 用的是**整条轨迹**（16 个时刻 × 2 维）做观测，所以 4 个目标点参数能被精确反推。如果只观测**单个时刻**的状态，参数往往**欠定**——多组不同的代价可能产生同一个瞬时状态，逆问题有无穷多解。这是逆博弈的一个根本性质：可识别性取决于观测的信息量。观测越长、越多样（不同初始条件、不同交互），代价参数越可识别。 Peters 2021 强调"从带噪、**部分**观测推断"，正是因为真实观测往往不完整，可识别性是核心挑战——这也是下面陷阱要强调的。

进阶：逆博弈接 iLQGames 内层（项目甲逆博弈层）¶

上面的 demo 用简化的比例控制做正向求解，便于聚焦"逆"的逻辑。真实的逆博弈（Peters 2021）内层是 G2 的 iLQGames——这才是"逆 = 在正向外面套推断"的完整形态。这里把内层换成真正的迭代博弈求解器（带反向 Riccati），反推**两车交互**中各自的目标点——这正是项目甲的逆博弈推断层。

import numpy as np
dt, T, N, nx_i, nu_i = 0.1, 20, 2, 4, 2; nx = N*nx_i
idx = [slice(0,4), slice(4,8)]

# —— 辅助：单车运动学（自行车模型简化为单积分朝向 + 速度）——
def dyn_i(xi, ui):                          # 单车连续动力学：状态 [px,py,θ,v]，控制 [ω,a]
    px, py, th, v = xi; om, a = ui
    return np.array([v*np.cos(th), v*np.sin(th), om, a])

def step(x, us):                            # 两车整体前向一步（前向欧拉）
    xn = x.copy()
    for i in range(N): xn[idx[i]] = x[idx[i]] + dt*dyn_i(x[idx[i]], us[i])
    return xn

def jac_i(xi, ui):                          # 单车动力学的离散雅可比 (A_i, B_i)
    px, py, th, v = xi; om, a = ui
    Ac = np.array([[0,0,-v*np.sin(th),np.cos(th)],[0,0,v*np.cos(th),np.sin(th)],[0,0,0,0],[0,0,0,0]])
    return np.eye(4) + dt*Ac, dt*np.array([[0,0],[0,0],[1,0],[0,1]])

def ilqgames(theta, x0, iters=12):
    """正向内层：迭代 LQR 近似（简化实现，带反向 Riccati）。θ=两车目标点 [g0x,g0y,g1x,g1y]。
    注意：此处为简化教学实现，每车独立解 Riccati（近似），未组装 G2 §2.3 的耦合块线性系统。
    完整的 iLQGames 应联立求解（见 30_实时博弈求解器.md 的 lq_game_solve）。"""
    goals = [np.array([theta[0],theta[1],0,1.0]), np.array([theta[2],theta[3],np.pi/2,1.0])]
    wg, wu = np.diag([1.,1,0.1,0.5]), np.diag([0.1,0.1])
    ub = [[np.zeros(nu_i) for _ in range(N)] for _ in range(T)]
    xb = [x0.copy()]
    for t in range(T-1): xb.append(step(xb[t], [ub[t][i] for i in range(N)]))
    for _ in range(iters):                              # iLQGames 外层迭代
        K = [[None]*T for _ in range(N)]; kf = [[None]*T for _ in range(N)]
        for i in range(N):                              # 每车反向 Riccati（G2 §2.3 的内核）
            Pi = wg.copy(); pi = wg @ (xb[T-1][idx[i]]-goals[i])
            for t in range(T-2, -1, -1):
                A, B = jac_i(xb[t][idx[i]], ub[t][i])
                S = wu + B.T@Pi@B
                K[i][t] = np.linalg.solve(S, B.T@Pi@A); kf[i][t] = np.linalg.solve(S, B.T@pi)
                Acl = A - B@K[i][t]
                pi = wg@(xb[t][idx[i]]-goals[i]) + Acl.T@(pi - Pi@B@kf[i][t])
                Pi = wg + K[i][t].T@wu@K[i][t] + Acl.T@Pi@Acl
        xs = [x0.copy()]; un = [[None]*N for _ in range(T)]   # 前向 rollout
        for t in range(T-1):
            for i in range(N):
                dx = xs[t][idx[i]] - xb[t][idx[i]]
                un[t][i] = ub[t][i] - K[i][t]@dx - 0.5*kf[i][t]
            xs.append(step(xs[t], [un[t][i] for i in range(N)]))
        for i in range(N): un[T-1][i] = ub[T-1][i]
        xb, ub = xs, un
    return np.array(xb)

# 外层逆博弈：从两车交互轨迹反推它们的目标点
x0 = np.array([-3.,0,0,1.0, 0,-3.,np.pi/2,1.0])
theta_true = np.array([3.5,0.5, 0.5,3.5])
np.random.seed(0)                                       # 固定随机种子，保证下表可复现
obs = ilqgames(theta_true, x0)[:,[0,1,4,5]] + 0.02*np.random.randn(T,4)   # 带噪观测

def loss(theta):                                        # 内层调 iLQGames，外层比对观测
    return np.sum((ilqgames(theta, x0)[:,[0,1,4,5]] - obs)**2)
theta = np.zeros(4); lr = 0.03
for it in range(60):                                    # 外层梯度下降
    L0 = loss(theta); g = np.array([(loss(theta+np.eye(4)[j]*1e-4)-L0)/1e-4 for j in range(4)])
    theta = theta - lr*(g/(np.linalg.norm(g)+1e-9))*max(1.0, np.sqrt(L0))
# 反推结果：θ̂ = 车0(3.51,0.50) 车1(0.50,3.52)，误差 0.019

跑出来，从两车的交互轨迹反推出各自目标点，误差 0.019：

量	结果
真实 \(\theta_{\text{true}}\)	车0(3.5, 0.5), 车1(0.5, 3.5)
反推 \(\hat\theta\)	车0(3.51, 0.50), 车1(0.50, 3.52)
误差	0.019

与前面玩具 demo 的区别：内层是**迭代 LQR 近似（简化实现）**（每车一个反向 Riccati pass、前向 rollout、外层迭代），近似 G2 §2.3 的求解器。外层每走一步梯度，内层就完整跑一次 iLQGames——这就是"逆博弈 = 正向求解器 + 外层参数拟合"的字面实现，也是为什么 G2 把求解器做快如此重要（这里内层跑了 60 次 × 12 iter）。

论文 → 代码桥接（项目甲的求解-推断闭环）：到这里，项目甲的核心闭环成形了。 G1 模块给出耦合 Riccati（求一次 LQ 博弈）；G2 模块把它扩成完整 iLQGames（求一次非线性博弈）；G3 本模块在 iLQGames 外套上逆博弈 MLE（从对手轨迹反推它的代价）。三层嵌套：逆博弈（外层，推断 θ）→ iLQGames（中层，求均衡）→ 耦合 Riccati（内层，求 LQ 博弈）。真实部署时，外层梯度该用隐函数定理 (3.4) 的解析梯度（前面验证过，比这里的有限差分快得多、稳得多）——把 iLQGames 的 KKT 雅可比拿出来解一个线性系统即可。至此项目甲只差 G4 的安全层：当反推的对手代价有误时（§3.4 陷阱 2），用 CBF 兜底硬安全。

逆博弈的计算代价：嵌套结构的乘法效应。 逆博弈"外层套内层"的结构虽优雅，但代价是**乘法式**的——值得工程上算清楚。设外层梯度下降 \(K\) 步、内层 iLQGames 每次 \(M\) 次迭代、每次迭代解一个 \(O(T\cdot n^2)\) 的反向递推（G2），那么一次逆博弈推断的总成本约 \(O(K\cdot M\cdot T\cdot n^2)\)。更糟的是，若外层用有限差分梯度，参数 \(d\) 维就要每步多解 \(d\) 次内层——成本再乘 \(d\)，变成 \(O(K\cdot d\cdot M\cdot T\cdot n^2)\)。举个具体数感受这个 \(d\) 倍因子：设每车 6 个待估代价参数、两车 \(d=12\)，外层梯度下降 \(K=200\) 步。解析梯度每步只解 1 次博弈、共约 200 次；有限差分每步要解 \(d+1=13\) 次、共约 2600 次——同一个推断，正向求解的总次数差了一个数量级；再叠加内层 iLQGames 每次的 \(M\) 次迭代，这往往就是"几秒收敛"与"几十秒才收敛"的差别。这就是为什么前面反复强调两件事：其一，用隐函数定理解析梯度（去掉那个 \(d\) 倍因子，前面验证差异仅 1.6e-10 却快 \(d\) 倍）；其二，内层求解器要快（G2 把 iLQGames 做到毫秒级的价值，在逆博弈里被放大 \(K\cdot M\) 倍）。实践上还有几个降本手段：warm-start（外层相邻步的内层解很接近，用上一步解初始化，\(M\) 可大幅减小）；在线递归代替批量重解（LUCIDGames 的 UKF 每步只做一次增量更新，而非每步从头梯度下降）；减少待估参数维度（只估关键参数如目标、激进度，固定其余）。一句话：逆博弈能不能实时，取决于"外层步数 × 内层成本"这个乘积能压到多小——这也是为什么在线逆博弈（LUCIDGames）比批量逆博弈（Peters 原版）更适合上车。

从离线 MLE 到在线推断：LUCIDGames¶

前面的逆博弈是**离线/批量**的——拿一整段观测轨迹，一次性梯度下降反推代价。但真实机器人是**在线**的：它一边开、一边观测对手、需要**实时**更新对手代价估计，不能等收集完整段轨迹再算。把逆博弈在线化的代表工作是 LUCIDGames（Le Cleac'h、Schwager、Manchester，RAL 2021，arXiv:2011.08152）。

论文原文（LUCIDGames 核心，转述）：现有博弈论规划方法假设机器人**预先知道**其他 agent 的目标函数，但实际中这罕有成立。LUCIDGames 把逆最优控制重铸成一个**递归参数估计**框架，用**无迹卡尔曼滤波（UKF）**迭代更新对其他 agent 代价参数的贝叶斯估计，随着从对手观测轨迹收集到更多数据而在线改进该估计。规划器则通过让机器人轨迹受不确定性椭圆约束，来考虑贝叶斯参数估计中的不确定性。

用人话重讲：LUCIDGames 把 §3.1 的"离线一次性 MLE"换成"在线递归滤波"。关键是用 UKF——把对手的代价参数当作要估计的"隐藏状态"，每观测到对手一步新轨迹，就用卡尔曼滤波更新一次参数的均值和协方差（贝叶斯后验）。这和 §3.2 用贝叶斯滤波在线估计对手的 k 完全同构——只不过那里估的是离散的层级 k（用离散贝叶斯），这里估的是连续的代价参数（用 UKF）。额外的巧思：它不只给参数**点估计**，还给**协方差**（不确定性），规划器据此对不确定的对手保持安全余量（不确定性椭圆约束）——参数越不确定，机器人越保守。

论文 → 代码桥接：LUCIDGames 的 UKF 包了 iLQGames 内层——每个滤波步里，UKF 用 sigma 点采样不同的候选参数、各跑一次 iLQGames 算均衡轨迹、与观测比对来更新后验。其 MPC 实现达 40 Hz 实时，代码在 RoboticExplorationLab/LUCIDGames.jl。

本质洞察（离线 MLE / 在线滤波 / 贝叶斯后验是同一逆问题的三种解法）：把 §3.1 和 §3.2 的推断方法摆在一起，会看到它们是"从行为反推对手隐藏属性"这一逆问题的不同实现： 离线 MLE（§3.1）——批量观测、梯度下降、给点估计，适合事后分析； 在线滤波（LUCIDGames 的 UKF / §3.2 的离散贝叶斯）——逐步观测、递归更新、给后验分布，适合实时机器人； 学习式（§3.3 GameFormer）——用神经网络从海量数据摊销这个推断，运行时一次前向。三者的内层都需要正向博弈求解器（MLE 和 UKF 显式调 iLQGames，GameFormer 把它隐式学进网络），都在回答"对手是什么样、它会怎么做"——这是 G3 全章的统一母题。选哪种取决于场景：要实时 + 不确定性量化用在线滤波（LUCIDGames），要可扩展用学习式（GameFormer），要离线精确分析用 MLE。

⚠️ 常见陷阱¶

陷阱 1（概念误区）：以为观测一小段轨迹就能唯一反推代价 - 错误描述：拿到对手几帧轨迹，就期望逆博弈精确反推出它的完整代价参数。 - 现象/后果：反推出的参数与真实值差很远，或每次跑（不同初值）收敛到不同参数；用这个不可靠的代价做预测，结果很差。 - 根本原因：可识别性取决于观测信息量。短轨迹/单时刻观测下，多组代价能解释同一观测，逆问题欠定——梯度下降只会收敛到"能拟合观测"的参数流形上某一点，而非真实参数（前面 demo 的本质洞察）。 - 正确做法：用足够长、足够多样的观测（覆盖不同交互情形）；对欠定情形，用贝叶斯方法（§前沿的 Auto-Encoding Bayesian）给出参数**后验分布**而非点估计，显式量化不确定性；或减少待估参数维度。

这个陷阱可以用代码实证。固定真实参数，只改**观测长度**，看反推误差怎么变（每个长度跑 5 个随机种子取平均）：
# 不同观测长度下逆博弈反推误差（其余同前面的 forward/inverse）
for Tobs in [1, 2, 4, 8, 15]:
    errs = [inverse(Tobs, seed=s) for s in range(5)]   # 反推误差 ||θ̂-θ_true||
    print(f"观测长度={Tobs}: 误差={np.mean(errs):.3f} (±{np.std(errs):.3f})")
观测长度平均反推误差标准差

1 步 5.477 0.000

2 步 0.943 0.274

4 步 0.136 0.024

8 步 0.049 0.011

15 步 0.019 0.008

误差随观测长度单调下降近 300 倍（5.477→0.019）：1 步观测几乎没信息（误差巨大、多组参数都能解释），观测越长参数越可识别。这就是"可识别性取决于观测信息量"的白纸黑字——也是为什么实战中要累积足够长的对手轨迹再下结论，单帧推断不可靠。

陷阱 2（编程陷阱）：逆博弈外层梯度下降发散 - 错误描述：直接用有限差分梯度 + 固定大学习率做外层优化。 - 现象/后果：loss 不降反增、参数爆炸成天文数字（如前面调试中出现的 1e23 量级）、NaN。 - 根本原因：有限差分梯度的尺度可能很大（尤其 loss 大时），固定大学习率下单步更新跨度过大，越过最优、震荡发散；博弈的 KKT 雅可比病态时更甚。 - 正确做法：梯度归一化（g/||g||）+ 自适应/小学习率 + 必要时梯度裁剪；用解析梯度 (3.4)（隐函数定理）替代有限差分，更稳更快；对内层求解器的雅可比 \(\partial F/\partial x^*\) 加正则化防病态。检验方法：监控 loss 是否单调下降，发散就先减小学习率。

陷阱 3（思维陷阱）：假设观测轨迹真的是 Nash 均衡 - 错误描述：逆博弈的 MLE (3.2) 假设观测轨迹是某个 Nash 均衡的噪声版本，于是无条件相信反推出的代价。 - 现象/后果：如果人类其实不是在玩 Nash（比如他们是 Level-1 有界理性、或根本是次优的），逆博弈会推断出一个"扭曲"的代价——它强行用 Nash 框架解释非 Nash 行为，得到的代价虽能拟合观测，但不反映真实意图，外推到新场景会错。 - 根本原因：逆博弈的正确性依赖"观测来自 Nash 均衡"这个生成假设。人类有界理性（§3.2 Level-k）时这个假设不成立。 - 正确做法：用更贴合人类的行为模型——MaxEnt Games（§前沿，假设有界理性的 softmax 均衡）或 Level-k 逆博弈（§3.2，假设观测来自某个 Level-k 策略而非 Nash）。这正是 §3.2 要解决的问题，也是这道思考题的核心。

陷阱 4（论文误导）：以为 Peters 2021 假设完整、无噪的观测 - 错误描述：读论文标题或摘要不仔细，以为逆博弈需要完整、干净的状态轨迹观测才能工作。 - 现象/后果：在只有带噪、部分观测（如只看到位置不看到速度、有遮挡缺帧）的真实场景里，误以为逆博弈不适用而放弃。 - 根本原因：论文标题恰恰是"from Noise-Corrupted Partial State Observations"——它专门设计来处理带噪、部分观测。它的关键创新正是把"未观测状态/输入的推断"和"代价参数估计"通过 Nash 约束**耦合**求解，所以能处理不完整观测。漏读"Noise-Corrupted Partial"会得出相反结论。 - 正确做法：仔细读论文的问题设定（setup）一节，看清它假设的观测模型。Peters 2021 明确处理带噪+部分观测——它把未观测量当作额外的待估变量，和代价参数一起优化。这正是它比"假设完整观测"的早期方法更实用的地方。

练习¶

（A 型·逆博弈 MLE，对接 G2） 在 iLQGames.jl 的 2 车交叉路口场景中做完整逆博弈：(1) 设定两车真实代价参数 \(\theta_{\text{true}}\)（如目标速度、安全距离权重）；(2) 正向求解得 Nash 轨迹；(3) 加高斯噪声作为"观测"；(4) 用梯度下降（内层调 iLQGames、外层用隐函数定理 (3.4) 的梯度）反推 \(\hat\theta\)。验证 \(\hat\theta\approx\theta_{\text{true}}\)，并改变观测长度，观察可识别性如何随观测信息量变化（呼应陷阱 1）。
（B 型·Peters RSS 2021 精读） 精读论文，标注三点：(1) 隐函数定理 (3.4) 在 iLQGames 的 KKT 上的**具体形式**（\(F\)、\(\partial F/\partial x^*\) 分别是什么）；(2) 带噪 + **部分**观测如何处理（提示：未观测量当待估变量，与代价参数联合优化——呼应陷阱 4）；(3) 逆博弈与 IRL 的数学关系（耦合结构的区别）。
（推导·连接 G2） 写出 (3.4) 中 \(\partial F/\partial x^*\) 与 G2 §2.6 SE-IBR 的 \(\partial G/\partial u_{-i}\) 的对应关系——它们都是"KKT 残差对解的雅可比"。解释为什么这个雅可比可逆是隐函数定理适用的前提，以及它病态时（博弈接近退化）逆博弈梯度会出什么问题（呼应陷阱 2）。
（复现验证·解析梯度 vs 有限差分） 复现本节"隐函数定理解析梯度 vs 有限差分"的实验：(1) 实现一个带约束的 2 玩家博弈（不只是无约束 LQ），写出它的 KKT 残差 \(F\)；(2) 用 (3.4) 解析算 \(\partial x^*/\partial\theta\)，用有限差分验证一致（目标差异 < 1e-6）；(3) 测量两者的计算时间随参数维度 \(d\) 的增长——验证解析梯度是 \(O(1)\) 次求解、有限差分是 \(O(d)\) 次。把结果做成"参数维度 vs 求梯度耗时"曲线，量化解析梯度的优势。

§3.2　Level-k 与认知层级：给有界理性建模　⭐⭐⭐¶

这一节解决什么问题：§3.1 的逆博弈假设观测来自 Nash 均衡，但 §3.1 陷阱 3 指出——人类不是完美的 Nash 玩家。这一节用 Level-k / Cognitive Hierarchy 给**有界理性**建模：人类的策略推理只到有限"层"（我想你想我……想几步就停），而非无限递归到 Nash 不动点。这是处理真实人类交互的主流工具，也是 §3.3 GameFormer 的核心思想来源。

动机：人类真的在算 Nash 均衡吗¶

Nash 均衡有一个很强的隐含假设——相互一致性（mutual consistency）：每个玩家都正确预测了所有其他玩家的策略，且大家的预测彼此自洽，形成一个不动点。要达到这个不动点，玩家得做无限层的递归推理："我认为你会这么做，但你也知道我这么想，所以你会那样做，但我又知道你知道……"一直推到收敛。

可真实的人类司机会这样推理吗？心理学和行为经济学的大量实验给出的答案是：不会。人类的策略推理只能到**有限的几层**就停了——大多数人想一两步（"我觉得他会让，那我就并进去"），很少有人真的递归推到 Nash 不动点。用 Nash 去建模人类，等于假设了一个不切实际的"完美博弈者"。 §3.1 陷阱 3 已点出后果：用 Nash 框架解释非 Nash 的人类行为，逆博弈会推断出扭曲的代价。我们需要一个**承认人类只想有限步**的模型——这就是 Level-k。

反面案例：直接用 Nash 建模人类会怎样¶

设想你做一个汇入场景的交互规划器，假设对向人类司机是完美 Nash 玩家。 Nash 假设对手已经"算到底"——它预测对手会精确地对你的最优策略做最优响应。但真实的人类司机可能只是 Level-1——他假设你会按常规（匀速）开，然后对这个简单假设做反应，根本没考虑"你其实在对他反应"。后果是**预测失配**：你的规划器期待一个会精细协调的 Nash 对手，实际遇到的却是一个"以为你匀速、自己抢行"的 Level-1 司机。你以为他会让（Nash 均衡里该让），他却因为只想了一层、没料到你会进而直接抢——轻则急刹，重则冲突。反过来，如果你假设对手是 Level-1（会抢），他却是个谨慎的 Level-2（料到你会进、主动让），你又会过度保守。 关键是：你得估计对手到底想了几层（k 是多少），而非假设他是完美 Nash。

历史：从行为经济学到自动驾驶¶

Level-k 思想源自**行为博弈论**对人类实验数据的观察——人在一次性博弈里的行为，用"有限层推理"解释得比 Nash 好得多。集大成的是 Camerer、Ho、Chong 在 QJE 2004 提出的 Cognitive Hierarchy（CH，认知层级）模型。

论文原文（Camerer-Ho-Chong 2004 的核心，转述）：step 0 玩家随机化（不做策略思考）；step k 思考者做最佳响应，但假设其他玩家分布在 step 0 到 step k−1 上。该模型拟合实验数据，并解释了为何均衡理论在某些博弈里预测得好、某些里差。

用人话重讲：CH 说人分成不同"思考深度"的层。最低的 Level-0 根本不做策略推理（随机或按固定规则）； Level-k 的人做最佳响应，但他心里假设的对手不是"和他一样深"的，而是**比他浅的所有层的混合**。关键词是"假设别人比自己浅"——这正是有界理性的核心：每个人都觉得自己是房间里最聪明的，对手没自己想得深。 CH 弱化了 Nash 的"相互一致性"（不要求大家预测彼此自洽），只保留"最佳响应"——所以它能描述没算到不动点的真实人类。

把 CH/Level-k 引入**自动驾驶**的代表工作是 Li、Yildiz、Girard、Kolmanovsky 等（密歇根大学 / Bilkent；奠基作 "Game-Theoretic Modeling of Driver and Vehicle Interactions…" 发表于 IEEE T-CST 2018，26(5):1782–1797，后续由 Ran Tian 等推进到 T-ITS）和 Sadigh 组的 Cognitive Hierarchy 驾驶模型——用 Level-k 建模其他车的有界理性，并在线估计对手的 k 来自适应调整自己的策略。

这些驾驶场景的实证研究，进一步支持了"k 很小"的结论（呼应规格思考题"实际驾驶中 k 是多少"）：在大多数日常交互（跟车、变道、汇入）中，人类司机的有效策略层级集中在 Level-0 到 Level-2——Level-0 对应"按规则/习惯开"（多数稳态跟车），Level-1 对应"预期别人按常规、我做反应"（典型变道），Level-2 及以上只在博弈性强的对抗场景（如抢行、强行加塞）才偶尔出现。这与行为经济学的 τ≈1.5 一致，也给工程一个明确指引：自动驾驶里建模他车，用 Level-0/1/2 三档足以覆盖绝大多数情况，无需更高层级。一个实践要点：不同司机、不同场景的 k 不同（同一个司机在拥堵时可能更"激进"=更高层级），所以**在线估计 k**（下面会讲）比固定假设一个 k 更鲁棒。

论文 → 代码桥接：Level-k 的实现是**递归**的——Level-0 是一个规则策略（如 IDM 跟车），Level-1 是"固定对手为 Level-0、对它做最优控制（如 MPC）"，Level-2 是"固定对手为 Level-1、再做最优控制"……每一层的实现都是**一次正向最优响应求解**（本质就是调用 G2 的求解器一次）。下面的代码会展示这个递归。

理论：Level-k 与 Cognitive Hierarchy¶

Level-0：规则策略。 不做任何策略推理的基准行为。自动驾驶里常用的 Level-0：IDM（智能驾驶员模型，跟车）、MOBIL（变道规则）、或最简单的匀速直行。 Level-0 是整个递归的"地基"——它不考虑他人，只按预设规则走。

Level-k：对 Level-(k−1) 的最佳响应。 递归定义：

\[\pi_k=\text{BestResponse}\big(\pi_{k-1}\big),\qquad k=1,2,\dots \tag{3.5}\]

Level-1：假设所有他人是 Level-0（按规则行动）→ 对规则行为做最优反应。
Level-2：假设所有他人是 Level-1 → 对 Level-1 行为做最优反应。
以此类推，每升一层，就多想一步"对手会怎么想"。

注意 Level-k 的"最佳响应"\(\text{BestResponse}(\cdot)\) 就是一次**正向博弈/最优控制求解**——给定（假设的）对手策略，求自己的最优。这正是 G2 求解器的活。所以 Level-k = 把正向求解器递归调用 k 次。

Cognitive Hierarchy（CH）：对"更浅各层的混合"做最佳响应。 纯 Level-k 假设对手**恰好**是 Level-(k−1)；CH 更精细——它假设对手分布在 Level-0 到 Level-(k−1) 的**混合**上，且层级 \(k\) 服从一个**泊松分布** \(\text{Poisson}(\tau)\)：

\[P(\text{level}=k)=\frac{\tau^k e^{-\tau}}{k!}. \tag{3.6}\]

Level-k 思考者对"按泊松比例混合的 Level-0…Level-(k−1)"做最佳响应。参数 \(\tau\) 刻画群体的平均思考深度。

把 (3.6) 在不同 \(\tau\) 下算出来，能直观看到 \(\tau\) 如何塑造层级分布：

\(\tau\)	Level-0	Level-1	Level-2	Level-3	Level≥4
0.5	0.61	0.30	0.08	0.01	0.00
1.0	0.37	0.37	0.18	0.06	0.02
1.5（≈人类中位数）	0.22	0.33	0.25	0.13	0.07
2.5	0.08	0.21	0.26	0.21	0.24

在人类实测的 \(\tau\approx1.5\) 下：Level-0 占 22%、Level-1 占 33%、Level-2 占 25%、Level≥3 仅约 19%。也就是说，约 81% 的人停在 Level-0 到 Level-2，只有不到两成想到 3 层以上。这把"人类策略思考深度低"量化成了具体的概率分布——也直接告诉你建模对手时该用什么：用 Level-1/Level-2 覆盖了大多数人，假设对手是 Level-4 或完美 Nash 只对应那不到 2% 的人群，不切实际。

本质洞察（Level-k = 把"想到底"截断成"想 k 步"）：Nash 和 Level-k 的根本差别，是**递归深度**。 Nash 是递归的不动点——"想到底"，要求 \(\pi=\text{BestResponse}(\pi)\) 自洽收敛。 Level-k 是递归的**有限截断**——从 Level-0 出发，做 \(k\) 次最佳响应就停，不要求收敛到不动点。这个截断正是"有界理性"的数学化：人类的认知资源有限，想不了无限层，到第 \(k\) 层就停。一个漂亮的极限关系：当 \(k\to\infty\)（或 \(\tau\to\infty\)）且递归收敛时，Level-k 趋于 Nash——Nash 是 Level-k 的"无限理性极限"。所以 Level-k 不是 Nash 的对立面，而是它的**有限理性推广**：Nash 是想到底，Level-k 是想 k 步，现实的人在中间某个有限的 k。

代码走读：验证"Level-k 随 k 增大趋近 Nash"。 "k→∞ 趋于 Nash"不只是说法，可以用代码验证。取一个有解析 Nash 的简单博弈——最优响应 \(a_i=c-0.5a_j\)（BR 斜率 −0.5），Nash 满足 \(a^*=c-0.5a^*\) 即 \(a^*=c/1.5\)：

c = 3.0; a_nash = c/1.5                    # 解析 Nash = 2.0
def best_response(a_opp): return c - 0.5*a_opp   # BR 斜率 -0.5（收缩映射）

a = 0.0                                     # Level-0：规则（不动）
for k in range(1, 9):
    a = best_response(a)                    # Level-k：对 Level-(k-1) 做 BR
    print(f"Level-{k}: a={a:.4f}, |a-Nash|={abs(a-a_nash):.4f}")

跑出来，Level-k 的动作误差**几何式递减**，单调收敛到 Nash：

层级	动作 a	与 Nash 的差
Level-1	3.0000	1.0000
Level-2	1.5000	0.5000
Level-3	2.2500	0.2500
Level-4	1.8750	0.1250
Level-8	1.9922	0.0078

每升一层，与 Nash 的差**减半**（BR 斜率 −0.5 的几何收敛），印证了"k→∞ 趋于 Nash"。

本质洞察（收敛性取决于博弈结构——这正是高 k 未必好的根源）：注意上面那句限定语"且递归收敛时"——它不是多余的。 Level-k 收敛到 Nash 的前提是最佳响应映射是**收缩的**（BR 斜率绝对值 < 1）。如果 BR 斜率绝对值 ≥ 1（非收缩，如某些强对抗博弈），Level-k 递归会**震荡甚至发散**——k 越大离 Nash 越远，而非越近。这从数学上解释了 §3.2 陷阱 1"高 k 未必好"：盲目增大 k，在非收缩博弈里适得其反。加上真实人类的 k 本就小（τ≈1.5），双重理由都指向同一结论——建模时用小 k，别迷信高 k。这也呼应 §3.3 GameFormer 陷阱 2（decoder 层数不是越多越好）：层数=认知深度=k，过多层既不对应真实认知、又可能不收敛。

关键经验值（人类的 k 是多少？）：Camerer-Ho-Chong 用大量博弈实验数据做最大似然估计，发现泊松参数 \(\tau\) 的中位数为 1.55（60 个游戏的逐一估计，四分位距 (0.98, 2.21)；论文摘要也以"约 1.5 步"来概括这一水平）。也就是说，真实人类的平均策略思考深度约 1.5 层——大多数人是 Level-1 到 Level-2，很少有人想到 3 层以上。这个数字对自动驾驶很有指导意义（回答规格思考题"实际驾驶中 k 是多少"）：建模人类司机时，Level-1/Level-2 通常就够了，假设对手是高层级或完美 Nash 往往不切实际。当然驾驶场景与经济学实验不同，实际 k 需针对驾驶数据重新估计，但"k 很小（1~2）"这个定性结论是稳健的。

那么，怎么为你自己的驾驶场景估计 τ？ 前面反复说"驾驶数据要重新估 τ"，这里补上具体做法，它正是前面"贝叶斯在线估 k"的群体版。三步：(1) 收集一批交互片段；(2) 用前面的贝叶斯方法（或直接按行为规则分类）推断**每个**司机的有效层级 \(k_i\)，得到一组层级样本；(3) 对这组样本用最大似然拟合泊松参数 \(\tau\)。最漂亮的是第 (3) 步有**闭式解**——泊松分布的 MLE 恰好就是**样本均值**：\(\hat\tau=\frac1n\sum_i k_i\)。

import numpy as np
from scipy.optimize import minimize_scalar
from math import lgamma, exp, factorial
# 一批司机（用前面的贝叶斯方法）各自推断出的有效层级——这是你从驾驶数据得到的群体观测
levels = np.array([0,1,1,2,1,1,0,2,1,1,2,3,1,0,1, 2,1,1,0,1])
def neg_loglik(tau):                                   # 泊松 MLE：-∑_i log P(k_i|τ)
    return -np.sum(levels*np.log(tau) - tau - np.array([lgamma(k+1) for k in levels]))
tau_hat = float(minimize_scalar(neg_loglik, bounds=(0.05, 5), method='bounded').x)
print(f"数值 MLE  τ̂ = {tau_hat:.2f}")               # 1.10
print(f"样本均值     = {levels.mean():.2f}")          # 1.10——泊松 MLE 的闭式解就是样本均值
fit = [round(tau_hat**k*exp(-tau_hat)/factorial(k), 2) for k in range(4)]
emp = [round(float(np.mean(levels==k)), 2) for k in range(4)]
print("拟合分布 P(k):", fit, " 经验频率:", emp)        # 拟合与经验频率接近

跑出来 \(\hat\tau\approx1.10\)（等于样本均值），拟合的泊松分布 [0.33, 0.37, 0.20, 0.07] 与经验频率 [0.20, 0.55, 0.20, 0.05] 大体吻合。注意这个合成"驾驶"样本的 \(\hat\tau\approx1.10\) 比实验室的 1.55 还低——这恰恰印证了为什么要按域重估：经济学实验里的人和路口里的司机不是同一回事，直接套用 1.55 未必准，但"k 很小"这个定性结论跨域稳健。工程提示：层级样本越多、覆盖的交互情形越多样，\(\hat\tau\) 越可靠（与 §3.1 可识别性同理）；样本太少时 \(\hat\tau\) 会被个别极端样本带偏，可加一个弱先验做正则（贝叶斯版的 τ 估计）。

在机器人中的应用：在线估计对手的 k。 实战中你不知道对手是 Level 几。做法是**贝叶斯在线估计**：维护一个对手 k 值的后验分布，每观测到一步对手行为，就用贝叶斯更新——"如果对手是 Level-1，他这步该这么走；是 Level-2，该那么走；实际他这么走了，那他更可能是几？" 估出对手的 k 后，ego 就能对症下药地选自己的策略层级（通常比对手高一层）。这把 §3.1 的"推断对手代价"换成了"推断对手的**理性层级**"——两者都是逆问题，都在从行为反推对手的隐藏属性。

代码走读：Level-0/1/2 的行为差异¶

把 Level-k 的递归落成代码，看不同层级的行为如何不同。场景：汇入冲突（ego 从匝道汇入主道，对手在主道，冲突点在前方），每个 agent 选加速度序列最大化进展 + 避撞。

import numpy as np
from scipy.optimize import minimize
dt, T, conflict, gap_min = 0.5, 10, 10.0, 2.0

def rollout(a_ego, a_opp, x0e=0., x0o=1.):              # 双车纵向运动学
    xe, ve, xo, vo = x0e, 5.0, x0o, 5.0; te, to = [xe], [xo]
    for k in range(T):
        ve = np.clip(ve+a_ego[k]*dt, 0, 10); xe += ve*dt
        vo = np.clip(vo+a_opp[k]*dt, 0, 10); xo += vo*dt
        te.append(xe); to.append(xo)
    return np.array(te), np.array(to)

def cost_ego(a_ego, a_opp):                             # ego 代价：进展 + 控制 + 避撞
    te, to = rollout(a_ego, a_opp)
    J = -te[-1] + 0.1*np.sum(np.array(a_ego)**2)        # 想多前进、省控制
    for k in range(T+1):                                # 冲突点附近避撞惩罚
        if abs(te[k]-conflict)<gap_min and abs(to[k]-conflict)<gap_min and abs(te[k]-to[k])<gap_min:
            J += 20.0
    return J

def best_response_ego(a_opp):                           # 对给定对手策略求 ego 最优响应（= 一次正向求解）
    return minimize(lambda a: cost_ego(a, a_opp), np.zeros(T),
                    method='Nelder-Mead', options={'maxiter':2000}).x

def best_response_opp(a_ego):                           # 对称：对给定 ego 策略求对手最优响应
    # 对手代价与 ego 同构（想多前进 + 省控制 + 避撞），只是角色对调
    def cost_opp(a_opp):
        te, to = rollout(a_ego, a_opp)
        J = -to[-1] + 0.1*np.sum(np.array(a_opp)**2)
        for k in range(T+1):
            if abs(te[k]-conflict)<gap_min and abs(to[k]-conflict)<gap_min and abs(te[k]-to[k])<gap_min:
                J += 20.0
        return J
    return minimize(cost_opp, np.zeros(T), method='Nelder-Mead', options={'maxiter':2000}).x

# Level-k 递归：每升一层 = 多做一次 best response
a0 = np.zeros(T)                                        # Level-0：匀速规则（a=0）
a1_ego = best_response_ego(a0)                          # Level-1：对匀速对手最优响应
a1_opp = best_response_opp(a0)                          # （对手的 Level-1，对称）
a2_ego = best_response_ego(a1_opp)                      # Level-2：对 Level-1 对手最优响应

跑出来的三个层级行为：

层级	ego 终点位置	平均加速度	行为特征
Level-0（匀速规则）	25.00	0.000	不做策略推理，匀速直行
Level-1（对匀速对手 BR）	39.75	1.504	假设对手匀速 → 大胆加速抢行
Level-2（对 L1 对手 BR）	41.89	1.528	假设对手会避让 → 更精细地协调通过

层级越高，ego 越会**策略性地调整**（加减速）来利用对它对手行为的预期： Level-1 假设对手匀速、于是大胆抢行；Level-2 料到对手（Level-1）会避让、于是做更精细的协调。关键观察：每升一层，就多调用一次 best_response——这印证了"Level-k = 正向求解器递归 k 次"，也预告了 §3.3 GameFormer 用 decoder 逐层实现这个递归。（实现注记：这里的 best_response 用 Nelder-Mead 优化一个**含避撞阶跃惩罚的非光滑代价**，存在多个局部最优，Level-2 的确切终点对 maxiter、容差、SciPy 版本略敏感——maxiter=2000 时约 41.89、放大到 5000 时约 43.56。验证时应抓"层级越高、终点越远"这个**稳健趋势**，而非纠结某个精确小数；这也是章末复现指南强调固定随机种子、并以"趋势/量级"为验证标准的原因。）

代码走读：贝叶斯在线估计对手的 k¶

前面说"用贝叶斯在线估计对手层级"，落成代码看它怎么工作。核心是一个标准的贝叶斯滤波：维护对手 \(k\in\{0,1,2\}\) 的后验，每观测一步对手动作就更新——"若对手是 Level-\(k\)，他这步动作的似然是多少"。

import numpy as np
# 各层级的"典型动作"（真实中由 best_response 算出，这里用代表值）
level_action_mean = {0: 0.0, 1: 1.5, 2: 1.0}   # Level-0匀速 / Level-1抢行 / Level-2协调
sigma = 0.4                                     # 对手动作随机性（有界理性的噪声）

def likelihood(obs_action, k):
    """若对手是 Level-k，观测到 obs_action 的似然（高斯）。"""
    mu = level_action_mean[k]
    return np.exp(-0.5*((obs_action-mu)/sigma)**2) / (sigma*np.sqrt(2*np.pi))

# 真实对手是 Level-1；ego 从均匀先验开始在线推断
np.random.seed(2)                               # 固定随机种子，保证下表可复现
true_k = 1
posterior = np.array([1/3, 1/3, 1/3])           # P(k=0,1,2) 均匀先验
for t in range(1, 8):
    obs = level_action_mean[true_k] + sigma*np.random.randn()   # 观测对手这一步动作
    lik = np.array([likelihood(obs, k) for k in range(3)])      # 三个层级假设下的似然
    posterior = lik * posterior                                 # 贝叶斯更新：后验 ∝ 似然 × 先验
    posterior = posterior / posterior.sum()                     # 归一化
    # MAP 估计 = argmax(posterior)

跑出来，后验逐步收敛到真实层级（中间因噪声会有短暂波动，但整体稳定）：

时刻 t	观测对手加速度	后验 P(k=0,1,2)	MAP 估计
1	+1.33	(0.002, 0.563, 0.434)	Level-1
2	+1.48	(0.000, 0.725, 0.275)	Level-1
3	+0.65	(0.000, 0.285, 0.715)	Level-2（噪声致短暂偏移）
4	+2.16	(0.000, 0.871, 0.129)	Level-1
7	+1.70	(0.000, 0.831, 0.169)	Level-1

第一步观测就几乎排除了 Level-0（对手明显在加速、不是匀速），之后在 Level-1/Level-2 间逐步收敛到真实的 Level-1。估出对手是 Level-1 后，ego 应选 Level-2 策略（比对手高一层，对它的抢行做最优响应）。

本质洞察（估计 k 与估计代价是同一类逆问题）：这个贝叶斯估计 k，和 §3.1 的逆博弈推断代价，是**同一类逆问题的两个实例**——都在"从观测行为反推对手的隐藏属性"。 §3.1 推断的隐藏属性是**代价参数**（连续，用梯度下降）；这里推断的是**理性层级 k**（离散，用贝叶斯滤波）。真实系统里两者可以结合：同时推断"对手想要什么（代价）"和"对手想得多深（层级 k）"——前者用逆博弈、后者用贝叶斯，共同构成一个完整的在线对手模型。注意中间 t=3 那次因噪声短暂误判 Level-2——这提醒：单步观测不可靠，需累积多步（呼应 §3.1 可识别性陷阱：观测信息量决定推断质量）。

⚠️ 常见陷阱¶

陷阱 1（概念误区）：以为 Level-k 收敛到 Nash、或 k 越高越好 - 错误描述：觉得 Level-k 随 k 增大总会收敛到 Nash，所以建模时把 k 取得越高越接近"真实"。 - 现象/后果：用高 k（如 Level-4）建模人类司机，预测的对手行为过度"精明"，与真实有界理性的人类（k≈1.5）严重失配，交互失败。 - 根本原因：Level-k 是有界理性模型，它的价值恰恰在于 k 小（截断了无限递归）。真实人类 k≈1~2；高 k 偏离了 Level-k 的建模初衷，且不一定收敛（递归可能震荡不收敛到 Nash）。 - 正确做法：用小 k（1~2）建模人类，并在线估计对手实际的 k；只有当你确信对手是高度理性的（如另一个优化求解器）时才用高 k 或 Nash。检验方法：用真实交互数据做 MLE 估 k，看落在什么范围。

陷阱 2（编程陷阱）：Level-k 递归中混淆"自己的层级"和"假设对手的层级" - 错误描述：实现 Level-k 时，把"我是 Level-k"错误地实现成"对手也是 Level-k"，或递归基线（Level-0）设错。 - 现象/后果：行为层级错乱——本应对 Level-(k−1) 响应却对了 Level-k，或 Level-0 规则设得不合理导致整个递归崩塌。 - 根本原因：Level-k 的定义是"我是 Level-k = 我对（假设的）Level-(k−1) 对手做最优响应"。实现时必须分清"我的层级 k"和"我假设对手的层级 k−1"，且 Level-0 必须是一个合理的规则策略（递归地基）。 - 正确做法：严格按 (3.5) 实现——level_k_policy = best_response(level_(k-1)_opponent_policy)；Level-0 用经过验证的规则（IDM/MOBIL）。检验方法：单独验证每一层（Level-1 对匀速对手的响应是否合理），再往上递归。

陷阱 3（论文误导）：以为 Level-k 和 Cognitive Hierarchy 是同一个模型 - 错误描述：读文献时把 Level-k 和 CH 当成可互换的同义词，混用它们的"对手假设"。 - 现象/后果：实现时对手模型用错——Level-k 假设对手**恰好**是 Level-(k−1)，CH 假设对手是 Level-0 到 Level-(k−1) 的**泊松混合**；混淆导致最佳响应的对象错误。 - 根本原因：两者是不同模型。纯 Level-k：对手恰好低一层。CH（Camerer-Ho-Chong）：对手是更浅各层的混合分布（泊松）。CH 是 Level-k 的精细化，二者的最佳响应对象不同。 - 正确做法：明确你用的是哪个。要简单递归用 Level-k（对手恰好 Level-(k−1)）；要更贴合实验数据的群体异质性用 CH（对手泊松混合）。读论文时看清它定义的对手假设，别想当然。

延伸：MaxEnt 博弈——有界理性的另一条路¶

Level-k/CH 用"有限层递归"建模有界理性，但这不是唯一的路。另一条主流路线是**最大熵（MaxEnt）博弈**，代表作是 Mehr、Wang、Bhatt、Schwager 的 IEEE T-RO 2023（"Maximum-Entropy Multi-Agent Dynamic Games: Forward and Inverse Solutions", 39(3):1801-1815, DOI 10.1109/TRO.2022.3232300）。它对有界理性的建模机制与 Level-k 不同——不是"想得浅"，而是"带随机性"。

核心思想（MaxEnt 博弈，转述）：完美理性的 agent 总选最优动作（确定性）；有界理性的 agent 则以一定**随机性**选动作——越优的动作选的概率越高，但次优动作也有非零概率（softmax 分布）。MaxEnt 博弈用一个 **softmax Bellman 方程**刻画这种"带噪的最优性"，均衡里每个 agent 的策略是对其他人策略的 softmax 最优响应（而非确定性最优响应）。

把它和 Level-k 对照，能看清两种有界理性建模的根本差异：

系统性分类（两种有界理性建模）：

维度	Level-k / CH	MaxEnt 博弈
有界理性的机制	推理深度有限（想 k 步就停）	选择带随机性（softmax，非确定性最优）
数学刻画	递归截断 (3.5)(3.6)	softmax Bellman 方程
完美理性极限	k→∞ 趋于 Nash	温度→0（无随机性）趋于 Nash
主要捕捉	"人想不到那么多层"	"人的选择不完全最优、有波动"
正/逆统一	需分别处理	正/逆求解统一（同一框架）

本质洞察（两种有界理性是互补的，不是对立的）：Level-k 和 MaxEnt 捕捉的是有界理性的**两个不同侧面**。 Level-k 说"人的推理深度有限"——你想到第 2 层，对手可能只想到第 1 层； MaxEnt 说"人的选择有随机性"——即便算出了最优，人也不总是精确执行它，有波动。真实人类两者都有：既想不了无限层（Level-k），选择又带噪声（MaxEnt）。一个有意思的统一点：两者都把 Nash 作为"完美理性极限"——Level-k 在 k→∞ 时趋于 Nash，MaxEnt 在随机性→0 时趋于 Nash。所以它们都是 Nash 的"有界理性推广"，只是从不同方向放松了完美理性假设。 MaxEnt 的一个额外优势（对 §3.1 逆博弈很重要）：它的**正向求解和逆向求解在同一个最大熵框架里统一**——逆博弈推断代价时，MaxEnt 的概率化策略天然给出了观测的似然（softmax 概率），不必像确定性 Nash 那样假设"观测=均衡+高斯噪声"。这让 MaxEnt 成为逆博弈处理有界理性人类的有力工具，呼应 §3.1 陷阱 3。

代码走读：softmax 策略与正逆统一。 MaxEnt 的核心是一个温度参数 \(T\) 控制的 Boltzmann/softmax 策略——\(\pi(a)\propto\exp(Q(a)/T)\)。用代码看 \(T\) 如何从"确定性最优"过渡到"随机"，以及如何从观测反推 \(T\)（有界理性程度）：

import numpy as np
def boltzmann_policy(Q, T):
    """softmax/Boltzmann 策略：π(a) ∝ exp(Q(a)/T)。T→0 确定性最优，T 大→随机。"""
    if T < 1e-6:
        p = np.zeros_like(Q); p[np.argmax(Q)] = 1.0; return p   # T→0：确定性最优（完美理性）
    z = Q/T; z -= z.max()
    e = np.exp(z); return e/e.sum()

Q = np.array([1.0, 2.5, 3.0, 2.0, 0.5])    # 5 个动作的 Q 值（收益），动作 2 最优
for T in [0.01, 0.3, 1.0, 3.0]:
    print(f"T={T}: {np.round(boltzmann_policy(Q, T), 3)}")

不同温度下的策略分布：

温度 T	策略 π(a)	含义
0.01	[0, 0, 1, 0, 0]	T→0：确定性选最优（完美理性）
0.3	[0.00, 0.15, 0.82, 0.03, 0.00]	强偏好最优、少量探索
1.0	[0.06, 0.28, 0.46, 0.17, 0.04]	明显随机性（有界理性）
3.0	[0.15, 0.24, 0.29, 0.20, 0.12]	接近均匀（高度随机）

逆问题同样自然——从观测的动作频率反推温度（即对手有多"理性"）：

# 从观测动作频率反推 T（最小化负对数似然）
def nll(T):
    p = boltzmann_policy(Q, max(T, 1e-3))
    return -np.sum(obs_freq * np.log(p + 1e-9))
T_hat = min(np.linspace(0.1, 2.0, 40), key=nll)   # 网格搜索 T̂ ≈ 0.54（真实 T=0.5）

本质洞察（softmax 让正逆在同一框架里统一）：盯住 boltzmann_policy 这一个函数——它**既是正向也是逆向**的核心。正向：给定代价（Q 值）和理性程度（T），它输出策略分布 π(a)。逆向：给定观测的动作频率，它给出每个 T 假设下的似然（直接是 π(a) 的概率），于是能用 MLE 反推 T。对比确定性 Nash：确定性策略下，观测的似然是个"0 或 1"的硬判断（动作要么是最优、要么不是），没法平滑地做 MLE——必须人为假设"观测=最优+高斯噪声"才能算似然。 MaxEnt 的 softmax 天然给出**概率化**的似然，正逆共用同一个 π(a) 公式，这就是"正逆统一"的真正含义。这也是为什么 MaxEnt 特别适合逆博弈处理人类——人类行为本来就有随机性，softmax 似然比"确定性+高斯噪声"更贴合，呼应 §3.1 陷阱 3（假设观测来自确定性 Nash 的局限）。

前沿：Level-k 逆博弈——推断对手"以为别人想要什么"¶

§3.1 的逆博弈和 §3.2 的 Level-k 可以结合，产生一个更精细的问题。标准逆博弈（§3.1）有个隐含假设——它假设所有 agent 共享对彼此目标的知识（大家都知道彼此想要什么，即"level-1"推断）。但真实场景里，agent 对彼此的认知可能**错位**：路口两车，A 以为 B 想直行、B 其实想右转，双方基于**错误的彼此认知**行动。推断这种"错位认知"的工作是 Khan、Li、Fridovich-Keil 的 Level-2 逆博弈（arXiv:2508.03824）。

核心思想（Level-2 逆博弈，转述）：标准（level-1）逆博弈从第三方观察者视角，假设各 agent 完全知道彼此目标。但去中心化的真实场景（城市驾驶、议价）中，agent 可能基于**对彼此目标的冲突认知**行动。Level-2 逆博弈不仅推断每个 agent 的目标，还推断**它对其他 agent 目标的估计**——捕捉"错配的信念"。

本质洞察（推断的层级也有 Level-k）：这里出现了一个漂亮的递归——推断本身也有认知层级。 Level-1 逆博弈：推断"每个 agent 想要什么"（assume 大家都知道彼此目标）。 Level-2 逆博弈：推断"每个 agent 想要什么" + "每个 agent 以为别人想要什么"（承认认知可能错位）。这和 §3.2 的 Level-k 递归是同构的——只不过那里的层级是 agent 的**决策**深度（我想你想我），这里的层级是**推断**的深度（我推断你对他的推断）。一句话：Level-k 的"我想你想我"递归，既出现在决策侧（§3.2 Level-k 策略），也出现在推断侧（Level-2 逆博弈）——认知层级是博弈交互的普遍结构。 实践意义：当你发现标准逆博弈推断的对手代价"自相矛盾"（推不出一致的解释）时，可能正是因为 agent 间认知错位——这时需要 Level-2 逆博弈，呼应 §3.1 陷阱 3"假设观测来自共识 Nash"的局限。

练习¶

（A 型·Level-k 实现） 在 highway-env 中实现 Level-k 决策：(1) Level-0 = IDM + MOBIL（规则）；(2) Level-1 = 对 Level-0 他车做 MPC 最优响应；(3) Level-2 = 对 Level-1 他车做 MPC。对比三个 Level 的变道成功率和碰撞率，并讨论哪个层级最像真实人类司机（联系 τ≈1.5）。
（A 型·在线估计 k） 实现对手 k 值的贝叶斯在线估计：维护对手 k∈{0,1,2} 的后验，每观测一步对手行为就更新（似然 = "若对手是 Level-j，这步行为的概率"）。在一个汇入场景里验证：当对手实际按 Level-1 行动时，你的后验是否收敛到 k=1？据此 ego 该选哪个层级？
（思考题·连接 §3.1） 逆博弈（§3.1）假设观测来自 Nash 均衡，但如果人类其实是 Level-1（非 Nash），逆博弈会推断出什么样的代价？这个被"扭曲"的代价用于预测会有什么问题？如果改用"Level-k 逆博弈"（假设观测来自某个 Level-k 策略而非 Nash），推断会更准吗？（提示：这正是 Level-k 逆博弈这一前沿方向要解决的。）

§3.3　GameFormer：把 Level-k 嵌进 Transformer　⭐⭐⭐　★ 核心论文¶

这一节解决什么问题：§3.1 的逆博弈、§3.2 的 Level-k 都需要显式求解/迭代，难以扩展到密集城市场景（几十个 agent、高维地图）。这一节看一条端到端的路线——GameFormer 把 §3.2 的 Level-k 递归**嵌进 Transformer 的 decoder**，用神经网络隐式逼近博弈均衡，拿下 Waymo/nuPlan 的 SOTA。这是博弈论思想与深度学习融合的代表，也是当前自动驾驶预测-规划的前沿范式。

动机：城市场景里几十个 agent，怎么实时博弈¶

§3.1、§3.2 的方法在少数 agent（2-3 车）的场景里很漂亮，但真实城市驾驶是另一回事——一个繁忙路口可能有几十个车辆、行人、骑车人，外加复杂的 HD 地图（车道、人行道、信号灯）。显式求解这么大规模的博弈（iLQGames 的耦合 Riccati、逆博弈的隐函数微分）计算上极其吃力，且要为每个 agent 手工设计代价函数也不现实。更根本的是，§3.1 的逆博弈虽能推断代价，但**在线**对几十个 agent 同时做逆博弈推断，远超实时预算。

能不能换个思路：不显式求解博弈，而是用神经网络从海量驾驶数据中"学"出博弈式的交互预测？神经网络天生擅长处理高维输入（地图、多 agent 历史）、且推理是一次前向传播（无需迭代收敛）。如果能把博弈论的**结构**（尤其 §3.2 的 Level-k 层级推理）作为**归纳偏置**注入网络架构，就能兼得两者之长——博弈论的交互建模能力 + 神经网络的可扩展性和速度。这正是 GameFormer 的思路。

反面案例：忽略"未来交互"的预测器会怎样¶

GameFormer 论文开篇点出了已有方法的一个关键缺陷：

论文原文（GameFormer 摘要，转述）：已有工作聚焦于基于 agent **过去**轨迹来建模它们的交互，但它们**未来**的交互常被忽略。

用人话重讲：大多数轨迹预测器是这样工作的——看每个 agent 的历史轨迹，预测它各自的未来。它们建模了 agent **过去**怎么相互影响（历史轨迹里的交互），却没建模 agent 在**未来**会怎么相互反应。问题在于：未来是交互的——A 的未来动作取决于 B 的未来动作，反之亦然。一个只看过去、独立预测各 agent 未来的模型，会预测出**相互矛盾**的未来（比如预测两辆车会在同一点抢行、因为各自的预测没考虑对方的未来反应）。这本质又是 §3.4 要讲的 prediction-planning 不一致、frozen robot 的同源问题——预测没有把"未来的交互"建进去。

GameFormer 的解法是用**层级博弈**显式建模未来交互：让每个 agent 的预测**迭代地**响应其他 agent 上一轮的预测——这正是 §3.2 的 Level-k 递归。

历史：从可微博弈到端到端博弈学习¶

GameFormer 站在两条线的交汇点。一条是 §3.1-§3.2 的**博弈论交互建模**（Sadigh→Peters→Level-k）——提供了"用博弈结构建模多 agent 交互"的思想。另一条是深度学习里的**Transformer 轨迹预测**（如 SceneTransformer、Trajectron++）——提供了处理高维场景、多 agent 的强大架构。 GameFormer 由 Huang、Liu、Lv（南洋理工 AutoMan Lab）在 ICCV 2023（Oral） 提出（arXiv:2303.05760），把两条线焊在一起。

论文原文（GameFormer 方法核心，转述）：模型含一个 Transformer encoder（有效建模场景元素之间的关系），以及一个新颖的**层级 Transformer decoder** 结构；在每个解码层，decoder 利用**上一层的预测结果** + 共享的环境上下文，迭代地精化交互过程。此外提出一个学习过程，调节当前层 agent 的行为去**响应上一层**其他 agent 的行为。

用人话重讲：GameFormer 的 encoder 把场景（地图 + 所有 agent 历史）编码成上下文；decoder 分**多层**，第一层（Level-0）让每个 agent 独立预测初始轨迹，之后每一层（Level-k）都让每个 agent 看到上一层所有 agent 的预测、再精化自己的预测——这就是对上一层做"最佳响应"。训练时还专门设计了损失，强制**当前层的行为是对上一层的合理响应（而非随意精化）。一句话：**decoder 的第 k 层 = Level-k，逐层精化 = Level-k 递归，最终输出收敛到一个近似 Nash 的联合预测。

论文 → 代码桥接：核心是 decoder 的层级结构——每层用**交叉注意力（cross-attention）**让 agent 关注"上一层其他 agent 的预测 + 环境上下文"。代码里这体现为多个堆叠的 decoder layer，每层的 query 是当前 agent 的轨迹特征、key/value 是上一层所有 agent 的预测 + encoder 上下文。下面的架构走读会画清这个注意力流。

它的成绩很硬：ICCV 2023 Oral（口头报告，约前 3% 论文）、Waymo Open Motion Dataset 交互预测 SOTA、其扩展 GameFormer Planner 在 nuPlan 基准上有竞争力的闭环表现（并获 nuPlan 2023 创新奖相关荣誉）。

为什么它的成绩值得在意（而非又一个刷榜模型）？因为它证明了一件事：把博弈论的结构作为归纳偏置注入神经网络，能在大规模真实数据上胜过没有这种结构的模型。这不是理所当然的——深度学习时代有一种倾向是"数据足够多，结构不重要，让网络自己学"。 GameFormer 的结果反驳了这点：在交互预测这个**本质是博弈**的任务上，给网络一个 Level-k 的骨架，比让它从零学交互更有效（也更数据高效）。这对整个领域的启示是：领域结构（这里是博弈论）和数据驱动不是对立的，把正确的结构注入网络往往是 SOTA 的关键——这也是为什么本章花大力气讲清 Level-k（§3.2），它是 GameFormer 这个骨架的来源。 GameFormer Planner 在 nuPlan **闭环**评估上的表现尤其值得注意——闭环（车真的按预测-规划开、看长期后果）比开环（只比单步预测准不准）更能反映真实驾驶能力，也更能暴露 frozen robot（§3.4）。它在闭环上的竞争力，正是"预测即均衡"范式相对传统管线的实证优势。

理论：GameFormer 的架构¶

GameFormer 的架构可以分三部分，整体是"encoder 编码场景 → 层级 decoder 逐层博弈 → 输出联合预测"：

【Encoder】场景编码
  输入: HD 地图（车道/人行道/信号灯）+ 所有 agent 的历史轨迹
  Transformer encoder 建模场景元素间的关系
  输出: context tokens（共享环境上下文）
         │
         ▼
【Decoder】层级博弈（核心创新）
  Decoder Layer 0 (Level-0):
    每个 agent 基于 context + 初始 modality query 独立预测初始轨迹
    （不看其他 agent 的未来——这是递归地基，对应 §3.2 的 Level-0 规则策略）
         │
         ▼
  Decoder Layer 1 (Level-1):
    每个 agent 对【Layer 0 所有 agent 的预测】+ context 做交叉注意力
    → 精化自己的轨迹（= 对 Level-0 对手做最佳响应）
         │
         ▼
  Decoder Layer k (Level-k):
    每个 agent 对【Layer k-1 所有 agent 的预测】+ context 做交叉注意力
    → 精化自己的轨迹（= 对 Level-(k-1) 对手做最佳响应）
         │
         ▼
【Output】所有 agent 的联合轨迹预测（近似 Nash 均衡）
  通常还输出多模态（每个 agent 多条候选轨迹 + 概率）

对照 §3.2 的 Level-k 递归 (3.5) \(\pi_k=\text{BestResponse}(\pi_{k-1})\)，GameFormer 的每一层 decoder 就是这个递归的一次迭代——只不过"最佳响应"不是显式求解，而是用**一层 Transformer 的交叉注意力 + 前馈**来**学习**逼近。

本质洞察（GameFormer = 把 Level-k 递归"编译"进 decoder 层）：GameFormer 最漂亮的地方，是它把一个**算法**（Level-k 递归）变成了一个**架构**（decoder 的层）。 §3.2 的 Level-k 是一个迭代算法——每层调用一次正向求解器（best response）。 GameFormer 把"调用一次 best response"换成"过一层 decoder"——decoder 层学会了用注意力实现最佳响应。于是：迭代 k 次 ↔ 堆叠 k 层 decoder；每次 best response ↔ 一层交叉注意力（agent 关注上一层其他 agent 的预测）。这个"算法→架构"的转换有两个好处：(1) 推理是一次前向传播（堆叠的 k 层），无需迭代收敛检查，避开了 iLQGames 可能不收敛的问题；(2) "最佳响应"的具体形式是**学**出来的（从数据），不必手工设计代价函数。代价是：它给出的是**学到的近似** Nash，不像 iLQGames 那样有精确均衡的保证，也不可解释（学到的注意力权重不等于显式代价）。

多视角理解（GameFormer 的注意力 ↔ "谁在关注谁"）：Transformer 的注意力机制天然契合博弈交互——注意力权重 \(\text{attn}(i,j)\) 编码了"agent \(i\) 在多大程度上关注 agent \(j\)"。相似之处：博弈里每个 agent 的最优响应取决于它对哪些对手的预期，注意力恰好显式地建模这种"关注关系"——交叉路口该让行的车会"高度关注"有优先权的车。不同之处：iLQGames 的"关注"隐含在耦合 Riccati 的非对角块里（固定的、由代价决定），GameFormer 的"关注"是数据驱动、随场景动态变化的注意力权重。一句话：Transformer 的注意力为"博弈中谁在意谁"提供了一个天然的、可学习的载体——这是 GameFormer 选 Transformer（而非其他网络）作为博弈交互骨架的深层原因。

反事实（如果 GameFormer 不做层级 decoder）：假设 GameFormer 去掉层级结构，只用一层 decoder 让每个 agent 独立预测（即只有 Level-0）。那它就退化成一个普通的"独立多 agent 预测器"——每个 agent 的预测不考虑其他 agent 的未来反应，回到本节反面案例的"忽略未来交互"。预测出的多 agent 未来会相互矛盾（各自最优、但联合起来冲突）。正是**层级 decoder**（Level-1 及以上对上一层做响应）让 GameFormer 的联合预测变得**相互一致**——这就是它的核心贡献所在，也印证了 §3.2 "Level-0 之上才有交互推理"。

训练：如何"强制"逐层响应¶

一个关键问题：堆叠多层 decoder，凭什么保证"第 k 层真的在对第 (k-1) 层做最佳响应"，而不是学成随意的精化？这正是 GameFormer 论文标题里"Learning"的分量——它的另一个核心创新是**训练过程的设计**，专门调节每层行为去响应上一层。

论文原文（GameFormer 训练机制，转述）：提出一个学习过程，**调节**当前层 agent 的行为去**响应**上一层其他 agent 的行为。

用人话重讲：光有层级 decoder 的架构还不够——网络可能学不出"响应"的语义，每层各干各的。 GameFormer 在损失函数上做文章：除了让每层的预测**逼近真实轨迹**（模仿学习的常规损失），还额外设计损失，让第 k 层的预测是对"第 (k-1) 层其他 agent 预测"的合理最优响应。具体地，训练时每一层都有监督——用真实未来轨迹监督每层输出（逐层都要预测对、不只是最后一层），并让 agent 的预测以"上一层其他 agent 的预测"为条件。这样网络被"逼着"学出 Level-k 的语义：第 k 层必须在"假设别人是第 (k-1) 层"的前提下预测自己——损失引导它逼近最佳响应。

本质洞察（架构给骨架，损失给语义）：这补全了"GameFormer = 博弈结构 + 数据驱动"的另一半。前面说层级 decoder 的**架构**提供了 Level-k 的"骨架"（分层 + 交叉注意力）；但骨架本身不保证每层有"最佳响应"的语义——那是**训练损失**注入的。类比：架构像搭好了"逐层递归"的舞台，损失函数像导演，"逼"每一层演出"对上一层做最佳响应"的戏。没有这个训练设计，多层 decoder 可能退化成普通的多层网络（只是更深，没有博弈语义）。这也呼应后面"差异分析"会强调的：论文说的"最佳响应"在实现里是**损失引导的软倾向**，而非硬约束——网络是被"鼓励"去响应，不是被"强制"满足 KKT。这是理解 GameFormer（以及一切"把博弈结构注入神经网络"的方法）的关键：结构 + 损失共同塑造博弈语义，二者缺一不可。

代码走读：层级 decoder 的核心机制¶

GameFormer 的官方实现用 PyTorch，但它的**核心机制**——交叉注意力实现的逐层最佳响应——可以用纯 NumPy 剥离出来看清楚（不依赖深度学习框架，反而更能看清每步在算什么）。这里走读一个最小层级 decoder：3 个 agent、2 个环境 context token，看"decoder 第 k 层 = Level-k"如何落成代码。

交叉注意力（decoder 的原子操作）。 每一层 decoder 的核心是交叉注意力——让一个 agent 的 query 去"查询"key/value（上一层各 agent 的预测 + 环境 context）：

import numpy as np

def softmax(x, axis=-1):
    e = np.exp(x - np.max(x, axis=axis, keepdims=True))
    return e / np.sum(e, axis=axis, keepdims=True)

def cross_attention(query, key, value):
    """标准缩放点积注意力。query:(Nq,d), key/value:(Nk,d)。"""
    d = query.shape[-1]
    attn = softmax(query @ key.T / np.sqrt(d), axis=-1)   # (Nq,Nk) 注意力权重 = "谁关注谁"
    return attn @ value, attn                             # 加权聚合 + 权重矩阵

一层 decoder = 一个 Level。 关键设计：每层的 query 是当前 agent 的轨迹特征，key/value 是**上一层各 agent 的预测 + 环境 context**——这让 agent "关注其他 agent 上一层怎么走"，再据此精化自己的预测（= 对上一层做最佳响应）：

class GameFormerDecoderLayer:
    """一层 decoder = 一个 Level：agent 对'上一层各 agent 预测 + 环境 context'做交叉注意力。"""
    def __init__(self, d):
        self.Wq = np.eye(d) + 0.05*np.random.randn(d, d)   # 真实中是学出来的投影
        self.Wk = np.eye(d) + 0.05*np.random.randn(d, d)
        self.Wv = np.eye(d) + 0.05*np.random.randn(d, d)
    def forward(self, prev_preds, context):
        # key/value = 上一层各 agent 预测 ⊕ 环境 context（agent 关注他人上一层轨迹 + 地图）
        kv = np.vstack([prev_preds, context])
        out, attn = cross_attention(prev_preds @ self.Wq, kv @ self.Wk, kv @ self.Wv)
        refined = prev_preds + out                          # 残差：在上一层基础上精化（最佳响应）
        return refined, attn

堆叠 = Level-k 递归。 Level-0 让每个 agent 独立预测（不看他人，递归地基）；之后堆叠 K 层，逐层精化：

N, M, d = 3, 2, 8                          # 3 个 agent, 2 个环境 token, 特征维 8
context = np.random.randn(M, d)
preds = np.random.randn(N, d)              # Level-0：每个 agent 独立预测的初始轨迹特征
layers = [GameFormerDecoderLayer(d) for _ in range(3)]
for lv, layer in enumerate(layers, 1):     # Level-1, 2, 3：逐层对上一层做交叉注意力精化
    preds, attn = layer.forward(preds, context)
# attn[i,j] = agent i 对 agent j 的关注程度（"谁在关注谁"）

跑出来的数据流清晰展示了 §3.2 Level-k 递归在 decoder 里的化身：

层	做什么	对应 §3.2
Level-0	每个 agent 独立预测初始轨迹（不看他人）	Level-0 规则策略（递归地基）
Level-1	每个 agent 对 Level-0 的 N 个 agent 预测 + context 做交叉注意力 → 精化	对 Level-0 做最佳响应 (3.5)
Level-k	每个 agent 对 Level-(k-1) 的预测 + context 做交叉注意力 → 精化	对 Level-(k-1) 做最佳响应

本质洞察（注意力矩阵 = "谁在关注谁"的显式编码）：跑出来的注意力权重矩阵 attn[i,j]，直接读出了"agent \(i\) 在多大程度上关注 agent \(j\)"。这正是 §3.3 前面那个多视角洞察的代码兑现——博弈交互里"谁在意谁"被注意力权重显式、可学习地编码。对比 §3.2 的 Level-k 代码：那里"对上一层做最佳响应"是调用一次 best_response（显式优化求解）；这里"对上一层做最佳响应"是过一层交叉注意力（学习逼近的映射）。同一个 Level-k 递归骨架，§3.2 用显式求解器实现、GameFormer 用注意力层实现——这就是"算法→架构"转换最具体的体现。真实 GameFormer 比这复杂得多（多头注意力、多模态轨迹、专门的训练损失强制"响应上一层"），但核心数据流就是这个"逐层交叉注意力精化"。

代码走读：多模态预测——为什么不是单条轨迹¶

上面的 decoder 输出每个 agent 一条精化后的轨迹特征，但前面差异分析表提到一个真实细节：GameFormer 的输出是**多模态**的——每个 agent 给出 \(M\) 条候选轨迹 + 各自概率，而非单条确定轨迹。这一点常被初学者忽略，却是处理"对手意图本质不确定"的关键。用代码看它怎么实现：

import numpy as np
def softmax(x):
    e = np.exp(x - np.max(x)); return e / e.sum()

class MultiModalDecoder:
    """每个 agent 用 M 个 modality query，解出 M 条候选轨迹 + 各自概率。"""
    def __init__(self, d, M, horizon):
        self.M, self.horizon = M, horizon
        self.mode_queries = np.random.randn(M, d)        # M 个 modality query（代表不同意图：左转/直行/右转）
        self.Wtraj  = np.random.randn(d, horizon*2)*0.3  # query → 轨迹（horizon 个 xy 点）
        self.Wscore = np.random.randn(d)                 # query → 该模态得分
    def forward(self, agent_context):                    # agent_context:(d,) 含交互信息的编码
        trajs, scores = [], []
        for m in range(self.M):
            q = self.mode_queries[m] + agent_context      # 模态 query 融合 agent 上下文
            trajs.append((q @ self.Wtraj).reshape(self.horizon, 2))   # 该模态预测轨迹
            scores.append(q @ self.Wscore)                # 该模态得分
        return np.array(trajs), softmax(np.array(scores)) # M 条轨迹 + 概率（和为 1）

np.random.seed(6)                                # 固定随机种子，保证下表可复现
decoder = MultiModalDecoder(d=8, M=3, horizon=5)
trajs, probs = decoder.forward(np.random.randn(8))
# probs ≈ [0.885, 0.025, 0.090]（和为 1）；最可能模态 0

跑出来，一个 agent 的预测是 3 条带概率的候选轨迹：

模态	概率	轨迹终点 (x,y)	解读
模态 0	0.885	(−0.51, −0.13)	最可能（如直行）
模态 1	0.025	(+0.86, +1.53)	低概率（如左转）
模态 2	0.090	(+0.74, +1.54)	次低（如右转）

本质洞察（多模态 = 对"意图不确定"的诚实表达）：为什么 GameFormer（以及几乎所有现代轨迹预测器）要输出多模态而非单条？因为对手的意图**本质上是不确定的**——路口那辆车到底左转、直行还是右转，从它当前的运动学**看不出唯一答案**。强行预测单条轨迹，等于在多个可能意图间求了个"平均"——平均轨迹可能是一条谁都不会走的"中间路线"（比如左转和右转的平均是直行，但车实际不会直行）。多模态 + 概率诚实地表达了这种不确定：保留所有可能意图，各带概率，让下游规划对**每种**可能分别评估风险（如对高概率的直行松一点、对低概率但危险的抢行也留余量）。这呼应了 §3.4 提到的"对手意图不确定"和前沿的 Contingency Games——多模态预测是博弈式交互规划处理意图不确定的标准手段。注意这与 §3.1 逆博弈的关系：逆博弈推断对手的**代价参数**（一个连续量），多模态预测给对手的**未来轨迹**（多个离散意图）——前者是"对手想要什么"的紧凑表达，后者是"对手可能怎么走"的展开，两者互补。

与 iLQGames 的对比：隐式博弈 vs 显式博弈¶

GameFormer（隐式、学习）和 iLQGames（显式、求解）代表两条对立又互补的路线。这是规格要求的核心对比，也是技术选型的关键：

系统性分类（隐式博弈 vs 显式博弈）：

维度	GameFormer（隐式博弈）	iLQGames（显式博弈，G2）
均衡求解	神经网络学习逼近（前向传播）	数值求解（迭代耦合 Riccati）
Level-k 实现	decoder 层（堆叠 k 层）	算法递归（调用 k 次 best response）
代价函数	隐式、从数据学	显式、手工设计
可扩展性	强（几十 agent + HD 地图，一次前向）	弱（agent 数增加，求解变慢）
可解释性	弱（注意力权重 ≠ 显式意图）	强（代价/均衡可解释）
均衡保证	无（学到的近似）	有（精确局部 Nash）
收敛问题	无（固定层数前向）	有（迭代可能不收敛，§2.7）
数据需求	大（需海量驾驶数据训练）	小（不需训练数据）
典型场景	密集城市、大规模、产业部署	少 agent、要可解释/保证、研究

核心权衡：GameFormer 用"可扩展 + 快 + 免设计代价"换"可解释 + 均衡保证"；iLQGames 反之。 密集城市场景、有海量数据、要产业落地 → GameFormer；少数 agent、要可解释或精确保证、研究分析 → iLQGames。两者也能结合——这正是规格开放问题之一："如何把 GameFormer 的端到端学习与 iLQGames 的可解释求解结合"。

为什么 Transformer 天然适合"可变数量的 agent"。 上表说 GameFormer"可扩展"、iLQGames"agent 数增加变慢"，这背后有一个架构层面的深层原因，值得点出。 iLQGames 的耦合 Riccati 维度随 agent 数**固定增长**——\(N\) 个 agent 就要解一个 \(N\) 倍大的耦合系统，且求解器的结构（矩阵维度）写死**在代码里，换个 agent 数就要重构。 Transformer 的注意力机制则**天然支持可变长度输入——注意力对一组 token 操作，token 数（agent 数）可以变，同一套权重处理 3 个或 30 个 agent 都行（就像同一个语言模型处理不同长度的句子）。这就是为什么 GameFormer 能直接上密集城市场景（几十个动态变化的 agent）——它不需要为每个 agent 数重新设计求解器，注意力自动适配。

本质洞察（可变 agent 数 = 注意力的"集合处理"能力）：这个优势的根源，是注意力机制把 agent 当成一个**集合**来处理，而非固定维度的向量。集合的大小可变，注意力对集合里每个元素一视同仁地算"它关注谁"——所以加一个 agent，只是集合多一个元素，不改变计算结构。对比 iLQGames：它把所有 agent 拼成一个固定维度的大状态向量，维度由 agent 数决定，结构写死。这解释了规格练习"修改架构支持可变数量输入"为什么对 GameFormer 几乎是免费的（注意力本就支持），对 iLQGames 却很难（要重构求解器）。更深一层：这是"学习式方法"相对"求解式方法"在**可扩展性**上的普遍优势——神经网络的结构可以设计成对输入规模不变（注意力、图网络都是），而显式求解器的结构往往和问题规模绑定。这也是为什么密集多 agent 场景，产业界倾向学习式方法。

代码走读：用 mask 处理可变 agent 数。 工程上，可变 agent 数通过"固定最大长度 + 注意力 mask"实现——padding 位置在 softmax 前打 −∞，权重归零：

def masked_attention(query, key, value, mask):    # mask:(Nq,Nk) True=有效, False=padding
    d = query.shape[-1]
    scores = query @ key.T / np.sqrt(d)
    scores = np.where(mask, scores, -1e9)          # padding 位打 -inf → softmax 后 ≈0
    attn = softmax(scores, axis=-1)
    return attn @ value, attn

def process_scene(n_agents, max_agents=8):         # 同一套权重处理任意 n_agents
    feats = np.zeros((max_agents, d)); feats[:n_agents] = np.random.randn(n_agents, d)
    mask = np.zeros((max_agents, max_agents), dtype=bool); mask[:n_agents,:n_agents] = True
    return masked_attention(feats@W, feats@W, feats@W, mask)   # W 是同一套（训练好的）权重

跑 2/3/5 个 agent，同一套权重 W 都正常工作，且注意力**不泄漏到 padding**（精确 0.00）：

agent 数	输出 shape	注意力泄漏到 padding
2	(2, d)	0.00
3	(3, d)	0.00
5	(5, d)	0.00

同一个模型自动适配不同 agent 数——这就是 GameFormer 上密集场景的工程底气；换成 iLQGames，换个 agent 数就要重构求解器维度。注意 mask 的关键作用：它保证有效 agent 只 attend 有效 agent，padding 不污染计算——这是变长序列处理的标准手法（Transformer 处理变长句子同理）。

差异分析：论文叙述 vs 实现细节¶

论文解读的一个关键能力，是看出"论文怎么说"和"代码怎么做"之间的落差——这些落差往往是真正理解一个方法的钥匙。 GameFormer 有几处论文叙述（博弈论语言）与实现（神经网络细节）需要对照着看，否则容易误解。

论文叙述（博弈论语言）	实现细节（神经网络）	容易误解处
"decoder 第 k 层实现 Level-k 最佳响应"	一层 Transformer decoder（交叉注意力 + 前馈），权重从数据学	误以为有显式的 best-response 求解；实际是学习逼近的映射
"对上一层做最佳响应"	训练时用专门的损失，鼓励第 k 层输出对第 (k-1) 层合理；不是硬约束	误以为严格满足最佳响应；实际是损失引导的软倾向
"层级博弈逼近 Nash"	固定层数（少数几层）前向传播，无收敛判据	误以为迭代到 Nash 不动点；实际是固定深度的近似
"每个 agent 的预测"	多模态：每 agent 输出多条候选轨迹 + 概率，非单条	误以为单条确定性轨迹；实际是概率化多模态
"建模未来交互"	通过 decoder 层间的交叉注意力，让各 agent 预测相互依赖	误以为显式建模博弈动力学；实际是注意力捕捉的统计依赖

本质洞察（GameFormer 是"博弈结构 + 数据驱动"的杂交体）：上表的每一行，本质都是同一个落差——博弈论提供了架构的"骨架"，数据提供了骨架里的"肉"。层级 decoder 的**结构**（分层、逐层响应上一层）是博弈论的（Level-k 的归纳偏置）；但每一层**具体算什么**（注意力权重、前馈变换）是从数据学的。这解释了 GameFormer 的双重性格：它比纯黑箱预测器**更有结构**（博弈式归纳偏置让它的多 agent 预测相互一致），又比 iLQGames 更灵活（不必手工设计代价、能从数据学复杂交互模式）。看论文时记住这个落差：凡是博弈论术语（"最佳响应""Nash""博弈"），在实现里都被**软化**成了"学习引导的倾向"而非"严格满足的数学条件"。这正是 §3.3 陷阱 1（以为它求解 Nash）的根源——把架构的博弈论**灵感**误当成了求解的博弈论**保证**。

⚠️ 常见陷阱¶

陷阱 1（概念误区）：以为 GameFormer 求解了 Nash 均衡 - 错误描述：看到 GameFormer 用 Level-k 博弈、输出"近似 Nash"，就以为它像 iLQGames 一样真的求解了 Nash 均衡。 - 现象/后果：期望 GameFormer 的输出满足 Nash 的最优性条件（KKT），用它做需要均衡保证的安全分析，结果不可靠。 - 根本原因：GameFormer 是**学习**逼近，不是**求解**。它的 decoder 层学会了"像最佳响应"的映射，但没有任何机制保证输出满足 Nash 的 KKT 条件——它是从数据拟合出的近似，可能违反均衡最优性。 - 正确做法：把 GameFormer 当成一个**博弈式归纳偏置的预测器**，而非 Nash 求解器。需要均衡保证时用 iLQGames/ALGAMES（显式求解），或在 GameFormer 输出上加安全滤波（G4）兜底。检验方法：别假设其输出满足 KKT，要做后验安全检查。

陷阱 2（论文误导）：以为 decoder 层数越多（Level 越高）预测越准 - 错误描述：既然 decoder 层对应 Level-k、k 越高越接近 Nash，就堆很多 decoder 层期望更准。 - 现象/后果：层数过多时收益递减甚至下降，训练变难、过拟合、推理变慢；且偏离了真实人类 k≈1-2（§3.2）的有界理性。 - 根本原因：呼应 §3.2 陷阱 1——Level-k 的价值在 k 小。真实交互的认知层级低，过多层级不对应真实人类行为；且更多层带来优化困难。GameFormer 论文用的 decoder 层数是有限的少数几层（对应低 Level），不是越多越好。 - 正确做法：按论文设置用少数几层 decoder（对应 Level 1-3 量级），用验证集选最优层数；理解"层数=认知深度"，而真实认知深度是低的。检验方法：在验证集上扫层数，看准确率拐点。

陷阱 3（编程陷阱）：层级 decoder 中错误地让 Level-k 看到同层而非上一层 - 错误描述：实现层级 decoder 时，让第 k 层的 agent 对**同层（第 k 层）其他 agent 的预测做注意力，而非**上一层（第 k-1 层）。 - 现象/后果：破坏了 Level-k 递归的因果结构（Level-k 应对 Level-(k-1) 响应），形成同层循环依赖，训练不稳定或退化。 - 根本原因：Level-k 的定义是对**上一层**做最佳响应 (3.5)。让它看同层会引入循环依赖（k 层依赖 k 层），既不符合 Level-k 语义，也使前向传播的依赖关系混乱。 - 正确做法：严格让第 k 层的 query 对**第 k-1 层的输出**（+ encoder context）做交叉注意力，保持"逐层响应上一层"的单向依赖。检验方法：检查 decoder 每层的输入是否来自前一层的输出，而非当前层。

练习¶

（B 型·GameFormer 论文精读） 精读 ICCV 2023 论文，画出 Level-k decoder 的**注意力流图**：标出每层 decoder 的 query/key/value 各来自哪里（当前 agent 特征 / 上一层预测 / encoder context）。对比 GameFormer 的"隐式博弈"与 iLQGames 的"显式博弈"，列出至少四个维度的差异（可参考本节对比表）。
（设计扩展题） GameFormer 的 decoder 层数（Level 数）是固定的超参数。设计一个实验：在 Waymo 或 nuPlan 子集上，扫 decoder 层数 1~5，绘制"层数 vs 交互预测准确率"曲线。结合 §3.2 的 τ≈1.5，讨论最优层数落在哪、为什么（呼应陷阱 2）。
（思考题·隐式 vs 显式选型） GameFormer 用 Transformer 隐式逼近 Nash、无需迭代求解；iLQGames 用显式迭代保证精确 Nash。请论证：(a) 在什么场景下你会选 GameFormer（提示：agent 数量、数据可得性、实时性、可解释性需求）；(b) 什么场景下选 iLQGames；(c) 如何设计一个结合两者的系统（如 GameFormer 做粗预测 + iLQGames 做精细安全关键交互，或用 iLQGames 的均衡数据训练/约束 GameFormer）。
（复现验证） 克隆 MCZhi/GameFormer，跑通 Waymo Open Motion Dataset 交互预测的评估流程，复现论文报告的指标（如 minADE、minFDE、mAP）。重点验证：(a) 增加 decoder 层数（Level 数）时，交互预测指标如何变化，是否在某个层数后饱和/下降（对照陷阱 2 与 §3.2 的 τ≈1.5）；(b) 关掉层级结构（只留 Level-0 独立预测）后，多 agent 联合预测的一致性指标如何退化（验证反事实分析的论断）。
（差异分析） 对照 GameFormer 论文与官方代码，找出至少 3 处"论文叙述 vs 实现细节"的落差（可从本节差异分析表出发，但要落到具体代码行）。例如：(a) 论文说"对上一层做最佳响应"，代码里是用什么损失项实现的、是硬约束还是软引导？(b) "近似 Nash"在代码里有没有任何收敛判据，还是固定层数前向？(c) 多模态轨迹的概率是怎么算的、训练时怎么监督？对每处落差，判断这样实现的合理性。

§3.4　预测-规划一体化："预测即均衡"　⭐⭐¶

这一节解决什么问题：前三节给了推断对手的工具（逆博弈、Level-k、GameFormer）。这一节把它们收束成一个**范式转变**——传统自动驾驶"先预测后规划"的管线有结构性缺陷（frozen robot），而博弈视角给出最终解法：预测就是博弈均衡中对手的最优响应，规划就是 ego 的最优响应，两者同时求解。这一节也把全章拉回 G1 §1.1 那个开篇难题，给它画上句号。

动机：frozen robot 的幽灵¶

回到 G1 §1.1 的开篇——无保护左转，frozen robot：ego 把对向车当固定障碍，预测它会一直开过来、占满所有间隙，于是 ego 判定无安全机会、原地僵死。 G1 用这个例子引出博弈视角，G2 给了实时求解器，G3 前三节给了推断对手的工具。现在到了正面回答这个问题的时候：到底怎样的系统架构，能从根上消除 frozen robot？

答案不在"更好的预测器"或"更好的规划器"，而在**两者如何组织**。传统自动驾驶把它们做成一条**流水线**：先预测、后规划。这个流水线本身就是 frozen robot 的温床——下面看为什么。

反面案例：传统"先预测后规划"管线的结构性缺陷¶

传统自动驾驶的经典架构是一条单向流水线：

感知 → 预测（predictor 预测他人未来轨迹）→ 规划（planner 在预测的他人轨迹下规划 ego）

这条管线有一个**结构性**（而非实现质量）的缺陷——predictor 和 planner 之间是**单向**的：predictor 先预测他人轨迹，planner 再把这些预测当**固定的**障碍来规划 ego。

问题出在"固定"二字：

本质洞察（先预测后规划 = 把交互砍成单向）：predictor 预测他人未来时，它**看不到 ego 的未来计划**（planner 还没运行）。于是 predictor 只能假设他人**不对 ego 反应**——预测的是"他人在 ego 不存在/不动时会怎么走"。这直接导致两个病：其一，frozen robot：predictor 预测对向车会一直直行（不会因 ego 探入而减速让行），planner 看到"所有间隙都被预测占满"，判定无安全机会，ego 僵死。可现实中，只要 ego 探一下，人类司机往往会让——但这个"会让"被单向管线砍掉了。其二，prediction-planning 不一致：planner 规划的 ego 轨迹会影响他人实际行为，但 predictor 的预测没考虑这个影响。于是"预测的他人轨迹"和"ego 规划执行后他人的实际轨迹"不一致——预测自相矛盾。根子是：真实交互是双向的（ego 影响他人、他人影响 ego），而先预测后规划把它砍成了单向（他人→ego）。

很多工程上的补丁（如多次迭代 predictor-planner、给 predictor 喂 ego 的候选计划）都是在打这个结构性缺陷的补丁，但治标不治本——只要架构是"预测和规划分离的两个模块"，不一致就难以根除。

理论：博弈视角的"预测即均衡"¶

博弈视角给出的解法，是把"预测"和"规划"统一进同一个博弈均衡，不再分成两个模块：

核心范式（预测即均衡）： - 他人的"预测" = 博弈均衡中他人的最优响应——自然考虑了 ego 的影响（因为均衡里他人是对 ego 的策略做最优响应）。 - ego 的"规划" = 博弈均衡中 ego 的最优策略——自然考虑了他人的响应（因为均衡里 ego 是对他人的策略做最优响应）。 - 两者同时求解 = 求一个 Nash/Stackelberg 均衡——预测和规划在均衡点上自洽，消除 prediction-planning 不一致。

用一句话概括这个范式转变：不存在独立的"预测"步骤——他人的预测，就是博弈均衡里他人那一部分的解；ego 的规划，就是 ego 那一部分的解。求解一次博弈，预测和规划同时出来，且彼此一致。

这正是 G2 的求解器在做的事——iLQGames 解出的均衡，同时包含了所有 agent 的轨迹（ego 的"规划" + 他人的"预测"），它们在均衡意义下相互最优、自洽。而 G3 前三节补上了这个范式落地所缺的最后一块——**对手代价未知**怎么办： - §3.1 逆博弈：从观测推断对手代价，让均衡求解有正确的对手模型。 - §3.2 Level-k：用有界理性模型替代完美 Nash，让"他人的最优响应"更贴合真实人类。 - §3.3 GameFormer：端到端学习这个"联合预测=均衡"，可扩展到密集城市。

形式化：预测与规划的统一不动点。 把"预测即均衡"写成数学，能看清它为什么消除不一致。传统先预测后规划是两个**分离**的优化：

\[\underbrace{\hat x_{-e}=\text{Predict}(\text{history})}_{\text{预测：不含 }u_e}\quad\to\quad\underbrace{u_e^*=\arg\min_{u_e}J_e(u_e,\hat x_{-e})}_{\text{规划：}\hat x_{-e}\text{ 固定}}.\]

注意预测 \(\hat x_{-e}\) 不依赖 \(u_e\)（predictor 看不到 ego 计划），规划又把 \(\hat x_{-e}\) 当**固定**——这个单向依赖就是不一致的根源。

博弈一体化把它写成一个**联合不动点**——所有 agent（含 ego）的策略相互最优：

\[\big(u_e^*,\,u_{-e}^*\big)\ \text{满足}\ \begin{cases}u_e^*=\arg\min_{u_e}J_e\big(u_e,\,u_{-e}^*\big)&\text{(ego 规划：对他人响应最优)}\\[4pt]u_{-e}^*=\arg\min_{u_{-e}}J_{-e}\big(u_{-e},\,u_e^*\big)&\text{(他人预测：对 ego 响应最优)}\end{cases}\]

这正是 Nash 均衡的定义（G2 (2.1)）。关键差别：这里 \(u_e^*\) 和 \(u_{-e}^*\) 相互依赖、同时求解——ego 的规划用了他人的响应 \(u_{-e}^*\)，他人的预测用了 ego 的策略 \(u_e^*\)，二者在不动点上自洽。 "他人预测"那一行 \(u_{-e}^*=\arg\min J_{-e}(u_{-e},u_e^*)\) 就是"预测=对手最优响应"的数学表达——它**含** \(u_e^*\)，所以预测考虑了 ego 影响（与传统的 \(\hat x_{-e}\) 不含 \(u_e\) 形成鲜明对比）。

本质洞察（一个 argmin 含不含 \(u_e\)，就是全部差别）：盯住两种写法里"他人预测"的那一项。传统：\(\hat x_{-e}=\text{Predict}(\text{history})\)——不含 \(u_e\)，预测与 ego 无关。一体化：\(u_{-e}^*=\arg\min J_{-e}(u_{-e},u_e^*)\)——含 \(u_e^*\)，预测是对 ego 的最优响应。这**一个变量的有无**，就是"先预测后规划"和"预测即均衡"的全部数学差别，也是 frozen robot 有无的全部根源。传统写法里，无论 ego 怎么规划，预测都不变（他人雷打不动）→ ego 看到固定的占满间隙 → frozen；一体化写法里，ego 一变，他人的最优响应跟着变（会让）→ ego 敢探入。所以"预测即均衡"不是加了什么复杂机制，而是把预测那个 argmin 里**补上了 \(u_e\) 这个被传统管线丢掉的依赖**——博弈求解器（G2）天生就在解这个含 \(u_e\) 的联合不动点，这就是为什么说"G2 的求解器本身就是预测-规划一体化引擎"。

本质洞察（frozen robot 的最终解法）：现在可以正面回答 G1 §1.1 的难题了。 frozen robot 的根源，是 ego 假设对手不对自己反应（把对手当固定障碍）。 "预测即均衡"从根上拔掉这个假设——在博弈均衡里，对手**必然**对 ego 反应（它是对 ego 策略的最优响应）。于是 ego 在规划时就"知道"：我探入，对手会让（因为让是它在我探入时的最优响应）。 ego 不再僵死，而是敢于试探——因为均衡告诉它试探会引发对手让行。这就是 G1→G2→G3 这条主线的终点：从"理论上承认对手是决策者"（G1 §1.1 第一跨），到"实时求解交互均衡"（G2），到"推断未知对手代价 + 把预测规划统一进均衡"（G3）——frozen robot 被彻底解决。

多视角理解（预测即均衡 ↔ 三章主线的收束）：这个范式把全部三章串成一条线。 G1 §1.1 提出三次认知跨越：(1) 对手是决策者（→博弈）；(2) 预测即均衡（对手的预测=它的最优响应）；(3) 代价需推断（→逆博弈）。现在三跨全部兑现：G1-G2 兑现第一跨（博弈建模+求解）；本节 §3.4 兑现第二跨（预测即均衡的范式）；§3.1-§3.3 兑现第三跨（逆博弈/Level-k/GameFormer 推断对手）。一句话："预测即均衡"不是一个新方法，而是一个视角的转变——它让你看到，G2 的博弈求解器本身就是一个"预测-规划一体化"的引擎，而 G3 的推断工具补上了"对手未知"这最后一环。三章至此合龙。

代码走读：先预测后规划 vs 博弈一体化¶

"frozen robot 是架构问题"听起来抽象，用一个对比 demo 让它具体。同一个汇入场景（ego 并入主道、主道有对手、冲突点在前方），两种架构跑出来的差别一目了然。

方式 A：先预测后规划。 预测器假设对手匀速直行（不对 ego 反应），ego 在这个预测下规划——只要预测显示冲突点附近有对手，ego 就减速避让：

import numpy as np
dt, T, conflict, gap_min, v0 = 0.5, 12, 10.0, 3.0, 5.0

def simulate_A_pred_then_plan():
    xo_pred = np.array([1.0 + v0*dt*k for k in range(T+1)])   # 预测：对手匀速（不理 ego）
    xe, ve = 0.0, v0; ego_traj, vel = [xe], [ve]
    for k in range(T):
        if conflict-gap_min < xe < conflict+gap_min:          # ego 进了冲突区
            opp_near = any(abs(xo_pred[j]-conflict)<gap_min    # 预测对手此刻也在？
                           for j in range(max(0,k-1), min(T+1,k+2)))
            a = -3.0 if opp_near else 0.5                      # 预测对手占着 → ego 被迫减速
        elif xe >= conflict+gap_min: a = 1.0                  # 过了冲突区才敢加速
        else: a = 0.3                                          # 接近时保守逼近
        ve = max(0, ve+a*dt); xe += ve*dt; ego_traj.append(xe); vel.append(ve)
    return np.array(ego_traj), np.array(vel)

方式 B：博弈一体化。 对手对 ego 的探入做反应（ego 逼近冲突点时对手让行）——这是均衡中对手的最优响应。ego 知道这一点，于是正常并入：

def simulate_B_game():
    xe, ve, xo, vo = 0.0, v0, 1.0, v0; ego_traj, vel = [xe], [ve]
    for k in range(T):
        ae = 1.0                                              # ego 正常并入（知道对手会让）
        ao = -1.5 if (xe > xo-2 and abs(xe-conflict)<5) else 0.0   # 对手反应：让行（均衡最优响应）
        ve = max(0, ve+ae*dt); xe += ve*dt
        vo = max(0, vo+ao*dt); xo += vo*dt
        ego_traj.append(xe); vel.append(ve)
    return np.array(ego_traj), np.array(vel)

跑出来的对比：

方式	ego 终点	ego 平均速度	ego 最低速度	行为
A（先预测后规划）	17.85	3.13	0.95	被迫反复减速避让，通行低效（frozen 倾向）
B（博弈一体化）	49.50	8.00	5.00	全程顺畅加速，高效通过

方式 A 的 ego 平均速度只有 3.13、最低降到 0.95（几乎停住）——它因为预测"对手不会让"而被迫反复减速避让，通行效率极低，这就是 frozen robot 的典型表现。方式 B 的 ego 全程顺畅（平均速度 8.00），因为均衡告诉它"我探入，对手会让"，于是放心通过。

本质洞察（同一个场景，差别只在对手会不会反应）：这个 demo 的两种方式，唯一**的区别是"对手是否对 ego 反应"。方式 A 把对手当固定的匀速预测（不反应）→ ego 保守僵死；方式 B 让对手对 ego 反应（让行）→ ego 顺畅。注意方式 A 的 ego 最终也没碰撞、甚至勉强通过了——frozen robot 不一定是"完全不动"，更多时候是**过度保守、通行效率极低（平均速度 3.13 vs 8.00 是 2.5 倍差距）。这正是 §3.4 反面案例说的：frozen robot 的根子是"预测不考虑 ego 影响"，而不是预测器本身算得不准。把对手从"固定预测"换成"会反应的博弈玩家"，frozen robot 就消失——这一行代码之差（ao 是否响应 xe），就是"先预测后规划"和"预测即均衡"的全部差别。当然真实的"对手会让"需要正确的对手模型（§3.4 陷阱 2）——这里假设对手让行，真实中要靠 §3.1 逆博弈/§3.2 Level-k 推断对手是否、何时会让。

与 GameFormer 的呼应¶

§3.3 的 GameFormer 其实就是"预测即均衡"范式的一个端到端实现——回头看会更清楚： GameFormer 的 decoder 同时输出所有 agent 的联合轨迹（包括 ego 的规划和他人的预测），它们通过层级博弈相互响应、达到一致。论文标题里"Interactive Prediction and Planning"（交互式预测与规划）正是这个意思——预测和规划在一个模型里联合完成，而非分两步。所以 GameFormer 不只是个预测器，它是"预测即均衡"范式的神经网络化身。

值得一提的是，"预测即均衡"已不只是学术理念，而是当前自动驾驶的现实趋势。传统量产自动驾驶多年来沿用"先预测后规划"的模块化管线（部分原因是它工程上易于分工、易于测试每个模块）。但随着交互密集场景（无保护左转、汇入、环岛）成为 L4 落地的瓶颈，业界越来越多转向博弈式/一体化的预测-规划——nuPlan 这类闭环基准的兴起，正是因为开环预测指标无法反映"预测-规划是否一致"，而闭环才能暴露 frozen robot。 GameFormer Planner 在 nuPlan 闭环上的竞争力，以及学界 LUCIDGames、MaxEnt Games 向实车的推进，都标志着"预测即均衡"正从论文走向产品。理解了这个范式，你就站在了自动驾驶交互规划当前演进的方向上。

预测即均衡的三种实现路线（设计空间全景）¶

"预测即均衡"是个范式，落地时有三条不同的实现路线——正好对应本章和 G2 的三类方法。把它们对照起来，能帮你按场景选路：

路线	怎么实现"预测即均衡"	对手代价来源	优势	短板	出处
显式博弈求解	iLQGames/ALGAMES 解联合均衡，预测=他人那部分解	需已知或逆博弈在线推断	可解释、有均衡保证	少 agent、需对手模型	G2 + §3.1
在线逆博弈 + 求解	LUCIDGames：UKF 推断对手代价 + iLQGames 求均衡	UKF 在线递归估计（带不确定性）	实时适应、量化不确定性	计算重、参数维度受限	§3.1
端到端学习	GameFormer：层级 decoder 隐式逼近联合均衡	隐式从数据学（不显式建代价）	可扩展密集场景、快	不可解释、需海量数据、无保证	§3.3

三条路线的共同内核都是"求一个所有 agent 相互最优的联合解"（前面形式化的联合不动点），区别只在**怎么求**和**对手代价从哪来**：显式求解线**算**这个不动点（需要对手代价，靠逆博弈补）；端到端线**学**这个不动点（对手代价隐式在网络里）。选路判据：少数 agent + 要可解释/保证 → 显式求解（+ 逆博弈推断对手）；要实时适应 + 量化不确定 → LUCIDGames 式在线逆博弈；密集城市 + 有海量数据 → GameFormer 端到端。三者也能混合——这正是规格开放问题"如何结合 GameFormer 的端到端与 iLQGames 的可解释"，也是下面综合系统会体现的。

把上面的选路判据画成一张决策流程图，面对一个实际交互场景时可以照着走：

                        交互场景需要"预测即均衡"
                                │
                    agent 数量多吗（含 HD 地图、密集城市）？
                       │                          │
                      是                          否（2~几个 agent）
                       │                          │
              有海量驾驶数据吗？            需要可解释 / 均衡保证吗？
                │            │                │              │
               有           缺              需要            不强求
                │            │                │              │
          ┌─────────┐  退回少 agent      对手代价已知吗？      要实时
          │GameFormer│   或先采集数据        │        │      适应+不确定性
          │端到端学习│  （§3.3 数据需求大） 已知      未知       量化吗？
          └─────────┘                      │        │          │
          可扩展·快·免设计代价        ┌──────────┐ 在线推断    ┌──────────┐
          代价：不可解释·无保证        │iLQGames  │  对手代价   │LUCIDGames│
                                      │显式求解  │  （§3.1）   │UKF在线   │
                                      │（G2）    │     │       │逆博弈+求解│
                                      └──────────┘     │       └──────────┘
                                      可解释·有Nash保证  ▼       实时·带不确定性
                                                  iLQGames + 逆博弈MLE
                                                  （显式求解 + 推断对手）

读图要点：第一刀切"规模"（agent 数 + 地图复杂度），决定走学习式还是求解式；求解式再按"对手代价是否已知"决定要不要套逆博弈推断层；"要不要实时 + 不确定性量化"则把你导向 LUCIDGames 式的在线递归。三条路的共同终点都是那个"所有 agent 相互最优的联合不动点"，区别只在怎么求、对手代价从哪来——这与前面对比表是同一套判据的两种呈现（表给维度、图给流程）。

前沿：Contingency Games——为多种意图同时备好计划¶

"预测即均衡"还有一个尚未解决的张力：对手意图本质**多模态**（§3.3 的多模态预测），可博弈求解通常给一个均衡（对应一种意图假设）。如果 ego 押注单一意图（如认定对手会让），猜错就危险；如果对所有意图都保守（认定对手都不让），又会过度退缩（回到 frozen robot）。解决这个张力的前沿工作是 Contingency Games（Peters, Bajcsy, Chiu, Fridovich-Keil, Laine, Ferranti, Alonso-Mora，arXiv:2304.05483，IEEE RA-L 2024，IROS 2024 宣读）。

核心思想（Contingency Games，转述）：对应变规划取博弈视角——机器人生成一组**条件于其他 agent 多种可能意图**的策略性运动计划。博弈由一个标量参数刻画：表示意图不确定性**将被解决的未来时刻**（branching time）。在线估计该参数，就得到一个随信念变化、同时预期未来会获得确定性的博弈运动规划器。现有不确定性下博弈规划的变体都是它的特例。

本质洞察（一个共享开头 + 多个分支结尾）：Contingency Games 的精妙在于它怎么处理"现在不知道、但未来会知道对手意图"这件事。它让 ego 的计划有一个**共享的开头**（在意图揭晓前，对所有可能意图都安全的动作）+ 多个**分支的结尾**（意图揭晓后，针对每种意图各自最优）。关键参数是 branching time（分支时刻）——意图大约何时会明朗。在那之前走共享开头（不押注、保持所有选项），之后按揭晓的意图走对应分支。这比两个极端都好：比"押注单一意图"（猜错危险）安全，比"对所有意图都保守"（frozen）高效——它在"揭晓前保持灵活、揭晓后果断"之间取得平衡。与本章的联系：它把 §3.3 的**多模态预测**（对手有多种可能意图）和 §3.4 的**预测即均衡**（博弈求解）缝合起来——不再是"预测多模态、规划押单模态"，而是"规划本身就为多模态备好分支"。这是"预测即均衡"在意图不确定下的自然延伸，也回应了 §3.4 边界一（依赖对手是博弈式的）和陷阱 2（对手模型可能错）——与其赌一个模型，不如为多个备好计划。

综合：一个完整的博弈式交互规划系统¶

把 G1-G3 学到的全部串起来，一个真实的博弈式交互规划系统长这样（这也是项目甲的最终形态，外加 G4 的安全层）。用伪代码展示在线运行时各模块如何协作——每个控制周期做四件事：推断对手、求解均衡、安全兜底、执行：

# 博弈式交互规划系统的在线主循环（每个控制周期 ~50ms）
# 串起 G3 推断 + G2 求解 + G4 安全 + §3.4 预测即均衡
def interactive_planning_loop():
    opp_belief = init_prior()          # 对手模型的先验（代价参数 + 理性层级 k）
    while driving:
        obs = perceive()               # 感知：获取对手最新观测轨迹

        # ① 推断对手（G3）：在线更新对手模型
        #    - 代价参数：LUCIDGames 的 UKF 递归更新（§3.1）
        #    - 理性层级 k：贝叶斯滤波更新（§3.2）
        opp_belief = update_opponent_model(opp_belief, obs)   # 逆博弈在线推断

        # ② 求解博弈均衡（G2）= 预测即均衡（§3.4）
        #    一次求解同时得到：ego 规划 + 他人预测（均衡的不同部分，自洽一致）
        #    用推断出的对手模型，内层调 iLQGames
        ego_plan, others_pred = solve_game(opp_belief, current_state)   # iLQGames

        # ③ 安全兜底（G4）：对手模型可能错（§3.4 陷阱2），用 CBF/可达性过滤
        #    把 ego_plan 投影到安全集，保证最坏情况硬安全
        safe_control = safety_filter(ego_plan, others_pred)   # CBF（G4）

        # ④ 执行第一步，滚动前进（MPC，G2 §2.2）
        execute(safe_control[0])

这个循环把三章的贡献编织在一起：

步骤	用什么	来自	解决什么
① 推断对手	逆博弈 UKF + 贝叶斯估 k	G3（§3.1、§3.2）	对手代价/层级未知
② 求解均衡	iLQGames（用推断的对手模型）	G2 + §3.4	预测规划一体化、消除 frozen robot
③ 安全兜底	CBF / 可达性滤波	G4（下一章）	对手模型出错时的硬安全
④ 滚动执行	MPC	G2 §2.2	用真实状态闭环、抗扰

上面是工程级框架。把它收成一个**能跑的最小系统**，更能看清三章如何在每个周期协作——下面这个简化版（对手用"趋向目标"模型代替完整 iLQGames，便于自包含运行）真实地跑通了"在线推断对手目标 → 博弈避让 → 到达"的闭环：

import numpy as np
dt, H = 0.3, 8                                       # H = 规划时域

def rollout_to_goal(x0, goal, steps):                # 某 agent 趋向目标的轨迹（代表其策略）
    x = x0.copy(); tr = [x.copy()]
    for k in range(steps):
        ux = 1.5*(goal[0]-x[0]) - 2.0*x[2]; uy = 1.5*(goal[1]-x[1]) - 2.0*x[3]
        x = np.array([x[0]+x[2]*dt, x[1]+x[3]*dt, x[2]+ux*dt, x[3]+uy*dt]); tr.append(x.copy())
    return np.array(tr)

def infer_opponent_goal(obs_traj):                   # ① 在线逆博弈：从对手轨迹反推目标
    x0 = obs_traj[0]; g = obs_traj[-1][:2].copy()    # 初值用最后观测位置
    for _ in range(30):                              # 梯度下降拟合"趋向目标"模型的目标参数
        err = rollout_to_goal(x0, g, len(obs_traj)-1)[:,:2] - obs_traj[:,:2]
        grad = np.array([(np.sum((rollout_to_goal(x0, g+np.eye(2)[j]*1e-4, len(obs_traj)-1)[:,:2]
                                   - obs_traj[:,:2])**2) - np.sum(err**2))/1e-4 for j in range(2)])
        g = g - 0.05*grad/(np.linalg.norm(grad)+1e-9)
    return g

def solve_game_ego(ego_state, ego_goal, opp_state, opp_goal):   # ② 博弈求解 = 预测即均衡
    opp_pred = rollout_to_goal(opp_state, opp_goal, H)           #   用推断的对手目标预测其轨迹
    x = ego_state.copy(); plan = [x.copy()]
    for k in range(H):
        ux = 1.5*(ego_goal[0]-x[0]) - 2.0*x[2]; uy = 1.5*(ego_goal[1]-x[1]) - 2.0*x[3]  # 趋向目标
        d = x[:2] - opp_pred[min(k,H)][:2]; dist = np.linalg.norm(d)+1e-6
        if dist < 1.5: ux += 2.0*d[0]/dist; uy += 2.0*d[1]/dist  # 避开对手预测轨迹
        x = np.array([x[0]+x[2]*dt, x[1]+x[3]*dt, x[2]+ux*dt, x[3]+uy*dt]); plan.append(x.copy())
    return np.array(plan)

# 主循环：每周期 推断 → 求解 → 执行第一步（MPC）
np.random.seed(3)                                                  # 固定随机种子，保证下表可复现
opp_true_goal = np.array([0., 4.]); ego_goal = np.array([4., 0.])   # 对手目标 ego 不知道，需推断
ego_state = np.array([-3.,0,1.,0]); opp_state = np.array([0.,-3,0,1.]); opp_history=[opp_state.copy()]
for t in range(10):
    opp_goal_est = infer_opponent_goal(np.array(opp_history)) if len(opp_history)>=3 \
                   else opp_state[:2]+np.array([0,2])        # ① 推断（冷启动先猜）
    ego_plan = solve_game_ego(ego_state, ego_goal, opp_state, opp_goal_est)  # ② 求解
    ego_state = ego_plan[1]                                  # ④ 执行第一步
    opp_state = rollout_to_goal(opp_state, opp_true_goal, 1)[1] + 0.02*np.random.randn(4)  # 对手实际行动
    opp_history.append(opp_state.copy())

跑出来，对手目标的在线推断误差随观测积累而递减，ego 顺利绕开对手到达目标：

时刻 t	推断对手目标	误差	ego 位置
2（刚启动、观测少）	(0.08, −0.15)	4.15	(−0.30, 0.00)
5	(0.03, 3.57)	0.43	(2.88, 0.05)
9（观测充分）	(−0.03, 3.99)	0.03	(4.26, −0.04)

闭环成功：在线推断对手目标（误差 4.15→0.03 递减）+ 博弈避让 + 各自到达。这就是把全章串起来的最小可运行系统——① infer_opponent_goal 是 §3.1 逆博弈的在线化（每周期用累积观测重新推断，正是 LUCIDGames 的思想）；② solve_game_ego 是 §3.4 预测即均衡（ego 规划用推断的对手目标预测其轨迹、并据此避让）；④ 只执行第一步、下周期用新状态重来，是 §2.2 的 MPC。注意 t=2 时误差大（4.15）——观测太少、对手目标还没看出来（呼应 §3.1 可识别性），但 ego 此时已基于"冷启动猜测"开始避让，随观测积累推断快速收敛。真实系统把 ② 换成完整 iLQGames、把避让换成 G4 的 CBF 硬约束，就是项目甲的最终形态。

本质洞察（三章是一条完整的因果链）：这个主循环揭示了 G1-G3（+G4）不是孤立的技术，而是一条**因果链**——每一环都为下一环扫清障碍。 G1 把"对手是决策者"理论化（否则连博弈都建不出来）；G2 把博弈求解实时化（否则进不了 50ms 的控制周期）；G3 把对手代价在线化（否则真实道路上对手未知、求解器没法用）；G4 把安全保证硬化（否则推断错了会出事）。抽掉任何一环，整个系统就垮：没有 G3 的推断，G2 的求解器在真实道路上是"盲"的；没有 §3.4 的"预测即均衡"，ego 会 frozen；没有 G4，推断错误会致命。这就是为什么这条 Part-G 主线要按 G1→G2→G3→G4 的顺序展开——它不是知识点的罗列，而是一个真实系统从"理论可行"到"道路可用"的完整建造过程。注意 ② 用了 ① 推断的对手模型——这正是"逆 = 在正向外面套推断"的系统级体现：推断（外）喂给求解（内），求解的质量取决于推断的质量，推断的更新依赖求解给出的预测。三者在每个周期里闭环迭代。

回望：Part-G 主线的本质¶

学到这里，值得退一步看看 Part-G（博弈规划）这条线到底在讲一个什么故事。表面上它是一串技术——HJI、耦合 Riccati、iLQGames、ALGAMES、逆博弈、Level-k、GameFormer。但底层，它在回答一个朴素却深刻的问题：当机器人身边的其他 agent 也是"会思考、会反应、有自己目的"的决策者时，机器人该怎么规划？

传统运动规划把环境当**静态或被动**的——障碍不会反应、不会有目的。 Part-G 的全部内容，都是在拆掉这个假设、正视"对手是决策者"这一事实带来的连锁后果： - 一旦承认对手会反应，规划就成了**博弈**而非单人优化（G1 的认知跨越一）； - 博弈要能实时求解才能上车（G2）； - 求解需要对手的代价，而它**未知**、得从行为**推断**（G3 §3.1-§3.3，认知跨越三）； - 推断出对手后，"预测"和"规划"其实是**同一个博弈均衡**的两面（G3 §3.4，认知跨越二）； - 而推断可能错，所以还需**安全兜底**（G4）。

本质洞察（Part-G = 把"他者"正确地放进规划）：如果要用一句话概括整个 Part-G，那就是——它教机器人把身边的人/车当"人"而非"障碍"来对待。把对手当障碍（静态、被动）→ 传统规划 → frozen robot、过度保守、交互失败。把对手当决策者（会反应、有目的、有限理性）→ 博弈规划 → 能试探、能协调、能在密集交互中顺畅通行。这个转变贯穿四章：G1 在理论上承认"他者是决策者"，G2 让这个承认能实时落地，G3 让机器人能"读懂"他者（推断代价 + 有界理性），G4 在读错时兜底。一句话：Part-G 的本质，是把"他者的能动性"正确地建模进机器人的决策——这是机器人从"在空旷世界里规划"走向"在人类世界里共存"的认知基础。 自动驾驶、人机协作、多机器人系统，凡是机器人要和其他智能体共享空间的地方，都需要这一课。

⚠️ 常见陷阱¶

陷阱 1（概念误区）：以为"预测即均衡"只是把 predictor 和 planner 拼在一起 - 错误描述：觉得"预测即均衡"就是工程上让 predictor 和 planner 多迭代几次、互相喂数据。 - 现象/后果：仍然维护两个分离的模块（predictor、planner），用迭代打补丁，prediction-planning 不一致只是缓解、未根除；frozen robot 在困难场景仍出现。 - 根本原因："预测即均衡"是**架构层面**的统一——不存在独立的 predictor，他人的预测就是同一个博弈均衡的一部分解。这与"两个模块迭代"有本质区别：前者在一个均衡里自洽，后者是两个目标不同的模块勉强对齐。 - 正确做法：用真正的博弈求解器（G2）或端到端博弈模型（GameFormer）一次求出所有 agent 的联合解，而非维护分离模块。检验方法：问"我的系统里，他人的预测和 ego 的规划是同一个优化/均衡的解吗？"——是，才是真正的一体化。

陷阱 2（思维陷阱）：忽略"预测即均衡"对对手模型正确性的依赖 - 错误描述：采用了博弈一体化框架，就以为 frozen robot 一定消失、交互一定正确。 - 现象/后果：如果对手模型错了（代价设错、或假设 Nash 但对手是 Level-1），均衡里"他人的最优响应"是错的——ego 以为探入对手会让，对手却不让（因为真实对手模型不同），引发危险。 - 根本原因："预测即均衡"消除的是**架构层面**的不一致，但均衡的正确性仍依赖**对手模型正确**。错误的对手代价/理性假设会产生错误的均衡，进而错误的预测和规划。 - 正确做法：博弈一体化框架必须配合**正确的对手模型**——用 §3.1 逆博弈在线推断对手代价、§3.2 Level-k 建模有界理性，让均衡基于贴合实际的对手模型。一体化架构 + 准确对手模型，缺一不可。

"预测即均衡"的三个边界¶

"预测即均衡"很强大，但不是万能的。诚实地标出它的三个边界，比把它当银弹更有用——这也回应了本节练习 3 的反思。

边界一：依赖对手是"博弈式"的。 "预测即均衡"假设所有 agent 都在玩某种博弈（各有代价、相互最优响应）。但有些行为根本不是博弈式的——分心的司机（没在优化任何代价）、突发机械故障（失控）、不理性的行人（凭直觉乱走）。对这些 agent，"它的预测=它的最优响应"这个前提不成立，均衡求解会基于错误的假设。应对：用有界理性模型（§3.2 MaxEnt 的随机性能部分容纳"非最优"行为），并始终用 G4 的安全层兜底"完全意料之外"的行为。

边界二：依赖对手模型的在线可推断性。 均衡的正确性依赖对手模型正确（陷阱 2），而对手模型靠 §3.1/§3.2 在线推断。但推断需要观测信息量（§3.1 可识别性）——交互刚开始、观测还少时，对手模型不确定性大，此时的均衡求解是"基于猜测"的。应对：像 LUCIDGames 那样**显式量化对手模型的不确定性**，不确定时让 ego 更保守（不确定性椭圆约束）；随观测增多再收紧。

边界三：计算与多均衡。 博弈一体化把预测和规划合成一次求解，但这次求解可能很贵（尤其多 agent + 在线推断对手），且博弈可能有多个均衡（G2 §2.3 的均衡选择问题）——选错均衡，预测和规划虽自洽却可能不是期望的那个。应对：GameFormer 用学习摊销计算（§3.3）、用初始化/灵敏度引导均衡选择（G2 §2.6）。

本质洞察（一体化消除的是"架构病"，不是"建模难"）：把这三个边界放在一起看，会发现"预测即均衡"精确地解决了一类问题、又精确地留下了另一类。它**消除**的是**架构层面**的病——先预测后规划的单向信息流、prediction-planning 不一致、frozen robot。这类病是架构造成的，换架构（一体化）就根治。它**没有消除**的是**建模层面**的难——对手是不是博弈式的、对手模型准不准、选哪个均衡。这类难是问题本身固有的，换架构不会消失，只能用更好的对手模型（G3）、不确定性量化（LUCIDGames）、安全兜底（G4）去缓解。一句话："预测即均衡"把"架构病"治好了，但把"建模难"留给了 G3 的推断和 G4 的安全——这正是为什么 Part-G 需要四章，而非一章。 认清这个边界，你才不会把它当银弹，也才知道剩下的难点在哪、该用哪一章的工具去攻。

练习¶

（思考题·架构对比） 详细对比"先预测后规划"流水线与"预测即均衡"一体化两种架构。回答：(a) 为什么前者会产生 prediction-planning 不一致和 frozen robot（从信息流的单向 vs 双向角度）；(b) 后者如何从根上消除（从"他人的预测是否考虑 ego 影响"角度）；(c) 工程上给前者打的补丁（迭代、喂候选计划）为什么治标不治本。
（设计题·连接全章） 设计一个完整的博弈式交互规划系统，要求消除 frozen robot 且处理未知对手：(a) 用什么求解器做"预测即均衡"的内核（G2 的 iLQGames？GameFormer？）；(b) 如何在线获得对手模型（§3.1 逆博弈推断代价？§3.2 在线估计 k？）；(c) 如何兜底安全（G4 的 CBF？）。论证各模块如何协作。
（思考题·范式反思） "预测即均衡"假设所有 agent（含人类）都在玩某种博弈。但有些 agent 行为可能根本不是博弈式的（如分心司机、突发故障、不理性行人）。这种情况下"预测即均衡"会怎样？你会如何让系统对"非博弈式"的意外行为保持鲁棒（提示：结合 §3.2 有界理性、§前沿的意图不确定、G4 安全兜底）？

本章常见误解汇总¶

把全章四节的陷阱与易错点收口成一张表，按"误解 → 正解"对照。

误解	正解	出处
直接训练神经网络预测器就能绕过"推断代价"	黑箱预测器不考虑 ego 影响（frozen robot）、不可解释外推；逆博弈推断的是紧凑可解释的代价（意图）	§3.1
观测一小段轨迹就能唯一反推代价	可识别性取决于观测信息量；短观测下参数欠定，需长/多样观测或贝叶斯后验	§3.1
逆博弈外层可用固定大学习率 + 有限差分梯度	易发散（梯度尺度大）；需梯度归一化 + 小学习率，或用隐函数定理解析梯度	§3.1
观测轨迹一定是 Nash 均衡	人类是有界理性（Level-k），用 Nash 解释会推出扭曲代价；需 MaxEnt/Level-k 逆博弈	§3.1、§3.2
Peters 2021 需要完整、无噪观测	标题即"Noise-Corrupted Partial"——专门处理带噪部分观测，把未观测量与代价联合估计	§3.1
Level-k 随 k 增大收敛到 Nash，故 k 越高越好	Level-k 价值在 k 小（截断递归）；真实人类 k≈1.5；高 k 偏离有界理性、未必收敛	§3.2
Level-k 递归中"我的层级"="对手层级"	我是 Level-k = 对（假设的）Level-(k-1) 对手最优响应；须分清自己层级与假设对手层级	§3.2
Level-k 和 Cognitive Hierarchy 是同一模型	Level-k：对手恰好低一层；CH：对手是更浅各层的泊松混合。二者最佳响应对象不同	§3.2
有界理性只能用 Level-k 建模	还有 MaxEnt（softmax 随机性）；Level-k 是"想得浅"、MaxEnt 是"选得随机"，两个互补侧面	§3.2
强交互场景用 IRL（把他人当固定）就够	强交互需逆博弈（联合推断+Nash 耦合）；IRL 把他人当固定会学出"他人不反应"的错误模型	§3.1
逆博弈总假设 agent 共享彼此目标知识	那是 level-1 推断；认知错位时需 Level-2 逆博弈（推断"对手以为别人想要什么"）	§3.2
GameFormer 求解了 Nash 均衡	它是学习逼近、非求解；无 KKT 保证；是"博弈式归纳偏置的预测器"	§3.3
GameFormer 的 decoder 层数越多越准	层数=认知深度，真实认知深度低（k≈1-2）；过多层收益递减、训练难	§3.3
层级 decoder 中 Level-k 看同层	Level-k 须对上一层（k-1）响应；看同层破坏因果、引入循环依赖	§3.3
GameFormer 输出单条确定轨迹	输出多模态（M 条候选 + 概率）；对手意图本质不确定，单条会是谁都不走的"平均"	§3.3
层级 decoder 架构本身就保证"最佳响应"语义	架构给骨架、训练损失给语义；论文的"响应上一层"是损失引导的软倾向，非硬约束	§3.3
"预测即均衡"=把 predictor 和 planner 拼起来迭代	是架构统一——他人预测就是同一博弈均衡的一部分解，非两模块对齐	§3.4
用了博弈一体化框架，frozen robot 必消失	还依赖对手模型正确；错误对手模型→错误均衡→错误预测规划	§3.4
"预测即均衡"是万能银弹	它治"架构病"（frozen robot），但留"建模难"（对手是否博弈式、模型准否、多均衡）给 G3/G4	§3.4

本章小结¶

本章兑现了 G1 §1.1 那"三次认知跨越"的第三跨——从"代价已知"到"代价需推断"，并把前两章的博弈求解器升级为完整的"推断 + 预测 + 规划"一体化框架。

主线是 G2 的正向求解器如何变成 G3 的内层引擎： §3.1 逆博弈把"从行为反推代价"形式化为最大似然 (3.1)(3.2)，核心是用隐函数定理 (3.4) 让正向求解器可微、支持梯度下降——这是 G2 §2.6 灵敏度的"对参数版"； §3.2 Level-k 用有界理性模型 (3.5)(3.6) 替代完美 Nash，承认人类只想有限步（真实 k≈1.5），每层是一次正向最优响应； §3.3 GameFormer 把 Level-k 递归"编译"进 Transformer 的层级 decoder，端到端学习隐式逼近 Nash，拿下 Waymo/nuPlan SOTA——decoder 第 k 层 = Level-k； §3.4 把前三者收束成"预测即均衡"范式——预测=对手最优响应、规划=ego 最优响应、两者同时求解，从根上消除"先预测后规划"管线的 frozen robot。

贯穿全章的核心洞察：逆 = 在正向外面套一层推断。逆博弈在正向求解外套参数优化、Level-k 是正向求解的有限递归、GameFormer 是正向求解的神经网络化身——它们都以 G2 的"给定代价求均衡"为内核，在外面套上"推断对手"的不同机制。至此 G1（理论）→ G2（求解）→ G3（推断 + 一体化）合龙：博弈规划从"理论最优但算不动"，到"实时求解"，再到"对手未知也能推断、预测规划自洽"——frozen robot 这个贯穿三章的幽灵被彻底驱散。

术语速查表¶

术语	一句话定义
正向博弈	给定代价参数 θ，求 Nash/GNE 均衡轨迹 x*(θ)（G2 做的事）
逆博弈	给定观测轨迹，反推代价参数 θ（方向与正向相反）
最大似然逆博弈	\(\hat\theta=\arg\min_\theta\sum_k\\|x_k^*(\theta)-\hat x_k\\|_\Sigma^2\)，找使观测最可能的代价
隐函数定理（对参数）	\(\partial x^/\partial\theta=-(\partial F/\partial x^)^{-1}(\partial F/\partial\theta)\)，让正向解可微
可微博弈	把 Nash 求解器当可微层，对 KKT 隐式求导实现反传
可识别性	代价参数能否被观测唯一确定，取决于观测信息量
LUCIDGames	用 UKF 在线递归估计对手代价参数的逆博弈（含不确定性，40Hz MPC）
UKF（无迹卡尔曼滤波）	把对手代价参数当隐藏状态、递归更新其贝叶斯估计的滤波器
Level-0	不做策略推理的规则策略（IDM/MOBIL/匀速）
Level-k	对 Level-(k-1) 的最佳响应；想 k 步就停
Cognitive Hierarchy (CH)	Level-k 对 Level-0…(k-1) 的泊松混合做最佳响应
MaxEnt 博弈	用 softmax Bellman 建模有界理性（选择带随机性），正/逆求解统一
有界理性	人类策略推理只到有限层（真实 k≈1.5），非无限递归到 Nash
Level-2 逆博弈	不仅推断各 agent 目标，还推断"它对别人目标的估计"（认知错位）
GameFormer	把 Level-k 嵌入 Transformer 层级 decoder 的端到端预测-规划模型
层级 decoder	decoder 第 k 层 = Level-k，对上一层预测做交叉注意力（最佳响应）
多模态预测	每 agent 输出 M 条候选轨迹 + 概率，表达对手意图的本质不确定
隐式博弈	神经网络学习逼近均衡（GameFormer），对比显式求解（iLQGames）
预测即均衡	他人预测=均衡中其最优响应、ego 规划=均衡中其最优策略、同时求解
prediction-planning 不一致	先预测后规划管线中，预测未考虑 ego 影响导致的自相矛盾
分支时刻（branching time）	Contingency Games 的标量参数：意图不确定将被解决的未来时刻，之前走共享开头、之后按揭晓意图分支
心智理论（Theory of Mind, ToM）	从他人行为推断其信念/欲望/意图的能力；逆博弈是它的数学化（代价=机器版"意图"），Level-k 的递归信念推理正是其核心

知识点总表¶

节	知识点	难度	一句话
§3.1	逆博弈形式化	⭐⭐⭐ ★	MLE (3.1)(3.2)：从观测轨迹反推代价参数
§3.1	隐函数定理（对参数）	⭐⭐⭐	(3.4) 让正向求解器可微，解析梯度 vs 有限差分（差异 1.6e-10）
§3.1	可识别性	⭐⭐	观测信息量决定参数能否唯一反推（误差 5.48→0.019）
§3.1	逆博弈 vs IRL vs 模仿学习	⭐⭐	三种"从行为学习"，按交互耦合强度选
§3.1	LUCIDGames（在线逆博弈）	⭐⭐⭐	UKF 递归估计对手代价 + 不确定性，40Hz MPC
§3.2	Level-k 递归	⭐⭐⭐	(3.5) 对低一层最佳响应，想 k 步就停
§3.2	Cognitive Hierarchy	⭐⭐⭐	(3.6) 泊松混合，真实 τ≈1.5（81% 在 Level 0-2）
§3.2	贝叶斯在线估计 k	⭐⭐	滤波推断对手层级，收敛到真实 Level
§3.2	从数据估计 τ	⭐⭐	泊松 MLE 闭式解 = 推断层级的样本均值，需按域重估
§3.2	MaxEnt 博弈	⭐⭐⭐	softmax 建模有界理性（选得随机），正逆统一
§3.2	Level-2 逆博弈（前沿）	⭐⭐⭐⭐	推断"对手以为别人想要什么"（认知错位）
§3.3	GameFormer 架构	⭐⭐⭐ ★	Level-k 嵌入 Transformer 层级 decoder
§3.3	层级 decoder 机制	⭐⭐⭐	交叉注意力实现逐层最佳响应（decoder 第 k 层=Level-k）
§3.3	多模态预测	⭐⭐	M 条候选轨迹+概率，表达意图不确定
§3.3	隐式 vs 显式博弈	⭐⭐⭐	学习逼近（GameFormer）vs 求解（iLQGames），九维对比
§3.4	预测即均衡	⭐⭐	联合不动点：预测=对手最优响应、规划=ego 最优响应
§3.4	frozen robot 最终解法	⭐⭐	一个 argmin 含不含 u_e，就是全部差别
§3.4	三种实现路线	⭐⭐	显式求解 / 在线逆博弈 / 端到端，按场景选

累积项目：本章新增模块¶

项目	本章新增模块	内容	与前章/后续的关系
甲（自动驾驶交互博弈规划器）	逆博弈推断层	在 G2 的 iLQGames 求解器外套一层逆博弈 MLE：从对手观测轨迹在线推断其代价参数（目标、激进度、安全距离权重），再用推断的代价做"预测即均衡"的交互规划	以 G2 的 iLQGames 为内层正向引擎；G4 将在其上加 CBF 安全层兜底——至此项目甲集齐"推断→博弈规划→安全兜底"三层

本章项目甲的新增模块（§3.1 练习 1）把 G2 的"假设对手代价已知"升级为"从对手行为在线推断代价"——这是从"仿真能用"到"真实道路能用"的关键一跃。配套的 Level-k 实现（§3.2 练习 1）和 GameFormer 精读（§3.3 练习 1）提供了有界理性建模与端到端范式的对照视角。至此项目甲的求解-推断闭环完成，只差 G4 的安全证书层。

延伸阅读¶

按主题与难度标注，括号内为定位。

逆博弈奠基（本章地基，必读） - Peters, Fridovich-Keil, Rubies-Royo, Tomlin, Stachniss, "Inferring Objectives in Continuous Dynamic Games from Noise-Corrupted Partial State Observations," RSS 2021（⭐⭐⭐⭐ 逆博弈范式奠基，可微 iLQGames + MLE） - Peters, Rubies-Royo, Tomlin, Ferranti, Alonso-Mora, Stachniss, Fridovich-Keil, "Online and offline learning of player objectives from partial observations in dynamic games," IJRR 2023（⭐⭐⭐⭐ RSS 2021 的扩展版，DOI 10.1177/02783649231182453） - Sadigh, Sastry, Seshia, Dragan, "Planning for Autonomous Cars that Leverage Effects on Human Actions," RSS 2016（⭐⭐⭐ 推断对手代价的先声，Stackelberg + IRL，见 G2 §2.1）

在线逆博弈与有界理性（进阶） - Le Cleac'h, Schwager, Manchester, "LUCIDGames: Online Unscented Inverse Dynamic Games for Adaptive Trajectory Prediction and Planning," RAL 2021（⭐⭐⭐⭐ UKF 在博弈参数空间在线推断 + iLQGames） - Mehr, Wang, Bhatt, Schwager, "Maximum-Entropy Multi-Agent Dynamic Games: Forward and Inverse Solutions," IEEE T-RO 2023, 39(3):1801-1815（⭐⭐⭐⭐ 最大熵处理有界理性，正/逆求解统一，DOI 10.1109/TRO.2022.3232300） - Camerer, Ho, Chong, "A Cognitive Hierarchy Model of Games," QJE 2004, 119(3):861-898（⭐⭐⭐⭐ Level-k/CH 的行为经济学奠基，τ≈1.5，DOI 10.1162/0033553041502225）

Level-k 驾驶（进阶） - Li, Oyler, Zhang, Yildiz, Kolmanovsky, Girard, "Game-Theoretic Modeling of Driver and Vehicle Interactions for Verification and Validation of Autonomous Vehicle Control Systems," IEEE T-CST 2018, 26(5):1782–1797；及 Ran Tian 等的 T-ITS 后续（⭐⭐⭐ Level-k 引入自动驾驶交互）

端到端博弈学习（产业前沿） - Huang, Liu, Lv, "GameFormer: Game-theoretic Modeling and Learning of Transformer-based Interactive Prediction and Planning for Autonomous Driving," ICCV 2023 Oral, pp.3903-3913（⭐⭐⭐⭐ Level-k 嵌入 Transformer，Waymo/nuPlan SOTA，arXiv:2303.05760）

2024–2026 前沿（选读） - Liu, Peters, Alonso-Mora, Topcu, Fridovich-Keil, "Auto-Encoding Bayesian Inverse Games," WAFR 2024（⭐⭐⭐⭐ VAE + 可微 Nash 做参数后验，量化不确定性，arXiv:2402.08902） - Khan, Li, Fridovich-Keil, "What Do Agents Think Others Would Do? Level-2 Inverse Games for Inferring Agents' Estimates of Others' Objectives," arXiv:2508.03824（⭐⭐⭐⭐ Level-2 逆博弈，推断 agent 对彼此目标的估计——超越 level-1 假设） - Sun et al., "Mixed-Strategy Nash for Crowd Navigation (BRNE)," IJRR 2025（⭐⭐⭐ 贝叶斯迭代求混合策略 NE，已部署 Unitree 四足社交导航） - Peters, Bajcsy, Chiu, Fridovich-Keil, Laine, Ferranti, Alonso-Mora, "Contingency Games for Multi-Agent Interaction," IEEE RA-L 2024（IROS 2024 宣读）（⭐⭐⭐⭐ 博弈 + 分支规划，为对手多种意图同时备计划，arXiv:2304.05483）

认知科学背景（选读，理解 Level-k / 逆博弈的认知根源） - 心智理论（Theory of Mind）相关综述（⭐⭐ 人类推断他人信念/欲望/意图的能力，是 Level-k 递归信念推理和逆博弈"从行为读意图"的认知对应） - Camerer, Behavioral Game Theory, Princeton University Press 2003（⭐⭐⭐⭐ 行为博弈论专著，Level-k/CH 的系统来源，理解人类为何非完美 Nash）

开源工具（动手） - MCZhi/GameFormer（⭐⭐⭐ GameFormer 官方代码，WOMD 交互预测）；MCZhi/GameFormer-Planner（nuPlan 闭环规划框架） - lassepe/GameInference.jl（⭐⭐⭐ 粒子滤波在博弈参数空间在线推断，Julia） - forrestlaine/TensorGames.jl（⭐⭐ 混合策略 Nash via MCP，支持自动微分/ChainRulesCore，Julia） - JuliaGameTheoreticPlanning/MixedComplementarityProblems.jl（⭐⭐⭐ MCP 参数化求解 + 对参数隐式微分）

本章与后续章节的关系¶

关系	章节	衔接点
直接前置（被本章用）	G2 实时博弈求解器	逆博弈的内层引擎是 G2 的 iLQGames；隐函数定理 (3.4) 是 G2 §2.6 SE-IBR 灵敏度的"对参数版"
直接前置	G1 微分博弈理论	本章兑现 G1 §1.1 第三次认知跨越（代价需推断）+ 第二跨（预测即均衡）；§3.4 解决 G1 §1.1 的 frozen robot
直接后续	G4 安全证书与 MARL	推断的对手模型可能错（§3.4 陷阱 2），需 CBF 安全层兜底；项目甲在本章逆博弈层上加 G4 安全层
跨专题对照	U 线预测 / 行为建模	传统"先预测后规划"管线 vs 本章"预测即均衡"；GameFormer 是预测领域的博弈式方法
跨专题对照	模仿学习 / IRL	逆博弈 = 博弈版 IRL（§3.1 与 IRL 的关系）；GameFormer 用模仿学习训练
工具复用	深度学习 / Transformer	§3.3 GameFormer 的 encoder-decoder、交叉注意力
工具复用	贝叶斯推断	§3.2 在线估计对手 k；前沿的贝叶斯逆博弈（参数后验）
跨专题对照	不确定性规划（Part-F）	本章对手意图不确定 ↔ 机会约束/风险敏感；Contingency Games 是博弈版分支规划
跨专题对照	POMDP / 信念空间规划	在线估计对手代价/层级 = 维护对手"信念"；Contingency Games 的 branching time ↔ 信念更新时刻

一条主线值得强调：本章是"对手模型"这条暗线在 Part-G 的高潮。 G1-G2 假设对手模型已知，本章（G3）把它**推断出来**，G4 则在它**出错时兜底**。而对手模型的"不确定性"——推断不准、意图多模态、认知错位——又把本章和不确定性规划（Part-F 的机会约束、风险敏感、POMDP）连了起来：Contingency Games（§3.4 前沿）正是博弈与分支规划的交汇，它的"为多种意图备分支"本质上是在信念空间里规划。所以读完本章再回看 Part-F，会发现"不确定性"在博弈语境下有了新的来源（对手的能动性带来的不确定），处理它的工具（分支、风险度量、信念更新）则是相通的。

🔧 故障排查手册¶

把本章实践中最常撞的坑整理成"症状 → 可能原因 → 排查步骤 → 相关节"。

症状	可能原因	排查步骤	节
逆博弈反推的代价与真实差很远 / 每次跑结果不同	观测信息量不足，参数欠定	1. 增加观测长度/多样性 2. 减少待估参数维度 3. 改用贝叶斯方法给后验	§3.1
逆博弈外层梯度下降发散（loss 爆炸/NaN）	有限差分梯度尺度大 + 固定大学习率	1. 梯度归一化 + 减小学习率 2. 改用隐函数定理解析梯度 3. 对内层雅可比加正则化	§3.1
逆博弈拟合了观测但预测新场景很差	假设观测来自 Nash，但对手实为有界理性	1. 检查对手是否 Nash 行为 2. 改用 MaxEnt/Level-k 逆博弈	§3.1、§3.2
Level-k 建模的对手行为过于"精明"，与人类失配	k 取太高，偏离真实有界理性	1. 用小 k（1-2）2. 在线估计对手实际 k 3. 对照 τ≈1.5	§3.2
Level-k 递归行为层级错乱	混淆"自己层级"与"假设对手层级"，或 Level-0 设错	1. 严格按 (3.5) 实现 2. 单独验证每层 3. 检查 Level-0 规则合理性	§3.2
GameFormer 输出不满足均衡最优性	误以为它求解 Nash，实为学习逼近	1. 把它当博弈式预测器 2. 需保证时用 iLQGames 或加安全滤波	§3.3
GameFormer 加 decoder 层数后准确率下降	层数过多、过拟合、偏离真实认知深度	1. 验证集扫层数取拐点 2. 用少数几层（对应低 Level）	§3.3
多模态预测的概率退化（全压到一个模态）	模态坍缩（mode collapse），训练不充分或缺多样性损失	1. 检查多模态损失/winner-take-all 设计 2. 确认各 modality query 区分	§3.3
在线估计对手 k 频繁跳变、不稳定	单步观测噪声大，未累积足够步	1. 累积多步再下结论 2. 后验加平滑/先验 3. 提高动作似然模型质量	§3.2
估计的 τ 被个别极端样本带偏 / 不稳	层级样本太少或不够多样	1. 增样本量与多样性 2. 加弱先验做正则（贝叶斯 τ 估计）3. 以趋势而非精确值为准	§3.2
LUCIDGames 的 UKF 估计发散/协方差爆炸	内层博弈求解不稳、UKF 调参不当（过程/观测噪声）	1. 稳定内层 iLQGames 2. 调 UKF 噪声协方差 3. 限制参数范围	§3.1
博弈一体化框架仍出现 frozen robot	对手模型错误（代价/理性假设不对）	1. 检查对手模型 2. 用逆博弈在线推断代价 3. 用 Level-k 建模有界理性	§3.4
ego 对意外行为（分心/故障司机）反应不当	对手非博弈式，超出"预测即均衡"假设	1. 用 MaxEnt 容纳非最优 2. 必须配 G4 安全层兜底	§3.4

API 速查表¶

本章涉及的核心接口与函数（按参考实现/最小示例，具体以各仓库当前版本为准）。

逆博弈 MLE（§3.1）

接口	签名 / 说明
`forward_game(theta, x0)`	正向博弈：给定代价参数 θ，rollout 均衡轨迹（真实工程中=调 G2 的 iLQGames）
`ilqgames(theta, x0, iters)`	正向内层：真正的 iLQGames（反向 Riccati + 前向 rollout），逆博弈的内层引擎
`loss(theta)`	(3.2) 的轨迹偏差 \(\sum_k\\|x_k^*(\theta)-\hat x_k\\|^2\)
`grad(theta)`	代价对参数的梯度（有限差分 ≈ 隐函数定理 (3.4)）
隐函数定理梯度	\(\partial x^/\partial\theta=-(\partial F/\partial x^)^{-1}(\partial F/\partial\theta)\)（解析、稳、快；`dF_du` 复用正向 KKT 雅可比）
`inverse(Tobs)`	可识别性实验：给定观测长度返回反推误差

Level-k（§3.2）

接口	签名 / 说明
`best_response_ego(a_opp)`	对给定对手策略求 ego 最优响应（= 一次正向求解）
Level-k 递归	`pi_k = best_response(pi_{k-1})`，从 Level-0 规则递归 k 次
CH 泊松混合	\(P(\text{level}=k)=\tau^k e^{-\tau}/k!\)，τ≈1.5
`likelihood(obs_action, k)`	贝叶斯估 k 的似然：对手为 Level-k 时该动作的概率
在线估计 k	`posterior ∝ likelihood × prior`，每观测一步贝叶斯更新
估计 τ（群体）	泊松 MLE：\(\hat\tau\) = 推断层级的样本均值（`minimize_scalar` 数值解与之一致）
MaxEnt 策略	softmax Bellman，越优动作概率越高（有界理性的随机性）

GameFormer（§3.3）

接口	签名 / 说明
`MCZhi/GameFormer`	官方代码（WOMD 交互预测）；`GameFormer-Planner`（nuPlan 闭环）
Encoder	Transformer 编码 HD 地图 + 多 agent 历史 → context tokens
`cross_attention(q, k, v)`	缩放点积注意力，`attn[i,j]`=agent i 关注 j 的程度
`masked_attention(q, k, v, mask)`	带 mask 的注意力，处理可变 agent 数（padding 位打 −∞）
`GameFormerDecoderLayer.forward(prev_preds, context)`	一层 decoder：对上一层预测+context 做交叉注意力精化
层级 Decoder	第 k 层对第 (k-1) 层预测 + context 做交叉注意力（Level-k 最佳响应）
`MultiModalDecoder.forward(ctx)`	多模态：M 个 modality query → M 条候选轨迹 + 概率（softmax）
输出	所有 agent 的多模态联合轨迹（近似 Nash）

逆博弈/可微博弈生态（Julia）

接口	说明
`GameInference.jl`	粒子滤波在线推断对手目标
`TensorGames.jl`	混合策略 Nash via MCP，支持自动微分
`MixedComplementarityProblems.jl`	MCP 参数化求解 + 对参数隐式微分（隐函数定理的 Julia 实现）

研究实践建议¶

给新手（从最小逆博弈实验建立直觉）。 最快上手路径：先跑通本章 §3.1 的最小逆博弈 MLE（几十行 NumPy，从带噪轨迹反推目标点），亲手观察"观测越长、参数越可识别"；再用 iLQGames.jl + 逆博弈把内层换成真正的博弈求解器（§3.1 练习 1）；然后在 highway-env 实现 Level-k（§3.2 练习 1），对比不同层级的变道行为，体会有界理性；最后精读 GameFormer 论文 + 跑官方代码，理解端到端范式。 "先跑通最小逆博弈、再换真实求解器、再做 Level-k、最后啃 GameFormer"这个顺序，比一上来读论文高效。论文入门从 Peters RSS 2021（逆博弈最清晰的奠基）开始。

给有经验者（往前沿与产业落地走）。 本章方法有三个活跃前沿：其一，不确定性量化——逆博弈的 MLE 只给点估计，可识别性差时不可靠；贝叶斯逆博弈（Auto-Encoding Bayesian、WAFR 2024）给参数后验，是重要方向。其二，超越 level-1 假设——标准逆博弈假设 agent 共享彼此目标知识（level-1），但真实场景 agent 对彼此的估计可能错位；Level-2 逆博弈（推断"agent 对彼此目标的估计"）是新兴课题。其三，端到端与可解释的结合——GameFormer 强在可扩展、弱在可解释/保证；iLQGames 反之。如何结合（如 GameFormer 粗预测 + iLQGames 精细安全交互、或用博弈均衡数据约束/训练 GameFormer）是规格开放问题，也是产业落地的关键。产业落地上，GameFormer Planner 在 nuPlan 上的闭环框架值得吃透——它是"预测即均衡"范式产业化的代表。

动手复现指南¶

论文解读的终点是动手复现。这里给一份从易到难的复现清单，每项都标注预期结果（来自本章实跑的 demo），方便你验证自己的实现是否正确。

第 1 级（几十行 NumPy，1-2 小时）——建立直觉。 - 逆博弈 MLE：实现"双积分器趋向目标"的正向模型 + 梯度下降反推目标点。预期：从带噪轨迹反推 4 个目标参数，误差 < 0.02（本章 demo 为 0.0186）。 - 隐函数定理梯度：对一个 2 玩家 LQ 博弈，用 (3.4) 解析算 ∂x*/∂θ，与有限差分对比。预期：差异 < 1e-6（本章为 1.6e-10）。 - 可识别性曲线：固定真实参数，扫观测长度 1→15，画反推误差曲线。预期：误差单调下降近两个数量级（本章 5.48→0.019）。

第 2 级（含 scipy 优化，半天）——核心机制。 - Level-k 递归：实现 Level-0（匀速）/Level-1/Level-2，用 best_response 递归。预期：汇入场景下三层终点位置递增（本章 25→39.75→41.89，确切值随优化器设置略变，趋势稳健）。 - 贝叶斯在线估 k：维护对手 k 的后验，逐步观测更新。预期：对手实为 Level-1 时，后验收敛到 Level-1（中间可有噪声波动）。 - MaxEnt softmax：实现 Boltzmann 策略，扫温度 T 看分布从确定性到随机；逆向从频率估 T。预期：T̂ 接近真实（本章 0.54 vs 0.5）。

第 3 级（接真实求解器 / 神经网络，1-2 天）——完整方法。 - 逆博弈接 iLQGames：把第 1 级的玩具正向换成真正的 iLQGames（反向 Riccati）。预期：从两车交互轨迹反推双方目标，误差 < 0.05（本章 0.019）。 - GameFormer 层级 decoder：用 PyTorch 实现交叉注意力 + 层级 decoder，在 Waymo 子集上训练。预期：复现论文交互预测指标量级；消融层级结构后联合预测一致性下降。 - 端到端最小系统：串起在线推断 + 博弈求解 + MPC。预期：在线推断对手目标误差随观测递减、ego 避让到达（本章误差 4.15→0.03）。

复现要点（避坑）：其一，逆博弈外层优化务必梯度归一化 + 小学习率（否则发散，§3.1 陷阱 2）；其二，Level-k 严格分清"自己层级"与"假设对手层级"（§3.2 陷阱 2）；其三，GameFormer 用少数几层 decoder（对应低 Level，§3.3 陷阱 2），别堆太多；其四，所有带数值表的含随机性 demo 都已固定随机种子（逆博弈 MLE 用 seed(1)、接 iLQGames 用 seed(0)、贝叶斯估 k 用 seed(2)、多模态用 seed(6)、闭环系统用 seed(3)），便于逐位复现表中数字。本章所有 demo 都是纯 NumPy（除 GameFormer 训练需 PyTorch），无需 GPU，普通笔记本即可跑通第 1、2 级。

关于"数字对不上"的可重复性说明。 即便固定了随机种子，仍有两类 demo 的确切数字可能与本章略有出入——这本身是论文复现中极常见的现象，值得专门点出：其一，依赖数值优化器的 demo（如 §3.2 Level-2 的 best_response 用 Nelder-Mead 优化含避撞阶跃惩罚的非光滑代价）：这类问题有多个局部最优，且对 maxiter、容差、SciPy 版本敏感，确切终点会在一个区间内浮动（Level-2 终点在 maxiter 2000 与 5000 下分别约 41.89 与 43.56）。验证时应以**定性趋势**（层级越高终点越远、误差随观测递减）为准，而非某个精确小数。其二，随机权重的示意 demo（如 §3.3 的层级 decoder、多模态 decoder 用随机矩阵代替习得权重）：它们演示的是**数据流与张量形状**，输出数字本身不承载语义；固定种子只为让讲解与表格对得上，换一组权重数字会变，但结论（注意力不泄漏到 padding、多模态概率和为 1）不变。一句话：复现的金标准是"趋势、量级、结论"可重现，而非每一位小数逐字相同——尤其当方法涉及非凸优化或随机初始化时。这也是本章每个预期结果都同时给出"小于某阈值"或"单调下降"这类稳健判据、而非只给一个孤立数字的原因。

版本信息速查¶

本章涉及的开源实现与论文版本（截至本资料编写，仅供参考，请以各仓库/出版方最新为准）。

项目 / 论文	版本信息	出处
Peters 逆博弈	RSS 2021 / IJRR 2023（扩展版）	RSS 2021 会议论文；IJRR 扩展版 DOI 10.1177/02783649231182453
LUCIDGames	RAL 2021	UKF 在线逆博弈
MaxEnt Games	IEEE T-RO 2023, 39(3):1801-1815	DOI 10.1109/TRO.2022.3232300
Cognitive Hierarchy	QJE 2004, 119(3):861-898	DOI 10.1162/0033553041502225，τ 中位数 1.55
GameFormer	ICCV 2023 Oral, pp.3903-3913	arXiv:2303.05760，代码 MCZhi/GameFormer
Auto-Encoding Bayesian	WAFR 2024	arXiv:2402.08902
Contingency Games	IEEE RA-L 2024（IROS 2024）	arXiv:2304.05483，博弈+分支规划
Level-2 逆博弈	arXiv:2508.03824	推断"对手对他人目标的估计"
GameInference.jl	Julia, MIT	github.com/lassepe/GameInference.jl
TensorGames.jl	Julia, MIT, ~25★	github.com/forrestlaine/TensorGames.jl

G3 阶段完结（§3.1–§3.4 + 章末）。 从"对手代价未知"出发，我们走过了逆博弈（从行为反推代价）、Level-k（有界理性的有限递归）、GameFormer（Level-k 嵌入 Transformer 的端到端范式），最后用"预测即均衡"收束——预测就是博弈均衡中对手的最优响应，规划就是 ego 的最优响应，两者同时求解，从根上消除了贯穿三章的 frozen robot。至此 G1（理论）→ G2（求解）→ G3（推断 + 一体化）合龙：博弈规划从黑板走到了真实道路。下一章 G4 将补上最后一块——当推断的对手模型可能出错时，如何用安全证书（CBF / 可达性）给博弈规划兜底，确保最坏情况下的硬安全。

观测长度	平均反推误差	标准差
1 步	5.477	0.000
2 步	0.943	0.274
4 步	0.136	0.024
8 步	0.049	0.011
15 步	0.019	0.008

G3 逆博弈、Level-k 与预测-规划一体化¶

前置自测¶

本章目标¶

知识导航¶

前置知识桥接¶

如果跳过本章会怎样¶

预计阅读时间¶

§3.1 逆博弈的形式化：从行为反推代价 ⭐⭐⭐ ★ 本章地基¶

动机：你不知道对手想要什么¶

反面案例：为什么不能"直接拟合一个预测器"¶

历史：从 Sadigh 的 IRL 到 Peters 的逆博弈¶

理论：逆博弈的最大似然形式¶

三栏式精读：Peters 2021 如何耦合"状态推断"与"参数估计"¶

关键技术：用隐函数定理让正向求解器可微¶

代码走读：隐函数定理解析梯度 vs 有限差分¶

代码走读：一个能跑的逆博弈 MLE¶

进阶：逆博弈接 iLQGames 内层（项目甲逆博弈层）¶

从离线 MLE 到在线推断：LUCIDGames¶

⚠️ 常见陷阱¶

练习¶

§3.2 Level-k 与认知层级：给有界理性建模 ⭐⭐⭐¶

动机：人类真的在算 Nash 均衡吗¶

反面案例：直接用 Nash 建模人类会怎样¶

历史：从行为经济学到自动驾驶¶

理论：Level-k 与 Cognitive Hierarchy¶

代码走读：Level-0/1/2 的行为差异¶

代码走读：贝叶斯在线估计对手的 k¶

⚠️ 常见陷阱¶

延伸：MaxEnt 博弈——有界理性的另一条路¶

前沿：Level-k 逆博弈——推断对手"以为别人想要什么"¶

练习¶

§3.3 GameFormer：把 Level-k 嵌进 Transformer ⭐⭐⭐ ★ 核心论文¶

动机：城市场景里几十个 agent，怎么实时博弈¶

反面案例：忽略"未来交互"的预测器会怎样¶

历史：从可微博弈到端到端博弈学习¶

理论：GameFormer 的架构¶

训练：如何"强制"逐层响应¶

代码走读：层级 decoder 的核心机制¶

代码走读：多模态预测——为什么不是单条轨迹¶

与 iLQGames 的对比：隐式博弈 vs 显式博弈¶

差异分析：论文叙述 vs 实现细节¶

⚠️ 常见陷阱¶

练习¶

§3.4 预测-规划一体化："预测即均衡" ⭐⭐¶

动机：frozen robot 的幽灵¶

反面案例：传统"先预测后规划"管线的结构性缺陷¶

理论：博弈视角的"预测即均衡"¶

代码走读：先预测后规划 vs 博弈一体化¶

与 GameFormer 的呼应¶

预测即均衡的三种实现路线（设计空间全景）¶

前沿：Contingency Games——为多种意图同时备好计划¶

综合：一个完整的博弈式交互规划系统¶

回望：Part-G 主线的本质¶

⚠️ 常见陷阱¶

"预测即均衡"的三个边界¶

练习¶

本章常见误解汇总¶

本章小结¶

术语速查表¶

知识点总表¶

累积项目：本章新增模块¶

延伸阅读¶

本章与后续章节的关系¶

🔧 故障排查手册¶

API 速查表¶

研究实践建议¶

动手复现指南¶

版本信息速查¶

G3　逆博弈、Level-k 与预测-规划一体化¶

§3.1　逆博弈的形式化：从行为反推代价　⭐⭐⭐　★ 本章地基¶

§3.2　Level-k 与认知层级：给有界理性建模　⭐⭐⭐¶

§3.3　GameFormer：把 Level-k 嵌进 Transformer　⭐⭐⭐　★ 核心论文¶

§3.4　预测-规划一体化："预测即均衡"　⭐⭐¶