核心公式

CHAPTER 06 # 核心公式推导 24 条定量关系，每条都给符号表、逐步推导、假设与失效边界， 并回答同一个问题：它在 Gemini 身上具体对应什么。

    阅读时长 **约 180 分钟**
    公式 **24 条**
    交互图表 **6 个**
    论文配图 **58 张**
    数据冻结 **2026-07-25**





  ### 本章要点

1. 长上下文的成本主项是 KV cache 的访存，不是注意力的算力。 算力随 (n^2) 涨但可以分摊到成千上万颗芯片，KV cache 随 (n) 线性涨却必须留在 每一步解码的关键路径上。这条分账决定了 MQA/GQA、滑窗交错、以及第八代 TPU 的全部设计。

2. FlashAttention 和 Ring Attention 都没有把注意力的总算术量降下来。 前者降 HBM 往返与临时显存，后者降单设备负担并新增环形通信；exact attention 的集群总 FLOPs 仍然是 (\Theta(n^2d))。把它们画成「(O(n^2)\to O(n))」是上一版材料的硬错误。

3. Chinchilla 的「20 token / 参数」不是定律，是一次特定拟合在特定算力区间的读数。 一般解是 (N^\star\propto C^{\beta/(\alpha+\beta)})，只有 (\alpha\approx\beta) 才近似各半； Epoch AI 的复现更指出原文 Approach 3 的置信区间窄得不可能——而恰恰是它给出了那个 20:1。

4. pass@k 的正确估计量是组合数式，朴素的 (1-(1-\hat p)^k) 系统性低估。 更要紧的是它的经济学含义：成本随采样数线性涨，收益随采样数对数涨。这是 test-time compute 的硬天花板，2026 年 ARC Prize 把「每题多少钱」和分数并列公布， 就是评测界对这条曲线的正式承认。

5. 第八代 TPU 分裂成 8t / 8i，是 roofline 公式被刻进硅的最干净案例。 8i 的峰值算力比 8t 低约 20%，HBM 带宽却高约 32%，片上 SRAM 是 Ironwood 的 3 倍—— 一颗故意牺牲 FLOPS 换带宽的芯片。它的脊点比 8t 低约四成，这正是 decode 需要的方向。

    本章 8 组 · 24 个公式推导 · 6 个交互图表 · 58 张论文配图 ·
    关键词：KV cache Scaling Law
    MoE test-time compute
    roofline RLHF / DPO

   这一章不猜 Gemini 的架构。除 Nano-1（1.8B）与 Nano-2（3.25B）外， Gemini 各版本的参数量、层数、专家数、top-k、训练 token 数、注意力实现官方从未披露。 本章所有涉及具体规模的算例，要么用公开的 Gemma 参数（Gemma 是 Google 保留的唯一一条 通往架构细节的公开证据通道，但 Gemma ≠ Gemini），要么用显式声明的通用配置。 凡属外部估算，均写明依据并放进「批判 / 局限」块。

   版本口径（截至 2026-07-25）：最新旗舰是 Gemini 3.1 Pro Preview（2026-02-19，仍未 GA）； 最新 Flash 是 Gemini 3.6 Flash（2026-07-21 GA）。3.6 > 3.1 是产品线命名错位，不是能力排序。 Gemini 3.x 只有模型卡、没有技术报告；^[1]Gemini 2.5 技术报告 是最后一份公开技术报告。计数口径：一次乘加 = 2 FLOPs。

   如何读这一章

   24 个公式按八组组织，组内按依赖顺序排列。每个公式都是同一套结构： 一句话 → 符号表 → 逐步推导（步骤自动编号，每步说明「这一步在做什么、为什么可以这么做」） → 假设 → 局限 → 本质解说 → 落到 Gemini → 失效边界。 如果你只想拿结论，读「一句话」和「本质解说」；如果你要复核，读推导； 如果你想知道什么时候不能用它，读「失效边界」——那才是这一章真正想给的东西。

• 理解瓶颈：B1 → B19 → B18（为什么硬件长成现在这样）

• 理解长上下文：B1 → B2 → B14 → B13 → B17（为什么 1M 能跑但跑不好）

• 理解规模与推理：B20 → B5 → B6 → B7 → B8（钱花在哪一端）

• 理解另一条路：B16 → B15 → B21 → B22 → B23（Google Research 在研究什么，而 Gemini 没在用什么）

| | 编号 | 公式 | 一句话 | 依赖 | 回答哪个追问

| | B1 | Self-attention 的 (O(n^2)) 与 KV cache 显存；MQA/GQA 压缩 | 长上下文的真瓶颈是显存与访存，不是算力 | — | 为什么 1M 上下文卖得比训练贵

| | B14 | FlashAttention 的 online softmax 重标定 | 不物化 (n\times n)：省的是 I/O，不是 FLOPs | B1 | 「近线性注意力」是怎么被误读的

| | B2 | RoPE 的相对位置性质与外推失效 | 低频维度「没转完一圈」是外推崩溃的根因 | B1 | 为什么改 base 频率就能把窗口拉长

| | B13 | Ring Attention 的通信-计算重叠 | 降的是单设备负担，集群总算术量不变 | B1, B14 | 官方从未确认 Gemini 用了它

| | B17 | 有效上下文 vs 名义上下文 | 要在 (n) 个 key 里稳定命中，logit 间隔须随 (\log n) 增长 | B1, B16 | MRCR v2 在 1M 上只有 26.3% 的一个机制假说（非定论）

| | B3 | Sparse MoE 的 top-k 门控与负载均衡辅助损失 | 硬统计 (f_i) 乘可导 (P_i)，梯度从 (P_i) 回传 | — | MoE 是 Google 发明的，为什么被别人推到极致

| | B4 | Capacity factor 与 token dropping 的期望丢弃率 | 均匀路由假设下的丢弃率只是一个下界 | B3 | 稀疏的代价藏在哪里

| | B18 | MoE 的 all-to-all 通信与专家并行 roofline | 总参数 / 激活参数 / FLOPs / 通信是四件事 | B3 | 为什么细粒度 MoE 与新一代加速器方向冲突

| | B20 | (C\approx6ND) 的推导与 MoE / 注意力修正 | 前向 2ND + 反向 4ND，且明确排除 self-attention | — | 为什么不能用它反推 Gemini 参数量

| | B5 | Chinchilla 的拉格朗日完整推导 | 20 token/参数是怎么算出来的，以及它站不站得住 | B20 | DeepMind 发现了它，然后所有人都违反它

| | B6 | Kaplan 与 Chinchilla 的差异根源 | 学习率调度 + 参数计数口径解释了指数差异 | B5 | 同样的数据为什么能得出两个结论

| | B7 | pass@k 的无偏估计量与 test-time 算力分配 | 成本线性、收益对数 | — | Deep Think 为什么永远不会成为默认模式

| | B8 | 投机解码的期望加速比 | (\mathbb{E}[K]=\frac{1-\alpha^{\gamma+1}}{1-\alpha}) 的完整推导 | B1 | Google 两个团队同期独立发现了它

| | B9 | 蒸馏的 KL 目标与温度的 (1/T^2) 梯度尺度 | 软标签的方差缩减 + 函数类匹配 | — | Flash 能逼近 Pro，边界在哪

| | B10 | UCB1 → PUCT 与 MuZero 三网络损失 | 「搜索是 policy improvement operator」 | — | RL/搜索传统到底转化成了什么

| | B11 | Bradley-Terry、KL 正则闭式解、DPO、PPO/GRPO | (\log Z) 在配对差中抵消，RL 变成分类 | — | 可验证奖励是全部秘密也是全部边界

| | B12 | DDPM 的 ELBO、(\epsilon)-参数化与 flow matching | Veo / Imagen / AlphaFold3 / GenCast 的共同底座 | — | 生成模型这条线的数学是统一的

| | B19 | systolic array 的算术强度与 roofline | decode 为什么天然是带宽瓶颈 | — | 为什么第八代 TPU 要分裂成两颗芯片

| | B16 | 线性注意力 / SSM 与 softmax attention 的差距 | 固定 (d\times d) 状态 = 关联记忆容量的硬界 | — | 为什么便宜的记忆换不来精确召回

| | B15 | Titans 的 surprise-based 记忆更新 | 线性注意力 = 平方损失在线学习的一步梯度 | B16 | Google Research 的方向，不是 Gemini 的实现

| | B21 | Shampoo → SOAP / Muon 与 Nested Learning | (-1/4) 次幂从哪来；Muon 是谱范数下的最速下降 | — | 优化器这一层还有多少余量

| | B22 | 压缩即智能：Solomonoff、MDL、(\log)-loss = 压缩率 | 「训练 LLM = 训练压缩器」在字面意义上成立 | — | 这是 Google 的真信仰还是叙事

| | B23 | Hopfield 视角与 ICL 的隐式梯度下降 | 线性自注意力一层可精确实现一步 GD | B1 | 上下文学习到底是不是「学习」

| | B24 | FAPE 与 SE(3) 不变性 | 把等变性与手性写进损失函数 | B12 | 领域结构如何变成可优化的目标

    表 6.1 · 24 个公式的索引与依赖。「回答哪个追问」一列指向本项目的本质追问清单；
      点击表头「编号」可排序。数据冻结于 2026-07-25。




## 组 1 · 注意力、显存与长上下文

这一组的五个公式回答同一个问题：**「百万 token 上下文」这件事，到底是被什么卡住的，又是被什么解开的。**B1 把注意力的成本拆成两条互不相干的曲线——训练期的平方级算力与解码期的线性级显存带宽，并说明后者才是真正的墙；B14 与 B13 分别在单芯片内部和跨芯片之间重新组织同一个精确 softmax，把墙推远；B2 处理位置编码在长度外推时的崩溃；B17 则给出一条信息论下界，说明即使前四件事全部做对，「名义上下文」与「有效上下文」之间仍然存在一道数学上不可消除的鸿沟。

**全组通用的计数口径与边界。**（1）**一次乘加 = 2 FLOPs**，若某来源采用 fused multiply-add 计为 1 op，数字会差 2 倍。（2）FlashAttention 与 Ring Attention 都是 **exact attention**，它们**不改变**集群总算术复杂度（仍是 \(\Theta(Bn^2d)\)）；把它们画成 \(O(n^2)\to O(n)\) 是错误的。只有 local / block-sparse 这种真正跳过 block 的方案才改复杂度，代价是不再等价于 full attention。（3）**KV cache（自回归推理的持久状态）、训练期 activation memory、\(n\times n\) 打分矩阵是三件不同的东西**，本组全程分账。（4）本组出现的一切具体层数、头数、上下文实现方式，**除明确标注为 Gemma（开源）或论文原文之外，均不是 Gemini 的架构披露**——Gemini 3.x 只有模型卡没有技术报告，2.5（arXiv:2507.06261）是最后一份公开技术报告。

### B1 · Self-attention 的 \(O(n^2)\) 与 KV cache 的显存账

**一句话。**注意力的算力随序列长度**平方**增长，而解码时 KV cache 的显存与访存随长度**线性**增长；两者在不同阶段、消耗不同资源，MQA / GQA / 滑窗交替全部只动第二条曲线的常数因子，一个 FLOP 都没省。




    **图 6.1** 缩放点积注意力的数据流：\(QK^\top\) → 除以 \(\sqrt{d_k}\) → 掩码 → softmax → 乘 \(V\)。读法的关键是中间那个从未被画出来的 \(n\times n\) 张量——本节全部的成本争论都发生在它身上。
    [@src-a7468c6851]出处：Attention Is All You Need, 2017





    B1
    Self-attention 复杂度、KV cache 显存与算术强度
    Vaswani et al., 2017 · arXiv:1706.03762 ／ Shazeer, 2019 · arXiv:1911.02150 ／ Ainslie et al., 2023 · arXiv:2305.13245





      符号表

| | (n) | 序列长度（context length） | 正整数，(10^3\sim10^7)

| | (d) | 模型隐层宽度 (d_{\text{model}}) | 正整数

| | (h_q) | query 头数 | 正整数

| | (h_{kv}) | key/value 头数（MHA 时 (=h_q)） | (1\le h_{kv}\le h_q)

| | (d_h) | 单头维度，约定 (d=h_qd_h) | 典型 64 / 128

| | (d_k) | key 维度，MHA 中 (d_k=d_h) | 正整数

| | (L) | 层数 | 正整数

| | (B) | 推理 batch（含 beam / 并发副本） | 正整数

| | (g) | GQA 的 KV 组数 | (1\le g\le h_q)

| | (w) | 滑动窗口宽度 | Gemma 3 取 1024

| | (s) | 每元素字节数 | bf16=2，fp8=1，int4=0.5

| | (I) | 算术强度（FLOPs / Byte） | 实数

逐步推导 · 共 12 步（点击展开）

      起点是缩放点积注意力的定义。给定 \(n\) 个 token 的表示 \(X\in\mathbb R^{n\times d}\)，先线性投影出三组矩阵，再做一次加权平均：

      \[ Q=XW_Q,\qquad K=XW_K,\qquad V=XW_V, \]
      \[ \operatorname{Attn}(Q,K,V)=\operatorname{Softmax}\!\left(\frac{QK^{\top}}{\sqrt{d_k}}\right)V . \]
      \(QK^\top\in\mathbb R^{n\times n}\) 是「每个 query 对每个 key 的相似度」矩阵，softmax 沿行归一化。后面所有的成本讨论，都是在讨论这个矩阵怎么被算出来、要不要被写下来、以及它的输入（K、V）要不要被留住。



      先把 \(\sqrt{d_k}\) 这个分母的来源说清楚，因为它决定了后面能不能低精度分块。设 \(q,k\in\mathbb R^{d_k}\) 的各分量独立同分布、零均值单位方差，考察内积 \(s=q\cdot k=\sum_{i=1}^{d_k}q_ik_i\) 的前两阶矩：

      \[
      \begin{aligned}
      \mathbb E[s]&=\sum_{i=1}^{d_k}\mathbb E[q_i]\,\mathbb E[k_i]=0,\\
      \operatorname{Var}(s)&=\sum_{i=1}^{d_k}\Big(\mathbb E[q_i^2k_i^2]-(\mathbb E[q_ik_i])^2\Big)\\
      &=\sum_{i=1}^{d_k}\big(1\cdot 1-0\big)=d_k .
      \end{aligned}
      \]
      两步都只用了独立性：期望可拆、方差可加。结论是 logit 的标准差是 \(\sigma_s=\sqrt{d_k}\)，也就是说**它随头维度增长而漂移**。



      不缩放会出什么事？取 \(d_k=128\)，\(\sigma_s\approx11.3\)。两个 logit 相差 3 个标准差就是 34，而 \(e^{34}\approx5.8\times10^{14}\)：softmax 输出被单个 key 完全垄断，退化成 hard argmax。更致命的是梯度——记 \(p=\operatorname{Softmax}(s)\)，其 Jacobian 为

      \[ \frac{\partial p}{\partial s}=\operatorname{diag}(p)-pp^{\top}. \]
      当 \(p\) 接近 one-hot（某个分量趋于 1、其余趋于 0），\(\operatorname{diag}(p)-pp^\top\to0\)，梯度消失，训练根本启动不了。除以 \(\sqrt{d_k}\) 恰好把方差归一化回 \(d_k/d_k=1\)，让 softmax 停在「软」的工作区。**注意这个论证只在初始化时刻成立**——训练后 \(q,k\) 的实际方差会漂移、各维度会相关，这正是 Gemma 2 引入 logit soft-capping、Gemma 3 引入 QK-norm 的动机。



      现在逐项数一层注意力在训练/prefill 期的 FLOPs（一次乘加 = 2 FLOPs，忽略 softmax、mask、norm 等 \(O(n^2)\) 与 \(O(nd)\) 项）：

      \[
      \begin{aligned}
      \text{(a) QKV 投影}&:\ 3\cdot(n\,d\,d)\cdot2 = 6nd^2,\\
      \text{(b) 打分 }QK^\top&:\ (n\,n\,d)\cdot2 = 2n^2d,\\
      \text{(c) 加权 }PV&:\ (n\,n\,d)\cdot2 = 2n^2d,\\
      \text{(d) 输出投影 }W_O&:\ (n\,d\,d)\cdot2 = 2nd^2 .
      \end{aligned}
      \]
      \[ \Rightarrow\quad \text{FLOPs}_{\text{attn}}=\underbrace{8nd^2}_{\text{线性层}}+\underbrace{4n^2d}_{\text{注意力核}} . \]
      多头不改变总量：\(h_q\) 个头各自是 \(n\times n\times d_h\)，求和 \(h_q n^2d_h=n^2d\)。这与独立 reviewer 的 \(C_{\text{proj}}\approx8Bnd^2\)、\(C_{\text{attn}}\approx4Bn^2d\) 完全一致（本节取 \(B=1\)）。



      求交叉点：注意力核何时超过线性层？令 \(4n^2d\gt 8nd^2\)，两边除以 \(4nd\gt0\)：

      \[ n\gt 2d . \]
      若把整层的 FFN（\(d_{ff}=4d\) 时约 \(16nd^2\)）也算进分母，则 \(4n^2d\gt24nd^2\Rightarrow n\gt6d\)。

      这一步是本节最容易被跳过、也最容易被误读的地方。对 \(d=8192\) 的模型，注意力要到 \(n\approx1.6\)–\(4.9\) 万才开始主导算力。**也就是说在 8K 上下文的年代，那个人尽皆知的「平方复杂度」其实根本不是瓶颈。**真正逼人换架构的是下面的显存账。



      转向自回归解码。生成第 \(t\) 个 token 时只有一个 query，却必须与前面所有位置的 key/value 交互。若每步重算全部 \(K,V\)，总代价是 \(\sum_{t=1}^{n}O(td^2)=O(n^2d^2)\)；缓存下来则每步只追加一行。对 MHA / GQA / MQA **统一成立**的缓存大小是

      \[
      \boxed{\;M_{\mathrm{KV}}=2\,L\,B\,n\,h_{kv}\,d_h\,s\ \text{bytes}\;}
      \]
      \[
      h_{kv}=\begin{cases}h_q & \text{MHA}\\ g & \text{GQA}\\ 1 & \text{MQA}\end{cases}
      \]
      因子 2 来自 K 与 V 各存一份。**六个量缺一不可**：层数 \(L\)、batch \(B\)、序列长 \(n\)、KV 头数 \(h_{kv}\)、头维 \(d_h\)、元素字节数 \(s\)。注意这里必须写 \(h_{kv}\) 而不是 \(h_q\)——写成 \(h_q\) 时 GQA/MQA 的压缩就无从表达。同样重要的是：**这不是训练期的 activation memory，也不是那个 \(n\times n\) 打分矩阵**，它是推理会话期间必须一直活着的持久状态。



      代入独立 reviewer 的复算锚点：\(L=32\)、\(B=1\)、\(n=32768\)、\(h_q=32\)、\(d_h=128\)、\(s=2\)。全部是 2 的幂，可以手算复核：

      \[
      \begin{aligned}
      M_{\mathrm{MHA}}&=2\cdot32\cdot1\cdot32768\cdot32\cdot128\cdot2\ \text{B}\\
      &=2^{1}\cdot2^{5}\cdot2^{0}\cdot2^{15}\cdot2^{5}\cdot2^{7}\cdot2^{1}\ \text{B}\\
      &=2^{34}\ \text{B}\;=\;\mathbf{16\ GiB}.
      \end{aligned}
      \]
      32K 上下文、单个用户、32 层的中型模型，光 KV cache 就吃掉 16 GiB。这个数字本身就足以说明：**推理侧的显存压力不是来自模型权重，而是来自会话状态**。



      MQA（Shazeer, 2019）把 \(h_q\) 个 KV 头压成 1 个、query 侧仍保留 \(h_q\) 个头；GQA（Ainslie et al., 2023）把 query 头分成 \(g\) 组、每组共享一份 KV。直接从上式读出压缩比：

      \[
      \frac{M_{\mathrm{MQA}}}{M_{\mathrm{MHA}}}=\frac1{h_q},
      \qquad
      \frac{M_{\mathrm{GQA}}}{M_{\mathrm{MHA}}}=\frac{g}{h_q},
      \]
      \[
      \underbrace{16\ \mathrm{GiB}}_{\text{MHA}}
      \;\longrightarrow\;
      \underbrace{4\ \mathrm{GiB}}_{\text{GQA},\,g=8}
      \;\longrightarrow\;
      \underbrace{0.5\ \mathrm{GiB}}_{\text{MQA}} .
      \]
      \(g=1\) 退化为 MQA，\(g=h_q\) 退化为 MHA，所以 GQA 是一条连续的插值线而不是第三种机制。**这里最该被强调的是：上一步的 FLOPs 公式 \(8nd^2+4n^2d\) 一个字都没有变。**query 头数没减，注意力图没变，softmax 的数学形式没动——变的只有那个必须被反复从 HBM 里读出来的字节数。



      为什么减少字节数比减少 FLOPs 更值钱？看解码单步的**算术强度**。一步解码里，注意力部分要做 \(QK^\top\) 与 \(PV\) 两个矩阵-向量乘，同时要把整个 KV cache 从 HBM 读一遍：

      \[
      \begin{aligned}
      \text{FLOPs}&=\underbrace{2h_qd_hn}_{QK^\top}+\underbrace{2h_qd_hn}_{PV}=4h_qd_hn,\\
      \text{Bytes}&=2\,n\,h_{kv}\,d_h\,s .
      \end{aligned}
      \]
      \[ \boxed{\;I=\frac{4h_qd_hn}{2nh_{kv}d_hs}=\frac{2h_q}{h_{kv}\,s}\;} \]
      MHA + bf16 时 \(I=2h_q/(h_q\cdot2)=1\) FLOP/Byte。而 H100 的 roofline 拐点是 \(989\ \mathrm{TFLOPS}/3.35\ \mathrm{TB/s}\approx295\) FLOP/Byte——**差了 295 倍**，ALU 绝大部分时间在等 HBM。这就是「decode 是极端 memory-bound」的定量版本。代入 MQA（\(h_{kv}=1,h_q=32\)）得 \(I=32\)，提高 32 倍，但仍比 295 低一个数量级：**MQA 把带宽墙推远了，没有推倒**。



      prefill 与 decode 的不对称，是同一个式子的另一面。prefill 是一次并行的大矩阵乘，算术强度约 \(O(n)\)；decode 如上是 \(O(1)\)：

      \[ \frac{I_{\text{prefill}}}{I_{\text{decode}}}\sim n . \]
      同一块芯片在两个阶段的有效利用率相差几个数量级。这直接催生了 2024 年之后的三件事：prefill/decode 分离部署、continuous batching（把 \(I\) 从 \(2h_q/(h_{kv}s)\) 抬到 \(2h_qB/(h_{kv}s)\)），以及「长输入短输出」远比「短输入长输出」便宜的 API 定价结构。**Gemini API 里 output token 比 input token 贵好几倍，根源就是这个比值。**但要注意 batching 只对权重读取有效——每个请求有**自己的** KV cache，无法共享，所以 batching 治不了 KV cache 的带宽问题，这正是 MQA/GQA 不可替代的原因。



      最后一层压缩：滑窗层与全局层交替。设 \(L_g\) 个全局层、\(L_l\) 个局部层（窗口 \(w\)），则

      \[ M_{\mathrm{KV}}=2\,B\,h_{kv}\,d_h\,s\cdot\Big(L_g\,n+L_l\min(n,w)\Big). \]
      取一个**纯演示用**的配置 \(L=80\)（\(L_g=13\)、\(L_l=67\)，约 5:1）、\(h_{kv}=h_q=64\)、\(d_h=128\)、\(n=10^6\)、\(B=1\)、bf16：

      \[
      \begin{aligned}
      \text{每层每 token}&=2\cdot64\cdot128\cdot2=32768\ \text{B}=32\ \text{KiB},\\
      \text{全局 MHA}&=32768\cdot80\cdot10^6\\
      &=2.62\times10^{12}\ \text{B}=2441\ \mathrm{GiB},\\
      \text{5:1 滑窗}&=32768\cdot\big(13\cdot10^{6}+67\cdot1024\big)\\
      &=4.28\times10^{11}\ \text{B}=399\ \mathrm{GiB}.
      \end{aligned}
      \]
      局部层的贡献从 \(67\times10^6\) 塌缩到 \(67\times1024\)，几乎归零，整体降 6.1 倍。**\(L=80,h_q=64\) 是为了演示量级而假设的，不是 Gemini 的层数与头数——后者从未公开。**



      把四层压缩叠起来，就是「1M 上下文为什么突然可行」的完整账本：

      \[
      \begin{aligned}
      \underbrace{2441}_{\text{MHA}}
      &\xrightarrow{\;h_{kv}:64\to8\;}\underbrace{305}_{\text{GQA}}
      \xrightarrow{\;n\to w=1024\;}\underbrace{49.9}_{+\text{滑窗}}\\
      &\xrightarrow{\;s:2\to1\;}\underbrace{24.9}_{+\text{int8}}\quad(\mathrm{GiB})
      \end{aligned}
      \]
      2441 → 24.9 GiB，**98 倍，两个数量级，全部来自常数因子**：\(h_{kv}\) 砍 8 倍、\(n\to w\) 砍 6.1 倍、\(s\) 砍 2 倍。这四步**没有一步动过 softmax attention 的数学形式**——它们不是「更聪明的注意力」，而是把公式里的每一个因子单独攻击一遍。

• (\sqrt{d_k}) 的方差论证要求 (q_i,k_i) 独立同分布、零均值单位方差。这只在初始化时刻成立。

• FLOPs 计数忽略 softmax、mask、norm、激活函数，假设 (d\gg1)；未计入 causal mask 带来的约 2 倍节省。

• KV cache 公式假设 dense attention、每层都缓存、无量化元数据、无分页碎片。真实系统（如 PagedAttention）有 block 粒度的内部碎片。

• 算术强度分析假设 KV cache 完全放不进片上存储、每步全量重读 HBM。

• 约定 (d=h_qd_h)、(d_k=d_v=d_h)。DeepSeek 的 MLA 这类 latent attention 打破这个约定，不能直接套用。

• **(O(n^2)) 是计算复杂度不是显存复杂度。**FlashAttention 之后，「注意力显存平方爆炸」这个流行说法已经是错的（见 B14）；爆炸的是 KV cache 的线性项乘上巨大的常数。

• 交叉点 (n\gt2d) 只算了注意力层内部。文献里 (n\gt d)、(n\gt2d)、(n\gt6d) 都能见到，差别全在「你把哪些项算进分母」，引用时必须写清口径。

• **MQA 的质量损失不是零。**Shazeer 自己报告 BLEU 26.7→26.5、LM 困惑度 29.9→30.2；GQA 论文明确指出 MQA 会带来质量退化与训练不稳定，这正是 GQA 存在的理由。

• GQA 的「约 5% 原预训练算力做 uptraining」是在 T5-XXL（约 11B、encoder-decoder）上测的，外推到百 B 级 decoder-only 模型没有直接证据；论文还明确说不要把 GQA 用在 encoder self-attention 上。

• 「砍 KV 头」这条路线有天花板：(g=1) 时压缩比就到顶（(h_q) 倍）。MLA 换的是表示（低秩潜变量）而非维度剪枝，压缩比可以超过 (h_q)——Google 至今没有公开采用它，这是一个真实的路线分叉。

      注意力有两条彼此独立的成本曲线：算力上的 \(8Bnd^2+4Bn^2d\)（\(n\gt2d\) 后平方项才主导），与推理上的 \(M_{\mathrm{KV}}=2LBnh_{kv}d_hs\)。
      **四种常见机制作用在不同的账上，不能混为一谈**：
      **（a）MQA / GQA** 把 \(h_{kv}\) 从 \(h_q\) 降到 \(g\)，同时减少 KV cache 与 **K/V 投影的 FLOPs**（\(2Bnd\cdot 2gd_h\) 而非 \(2Bnd\cdot 2h_qd_h\)），但**不改变** full attention 的 \(QK^\top\) 与 \(AV\) 两个主项；
      **（b）量化**只改每元素字节数 \(s\)，减少搬运字节与实际吞吐成本，**不改变符号意义上的 FLOP 数**；
      **（c）严格滑窗 / local attention** 是唯一同时改两条曲线的：交互项从 \(\Theta(Bn^2d)\) 降到 \(\Theta(Bnwd)\)，可保留的 KV 长度也从 \(n\) 降到 \(w\)——代价是**改变了注意力图，不再等价于 full attention**；
      **（d）FlashAttention 式的精确分块**只降 HBM 往返与临时显存，**总算术量不变**（见 B14）。
      而正因为解码的算术强度只有 \(2h_q/(h_{kv}s)\)，在**不改变注意力图**的前提下，砍常数比砍渐近阶更划算。
  
  
  
  
  
  
  
  
  
    **图 6.2** **三个并排子图**（左 Multi-head、中 Grouped-query、右 Multi-query）展示同一批 query 头如何映射到不同数量的 KV 头。**先看清图的排布：左侧行标签自上而下是 Values / Keys / Queries——Queries 在最下排，Keys 与 Values 在上两排**（本章上一版把上下说反了，已更正）。三图的**下排 query 都是 8 个、宽度完全一样**，query 侧的计算量没有任何变化；变的只有上两排：MHA 是 8 组 KV 一对一，GQA 收缩为 4 组、每组由 2 个 query 汇入，MQA 只剩 1 组、被 8 条虚线全部共享。**要被缓存和反复读取的正是上两排。**
    [@src-a114e852aa]出处：GQA, 2023
  
  
  
  
  
  
    **图 6.3** KV cache 的**绝对显存占用（纵轴是 KV Cache memory (MB)，不是占比也不是百分比）**随上下文长度的增长，单面板两条曲线，同为 2B 模型：黄线 **global only** 全部为全局层，128K 时约 **6,973 MB**；红线 **L:G=5:1, sw=1024** 为 5 层滑窗配 1 层全局，同一点只有约 **1,133 MB**。读法的要点是两条线的**斜率差**：全局层的数量决定曲线有多陡——这正是上面推导里 \(L_g\,n+L_l\min(n,w)\) 那个分解的图形化。**⚠️ 但滑窗那一项在图上并不呈现为「几乎水平的常数项」**：红线因为仍保留 1/6 的全局层，在 64K 之后同样明显上翘，只是斜率小得多。真正水平的是 \(L_l\min(n,w)\) 在 \(n>w\) 之后的那一部分，图上看到的红线是它与 \(L_g\,n\) 之和。
    [@src-cf5ce22f4d]出处：Gemma 3 Technical Report, 2025

  它到底在说什么。这一节真正的洞察不是「注意力是 (O(n^2))」，而是平方项与线性项在两个不同的阶段咬人，而且咬的是两种不同的资源。训练时被 (4Bn^2d) 的 FLOPs 咬，那是算力问题，可以用更多芯片换；推理时被 (2LBnh_{kv}d_hs) 的 KV cache 咬，那是显存带宽问题，钱买不到——过去十年算力大约涨了三个数量级，HBM 带宽只涨了一个多。这条剪刀差就是 2019 年 MQA、2023 年 GQA、2025 年 Gemma 3 滑窗交替的同一个底层驱动力。顺着这条线看会发现一件耐人寻味的事：这三篇工作全部出自 Google，而且没有一篇是「更聪明的注意力」——不是 Linformer / Performer 那种试图把 (n^2) 降到 (n\log n) 的近似路线，而是清一色地在不动 softmax 数学形式的前提下砍常数。这是一个「自己设计芯片、自己知道 HBM 带宽与互联确切数字」的团队才会做的选择：当你能量化每一个因子的美元代价时，你会发现卡住你的从来不是渐近阶，而是乘在前面的 (2Lh_{kv}d_hs)。

  **可以确定的只有 Gemma 这一侧。**Gemma 3（arXiv:2503.19786）公开了完整配方：GQA + 5:1 局部/全局交替 + 滑窗 1024 + 全局层 RoPE base 10k→1M，并报告在 32K 上下文下 global-only 配置的 KV cache 开销达模型自身的 60%，改用滑窗交替后降到 不足 15%；消融显示 3:1 / 5:1 / 7:1 对困惑度影响极小，说明 5:1 是「省内存」与「保性能」之间挑的安全点。Gemma 4（2026-04，arXiv:2607.02770）继续沿这条线走：全局层把 key 直接复用为 value、叠加跨层 KV 共享，把全局 KV footprint 再降最多 37.5%；其 26B-A4B 变体则改为 MoE（约 3.8B 激活）。硬件侧能与这条公式对上的，是 2026-04-22 Google Cloud Next ‘26 发布的 TPU 8i（Zebrafish，推理专用）：288 GB HBM + 384 MB 片上 SRAM（Ironwood 的 3 倍），官方说法是要「把 KV cache 尽量放进硅上」——这不是市场话术，而是本节第 (10) 步那个 (I=2h_q/(h_{kv}s)) 太低的直接推论：既然搬不动，那就别搬。**但必须说清楚：Gemma 不是 Gemini 的架构披露。**Gemini 各代是否使用 GQA、是否使用滑窗交替、层数头数是多少，官方一律未披露；网上流传的具体数字全部是外部估算。

  三处会改变判断的边界。（一）滑窗交替的「困惑度几乎不变」是一个已知的度量盲区。Gemma 3 的消融以 perplexity 为指标，而 perplexity 对「大海捞针」式的长程精确检索本来就不敏感——它由绝大多数局部可预测的 token 主导。真正需要全局层的是跨文档推理、代码库级理解这类任务，恰恰不在困惑度的度量范围内。反过来说，Gemma 3 仍然保留了 1/6 的全局层这个事实本身，说明团队也不敢砍得更狠。（二）算术强度的门槛比直觉高得多。常见说法是「MQA 解决了 decode 的带宽问题」，但按第 (10) 步的式子，MQA 只把 (I) 从 1 抬到 32，仍比 H100 的拐点 295 低一个数量级；真正把 (I) 推过拐点的是 (B)（并发）而不是 (h_{kv})。所以「用了 GQA 就不 memory-bound 了」是错的——GQA 的真实作用是腾出显存让 (B) 能开大，收益是间接的。（三）本节所有 GiB 数字都不含分配器碎片、page table、量化的 scale/zero-point、logits 与 runtime workspace，也不含 beam search / speculative branches 撑大的有效 (B)。真实系统的占用会显著高于公式值，把它当采购依据会算漏。

  B14 · FlashAttention 的 online softmax 重标定与 I/O 复杂度

  一句话。softmax 的归一化基准可以被平移，于是它可以被增量合并；据此把 (n\times n) 中间矩阵永远留在片上、从不落 HBM，用多算 16.7% 的 FLOPs 换掉几倍到几十倍的访存。整个过程是精确的，不是近似，总算术复杂度一点没降。

    **图 6.4** 左侧的存储金字塔标出了整个论证的前提——SRAM 带宽比 HBM 高一个数量级但容量小三到四个数量级；中间是 tiling 如何让 \(n\times n\) 矩阵永不物化。读法的要点是**把左图的带宽比与右图的加速比对着看**：加速比来自那个带宽差，而不是来自更少的算术。
    [@src-5727fed78b]出处：FlashAttention, 2022
  
  
  
  
  
    B14
    online softmax 的归纳证明与 I/O 复杂度
    Milakov & Gimelshein, 2018 · arXiv:1805.02867 ／ Dao et al., 2022 · arXiv:2205.14135 ／ Shah et al., 2024 · arXiv:2407.08608
  
  
  
  
  
      符号表

| | (n) | 序列长度 | 正整数

| | (d) | head dimension | 常见 64 / 128 / 256

| | (M) | 片上 SRAM（GPU）/ VMEM（TPU）容量，以元素数计 | A100 约 (9.8\times10^4)；TPU 约 (6.7\times10^7)

| | (B_c,B_r) | 列块 / 行块大小 | (B_c=\lceil M/4d\rceil)

| | (T_c) | 外层块数 (\lceil n/B_c\rceil) | (\Theta(nd/M))

| | (x_j) | 第 (j) 个分数子块 | —

| | (m^{(j)},\ell^{(j)}) | 前 (j) 块的行最大值 / 指数和 | (\mathbb R^{B_r})

| | (\tilde m_j,\tilde\ell_j,\tilde P_j) | 第 (j) 块内的局部最大值 / 指数和 / 指数矩阵 | —

| | (O^{(j)}) | 未归一化的输出累加器 | (\mathbb R^{B_r\times d})

逐步推导 · 共 11 步（点击展开）

      先定位问题。标准实现要把 \(S=QK^\top\in\mathbb R^{n\times n}\) 写回 HBM、读回来做 softmax、再写 \(P\)、再读回来乘 \(V\)。于是

      \[
      \begin{aligned}
      \text{HBM 访问}&=\Theta(nd+n^2),\\
      \text{FLOPs}&=\Theta(n^2d),\\
      I&\approx\frac{n^2d}{n^2}=d .
      \end{aligned}
      \]
      \(d\approx64\text{–}128\)，而 A100 的 roofline 拐点约 153、H100 约 295、TPU v4 约 229 FLOP/Byte。**attention 是访存受限的，所以降 FLOPs 毫无意义。**这一句就是 FlashAttention 全部立论的基础，也是它与此前几十篇「近似 attention 降 FLOPs」工作的分野——那些工作降了 FLOPs 却常常没有 wall-clock 加速，因为它们优化的量根本不是瓶颈。



      要做到「不物化 \(S\)」，必须能分块算 softmax。把一行分数向量切成块 \(x_1,\dots,x_T\)，令 \(\tilde m_j=\max(x_j)\)、\(\tilde\ell_j=\sum_{k\in x_j}e^{x_k-\tilde m_j}\)，维护两个标量：

      \[
      \begin{aligned}
      m^{(j)}&=\max\big(m^{(j-1)},\tilde m_j\big),\\
      \ell^{(j)}&=e^{m^{(j-1)}-m^{(j)}}\ell^{(j-1)}+e^{\tilde m_j-m^{(j)}}\tilde\ell_j .
      \end{aligned}
      \]
      直觉是：每块各自用**自己的**最大值做归一化以避免溢出，合并时再把两边的基准统一到新的全局最大值上。下一步证明这个「统一基准」的动作是精确的。



      归纳证明 \(\ell^{(j)}=\sum_{k\in x_{1:j}}e^{x_k-m^{(j)}}\)。基础 \(j=1\) 显然。归纳步只用到一个初等恒等式——**指数的基准平移** \(e^{a-c}=e^{a-b}e^{b-c}\)：

      \[
      \begin{aligned}
      \ell^{(j)}
      &=e^{m^{(j-1)}-m^{(j)}}\!\!\sum_{k\in x_{1:j-1}}\!\!e^{x_k-m^{(j-1)}}
       \;+\;e^{\tilde m_j-m^{(j)}}\!\!\sum_{k\in x_j}\!\!e^{x_k-\tilde m_j}\\
      &=\sum_{k\in x_{1:j-1}}e^{(x_k-m^{(j-1)})+(m^{(j-1)}-m^{(j)})}\\
      &\qquad\;+\;\sum_{k\in x_j}e^{(x_k-\tilde m_j)+(\tilde m_j-m^{(j)})}\\
      &=\sum_{k\in x_{1:j}}e^{x_k-m^{(j)}}. \qquad\blacksquare
      \end{aligned}
      \]
      中间那一行是全部内容：把两个不同基准下的指数和，各自乘一个校正因子后搬到同一个基准上。之所以可以省略更细的步骤，是因为求和号内的每一项都独立地满足同一个恒等式，逐项成立即整体成立。



      数值稳定性是**顺带白送**的，这一点常被漏掉。由 \(m^{(j)}=\max(m^{(j-1)},\tilde m_j)\)，两个校正因子的指数都 \(\le0\)：

      \[
      e^{m^{(j-1)}-m^{(j)}}\in(0,1],
      \qquad
      e^{\tilde m_j-m^{(j)}}\in(0,1],
      \]
      且两者中至少有一个恰好等于 1。

      于是所有中间量都被夹在 \([0,B_c]\) 内，**永不上溢**。朴素地先算 \(\sum_ke^{x_k}\) 再除，在 FP16 下会直接溢出。也就是说，这一个恒等变形同时解决了「能分块」与「不溢出」两个本来独立的需求。



      再看这个递推的**代数结构**——它比证明本身更有用。定义二元合并算子

      \[
      \begin{aligned}
      (m_1,\ell_1)\oplus(m_2,\ell_2)
      &=\Big(m,\;e^{m_1-m}\ell_1+e^{m_2-m}\ell_2\Big),\\
      m&=\max(m_1,m_2),
      \end{aligned}
      \]
      可以逐条验证 \(\oplus\) 既**结合**又**交换**，单位元是 \((-\infty,0)\)。

      也就是说 \((m,\ell)\) 构成一个**交换幺半群**，softmax 的归约是一次标准的 parallel reduction：可以任意分块、任意顺序、任意树形合并。这条性质是三层系统抽象的共同地基——FlashAttention 用它做单卡分块，Ring Attention（B13）用它做跨卡环传，PagedAttention 用它做非连续 KV 页。**一个初等的指数恒等式撑起了整个现代长上下文栈。**



      推广到带值向量的输出累积。令 \(\tilde P_j=\exp(S_j-\tilde m_j)\)，维护

      \[
      \begin{aligned}
      O^{(j)}=\ &\operatorname{diag}\!\big(e^{m^{(j-1)}-m^{(j)}}\big)O^{(j-1)}\\
      +\ &\operatorname{diag}\!\big(e^{\tilde m_j-m^{(j)}}\big)\tilde P_jV_j .
      \end{aligned}
      \]
      同样的基准平移给出 \(O^{(j)}=\sum_{k\le j}\exp(S_k-m^{(j)})V_k\)。

      这一步与第 (3) 步是同一个论证，只是把标量换成了行向量、把求和换成了对 \(V\) 的加权。之所以可以省略重复的归纳细节：\(\operatorname{diag}(\cdot)\) 是逐行的对角缩放，对每一行而言退化成第 (3) 步的标量情形。



      跑满 \(T\) 块后归一化，记 \(m=m^{(T)}=\max_kS_k\)：

      \[
      \begin{aligned}
      \frac{O^{(T)}}{\ell^{(T)}}
      &=\frac{\sum_ke^{S_k-m}V_k}{\sum_ke^{S_k-m}}
      =\frac{e^{-m}\sum_ke^{S_k}V_k}{e^{-m}\sum_ke^{S_k}}\\
      &=\operatorname{softmax}(S)V .
      \end{aligned}
      \]
      \(e^{-m}\) 上下精确对消，**与分块方式、块顺序完全无关**。这是「exact attention」四个字的全部内容——FlashAttention 与朴素实现的输出在数学上逐位相等（浮点舍入除外），它不是任何意义上的近似。



      现在数 I/O。设 \(B_c=\lceil M/4d\rceil=\Theta(M/d)\)（4 是为了同时装下 Q/K/V/O 四个块），外层遍历 \(T_c=\Theta(nd/M)\) 个 K/V 块，内层扫一遍所有 Q 行块：

      \[
      \begin{aligned}
      \text{K、V 各读一次}&:\ \Theta(nd),\\
      \text{每个外层迭代扫 }Q,O&:\ \Theta(nd)\ \text{每次},\\
      \text{合计}&:\ \Theta(nd)+T_c\cdot\Theta(nd)\\
      &=\boxed{\;\Theta\!\left(\frac{n^2d^2}{M}\right)}
      \end{aligned}
      \]
      对照标准实现的 \(\Theta(nd+n^2)\)，在 \(n\gg d\) 时比值为 \(M/d^2\)。这笔交易的实质是：**把「一次访问 \(n^2\)」换成「\(T_c\) 次访问 \(nd\)」**，而 \(T_c=\Theta(nd/M)\)，所以**只要 \(M\gt d^2\) 就赚**。这也解释了为什么 \(d\) 变大时收益锐减——它在分母里是平方。



      代入一个可复算的时间账。取 \(n=2^{20}=1{,}048{,}576\)、\(d=128\)、A100（\(M=192\) KB/SM = \(98{,}304\) 个 bf16 元素，HBM 约 2 TB/s，bf16 算力 312 TFLOPS），单头单层：

      \[
      \begin{aligned}
      \text{标准访存}&=4n^2=4.40\times10^{12}\ \text{元素}\\
      &=8.80\ \text{TB}\ \Rightarrow\ 4.40\ \text{s},\\
      \text{Flash 访存}&=\tfrac{4n^2d^2}{M}=7.33\times10^{11}\ \text{元素}\\
      &=1.47\ \text{TB}\ \Rightarrow\ 0.73\ \text{s},\\
      \text{计算}&=4n^2d=5.63\times10^{14}\ \text{FLOPs}\\
      &\Rightarrow\ 1.80\ \text{s}.
      \end{aligned}
      \]
      比值核对：\(4.40/0.73=6.0=M/d^2=98304/16384\) ✓

      读出来的结论是：标准实现 **4.40 s 访存 vs 1.80 s 计算**，访存受限，硬件利用率上限只有 41%；FlashAttention 变成 **0.73 s 访存 vs 1.80 s 计算**，转为计算受限，理论上可以吃满算力。**「IO 感知」的全部含义就是把瓶颈从访存搬回计算**，让原本闲置的矩阵单元有活干。也顺带说明为什么 \(d=256\) 时收益基本蒸发：\(M/d^2\) 掉到 1.5，访存仍然压着计算。



      反向传播必须重算 \(S,P\)（因为它们从未被存下来）。只数 matmul：

      \[
      \begin{aligned}
      \text{前向}&:\ \underbrace{2n^2d}_{S=QK^\top}+\underbrace{2n^2d}_{O=PV}=4n^2d,\\
      \text{反向}&:\ dV,\ dP,\ dQ,\ dK\ \text{各 }2n^2d=8n^2d,\\
      \text{重算 }S&:\ +2n^2d .
      \end{aligned}
      \]
      \[ \frac{14n^2d}{12n^2d}=1.167, \]
      即前向 + 反向合计多算 **16.7%** 的 FLOPs。

      这是本节最反直觉的一行：**FlashAttention 算得更多，却跑得更快。**在访存受限区间，用 17% 的额外算力换掉几倍到几十倍的访存是压倒性划算的。任何只看 FLOPs 的比较都会得出相反的结论——这正是它方法论上的价值：**它换掉的是度量，而不是算法。**



      TPU 侧的收益结构完全不同，这一点很少被讲清。TPU 的 VMEM 约 128 MiB，比 A100 的 192 KB/SM 大三个数量级：

      \[
      \begin{aligned}
      \left.\frac{M}{d^2}\right|_{\text{A100},\,d=128}&=6.0,\\
      \left.\frac{M}{d^2}\right|_{\text{TPU},\,d=128}&\approx4.1\times10^{3}.
      \end{aligned}
      \]
      在 TPU 上「softmax 能不能分块」这个约束**根本不紧**，收益几乎全部来自「不把 \(S\) 写回 HBM」这一件事，而不是来自精细的块大小调优。绑定约束换成了另一个：MXU 是 128×128 的脉动阵列，块大小必须是 128 的倍数，\(d\lt128\) 的 head 会直接浪费阵列的一个维度——这解释了为什么 TPU 上不流行极小的 head_dim。Google 的对应实现走 Pallas（JAX 的 kernel DSL）+ splash attention。

• (d\le M\le nd)，否则块划分无意义；A100 上 (d=256) 时 (M/d^2=1.5)，理论收益已接近消失。

• I/O 分析假设 K/V 块整体驻留片上、Q/O 可流式扫过，忽略 kernel 启动、寄存器溢出等常数开销。

• FLOPs 账只数 matmul，忽略 exp / mask / dropout 等逐元素操作——而这些恰恰在现代硬件上远非可忽略（H100 上 exp 的吞吐比 matmul 低约 256 倍）。

• online softmax 的数值稳定性依赖 (m,\ell) 与输出累加器用 FP32；FP8 路径下必须显式保证这一点。

• 短序列无收益。(n) 小时 (\Theta(nd)) 项主导、kernel 启动开销占比上升，(n\lesssim512) 时常常不如朴素实现。

• 对超小或超大 (d) 都不友好。(d) 太小浪费张量核 / MXU 的 tiling；(d=256) 时 (M/d^2) 只剩 1.5（A100）。

• 误差不是逐块独立的。(m^{(j)}) 一旦被某个离群 logit 抬高，此前累积的 (O^{(j-1)}) 就要整体乘一个很小的 (e^{m^{(j-1)}-m^{(j)}})，低精度下这一步会吃掉有效位——这就是 (m,\ell) 与累加器必须留在 FP32 的原因，也意味着 FP8 只能用在两个 GEMM 的输入上，收益被摊薄。FlashAttention-3 论文自己也承认 FP8 在 (d=128/256) 且带因果掩码时反而落后于 FP16。

• **非标准 mask 支持差。**任意稀疏 mask、可变长 mask、自定义偏置往往要重写 kernel。

• **因果掩码的节省被块粒度打折。**只有整块被掩码的 tile 才能跳过，拿不到理论上的 2 倍。

      online softmax 的 \((m,\ell)\) 合并构成交换幺半群，因此 softmax 归约与分块方式、块顺序无关；据此 FlashAttention 把 HBM 访问从 \(\Theta(nd+n^2)\) 降到 \(\Theta(n^2d^2/M)\)，加速比约 \(M/d^2\)，代价是前向+反向多算 16.7% 的 FLOPs。**它是 exact attention，总算术复杂度仍为 \(\Theta(Bn^2d)\)。**

  它到底在说什么。FlashAttention 最重要的贡献不是那个 kernel，而是把「什么是 attention 的成本」这个问题重新定义了一遍。在它之前，几十篇论文在降 (O(n^2)) 的 FLOPs（Linformer、Performer、Reformer……），大多数在真实硬件上并不更快，因为它们优化的量根本不是瓶颈。第 (1) 步的算术强度分析指出瓶颈是 HBM 往返，然后第 (10) 步给出一个「多算 17% 却快好几倍」的精确算法。这是一次典型的换度量而非换算法的胜利，方法论价值超过技术本身。而第 (5) 步那个幺半群结构值得单独记住：它解释了为什么 Flash（单卡分块）、Ring（跨卡环传）、Paged（非连续页）三种看起来毫不相干的系统设计，可以共用同一条数学地基。

  **能确定的是软件栈，不能确定的是 Gemini 用没用。**公开可查的事实是：Google 在 TPU 上的对应实现走 Pallas（JAX 的 kernel DSL）+ splash attention（sparse flash attention），文档公开；TPU 的 VMEM 约 128 MiB，使 (M/d^2) 达到 (10^3) 量级，因此「分块」这个约束在 TPU 上远不如在 GPU 上紧。**Gemini 是否使用 FlashAttention 或其任何变体，官方从未披露，任何断言都是外部推测。**更值得注意的是一个反向因果：GPU 侧的 FA2/FA3 是在极小的片上内存里做极致手工调度（warp specialization、pingpong、寄存器布局），TPU 侧因为 VMEM 大三个数量级，这一整层问题几乎不存在，代价是被 128×128 的 MXU tiling 与 XLA 的调度决策锁死。**FlashAttention 系列诞生在 GPU 生态而非 TPU 生态，不是偶然——只有当资源极度稀缺时，才会逼出这种级别的算法-硬件协同设计。**Google 推出 Pallas 某种意义上是在补这一课。

  两个必须纠正的流行说法，和一个隐蔽的代价。（一）「FlashAttention 把注意力从 (O(n^2)) 降到 (O(n))」是错的，而且错得很具体。它降的是 HBM I/O（(\Theta(nd+n^2)\to\Theta(n^2d^2/M))）与临时显存（(\Theta(Bhn^2)\to\Theta(Bnd))）；总算术量仍是 (\Theta(Bn^2d))，而且因为反向重算还多了 16.7%。把它和 local/block-sparse 混为一谈，等于把「精确分块」和「有损近似」当成同一类技术。（二）「FlashAttention 之后注意力就不再是显存瓶颈了」也不对。它消除的是训练期的 (n\times n) 临时 activation，对自回归推理的 KV cache 没有任何影响——B1 的 16 GiB 一分不少。这两件事被混淆的频率极高。（三）一个很少被讨论的路径依赖：今天要提出一种新的注意力变体，如果它写不成一个高效的 flash kernel，就等于没有竞争力——哪怕小规模上效果更好。过去几年幸存下来的架构改动（GQA/MQA、滑窗、局部-全局交替、logit soft-cap）无一例外都是「对 flash kernel 友好」的改动：要么减少 KV 读取，要么只改块的形状。软件栈正在给模型设计打分，而这个打分函数从未被明示。

  B2 · RoPE 的相对位置性质证明与长度外推的失效

  一句话。RoPE 用旋转把绝对位置注入 q/k，内积处自动抵消成相对位置——这是一个两行的恒等式；而外推之所以崩溃，根因是低频维度在训练长度内根本没转完一圈——注意这不是说相对性失效了（代数恒等式对每个频率都成立），而是说这些维度在训练中只见过整个相位圆周的一小段弧，外推时相位走进了从未见过的区间，成了分布外输入。

    **图 6.5** RoPE 的实现示意，**分上下两个面板**。**上面板（左下角标 d=2）**是最小情形：把 query/key 的相邻两维 \((x_1,x_2)\) 看作一个二维平面，按角度 \(m\theta_1\) 旋转成 \((x'_1,x'_2)\)——图上用绿字把 \(\theta_1\) 标为 *Constant*、用红字把 \(m\) 标为 *Position*，正好对应「角度 = 位置 × 常数频率」。**下面板**把它推广到整条向量与多个位置：向量顶部标出 \(\theta_1,\theta_2,\dots,\theta_{d/2}\)，说明每两维共用一个 \(\theta\)、共 \(d/2\) 个平面；六行分别对应位置 1–6，右侧是旋转后的结果。**⚠️ 图上只出现 \(\theta\) 的下标序列，没有任何 \(\theta_i\) 的数值、公式或曲线**——「不同平面转速不同、\(\theta_i\) 呈几何级数衰减」是论文的定义式而不是本图的内容。后面「哪些维度转满了圈」的讨论请引式 \(\theta_i=b^{-2i/d}\)，**不能引这张图**。
    [@src-83213326f5]出处：RoFormer (RoPE), 2021
  
  
  
  
  
    B2
    RoPE 的相对性证明、外推失效根因与 PI / NTK-aware / YaRN
    Su et al., 2021 · arXiv:2104.09864 ／ Chen et al., 2023 · arXiv:2306.15595 ／ Peng et al., 2023 · arXiv:2309.00071
  
  
  
  
  
      符号表

| | (m,n) | token 的绝对位置索引 | (0,1,\dots)

| | (d) | 头维度（须为偶数） | 典型 64 / 128

| | (i) | 二维旋转平面的编号 | (0,\dots,d/2-1)

| | (b) | RoPE 基底（base） | 默认 (10^4)

| | (\theta_i) | 第 (i) 个平面的角频率 (b^{-2i/d}) | ((0,1])

| | (R_{\Theta,m}) | 位置 (m) 的分块旋转矩阵 | (\mathbb R^{d\times d})，正交

| | (\lambda_i) | 第 (i) 维的波长 (2\pi/\theta_i) | token 数

| | (L,L’) | 预训练长度 / 目标扩展长度 | 正整数

| | (s) | 缩放因子 (L’/L) | (\gt1)

| | (r(i)) | 转数 (L/\lambda_i) | (\gt0)

| | (\gamma) | YaRN 的 ramp 函数 | ([0,1])

| | (t) | YaRN 的注意力温度 | (\gt0)

逐步推导 · 共 17 步（点击展开）

      先写清楚我们想要什么。目标是找一个把位置注入表示的函数 \(f\)，使得注意力内积**只依赖相对位置**：

      \[ \big\langle f(q,m),\,f(k,n)\big\rangle = g(q,k,\,n-m). \]
      这是一个函数方程，而不是一个架构。RoPE 的贡献就是给出了它的一个优雅解，并且这个解不引入任何额外参数、也不需要一个 \(n\times n\) 的偏置矩阵（对比 T5 的可学习相对位置偏置）。



      Su et al. 的答案是**用旋转**。二维情形取 \(f(q,m)=R_mq\)；推广到 \(d\) 维时把坐标两两配对成 \(d/2\) 个平面，各用自己的频率旋转，拼成块对角矩阵：

      \[ R_m=\begin{pmatrix}\cos m\theta & -\sin m\theta\\ \sin m\theta & \cos m\theta\end{pmatrix}, \]
      \[ R_{\Theta,m}=\operatorname{diag}\big(R^{(0)}_m,\dots,R^{(d/2-1)}_m\big), \]
      \[ \theta_i=b^{-2i/d},\qquad b=10^4 . \]
      频率按几何级数从 1（\(i=0\)）衰减到 \(10^{-4}\)（\(i=d/2-1\)），这是从原始 Transformer 的正弦编码继承来的设计。**记住这个几何级数——它是相对性的「非必要条件」，却是外推失效的「充分肇因」。**



      证明只需要旋转群的两条性质，都是初等的：

      \[
      \begin{aligned}
      R_\alpha R_\beta&=R_{\alpha+\beta} &&(\text{三角和角公式}),\\
      R_\alpha^{-1}&=R_{-\alpha}=R_\alpha^{\top} &&(\text{正交性}).
      \end{aligned}
      \]
      块对角矩阵逐块满足则整体满足，所以 \(R_{\Theta,m}\) 也满足这两条。之所以可以直接从二维推到 \(d\) 维而省略中间步骤：块对角矩阵的乘法就是逐块乘法，转置就是逐块转置。



      于是直接计算：

      \[
      \begin{aligned}
      \big\langle R_{\Theta,m}q,\;R_{\Theta,n}k\big\rangle
      &=(R_{\Theta,m}q)^{\top}(R_{\Theta,n}k)\\
      &=q^{\top}R_{\Theta,m}^{\top}R_{\Theta,n}k\\
      &=q^{\top}R_{\Theta,-m}R_{\Theta,n}k\\
      &=q^{\top}R_{\Theta,\,n-m}k\\
      &=\big\langle q,\;R_{\Theta,\,n-m}k\big\rangle .
      \end{aligned}
      \]
      四步依次用到：内积展开 → 转置分配 → 正交性 \(R^{\top}_{\Theta,m}=R_{\Theta,-m}\) → 加法性 \(R_{\Theta,-m}R_{\Theta,n}=R_{\Theta,n-m}\)。

      **得证：内积只依赖 \(n-m\)。**

      四行，每行只用一条性质。这就是 RoPE 的全部魔法——绝对位置的旋转在内积处**自动抵消**。值得单独指出：**这个证明对任意 \(\theta_i\) 都成立**，完全没用到几何级数。频率阶梯是为了长程衰减与多尺度覆盖设计的，不是相对性所必需——这一点直接决定了后面 PI / NTK / YaRN 为什么**可以**随便改频率而不破坏相对性。



      换成复数形式看得更透。把平面 \((x_{2i},x_{2i+1})\) 视作复数，旋转就是乘以单位复数 \(e^{\mathrm i m\theta_i}\)，实内积对应复内积的实部：

      \[
      \begin{aligned}
      \big\langle R_mq,R_nk\big\rangle
      &=\sum_i\operatorname{Re}\Big[\big(q_ie^{\mathrm i m\theta_i}\big)\overline{\big(k_ie^{\mathrm i n\theta_i}\big)}\Big]\\
      &=\sum_i\operatorname{Re}\Big[q_i\bar k_i\,e^{\mathrm i(m-n)\theta_i}\Big].
      \end{aligned}
      \]
      指数上只剩 \(m-n\)。这个式子还顺带告诉我们一件更深的事：**注意力打分是系数 \(\{q_i\bar k_i\}\) 在频率阶梯 \(\{\theta_i\}\) 上的一个傅里叶求和，自变量是相对距离**。既然是傅里叶求和，模型就**可以**在任意距离上构造出一个峰值——这正是长上下文精确寻址能力的来源。



      长程衰减性质要小心陈述。记 \(\Delta=m-n\)、\(c_i=q_i\bar k_i\)，用 Abel 分部求和，令 \(E_j=\sum_{i=0}^{j}e^{\mathrm i\Delta\theta_i}\)：

      \[
      \begin{aligned}
      \Big|\sum_i c_ie^{\mathrm i\Delta\theta_i}\Big|
      \;\le\;\Big(\max_j|E_j|\Big)\cdot
      \Big(&|c_{d/2-1}|\\
      &+\sum_j|c_{j+1}-c_j|\Big).
      \end{aligned}
      \]
      第二个因子与 \(\Delta\) 无关（只是 \(q,k\) 的总变差）；第一个因子是几何级数频率上的指数和，随 \(\Delta\) 增大而振荡衰减。所以 RoPE 自带一个软性的局部性先验。**但必须强调：衰减的是上界，不是打分本身。**把「RoPE 有长程衰减」读成「远处的注意力一定小」是过度解读——上一步的傅里叶求和说明模型完全可以在远处造峰。



      现在处理外推。定义第 \(i\) 维转满 \(2\pi\) 所需的 token 数：

      \[ \lambda_i=\frac{2\pi}{\theta_i}=2\pi\,b^{2i/d}. \]
      取 \(b=10^4,\ d=128\)：

      \[
      \begin{aligned}
      \lambda_0&=2\pi\approx 6.3, &\lambda_{32}&\approx 6.28\times10^{2},\\
      \lambda_{48}&\approx 6.28\times10^{3}, &\lambda_{63}&\approx 5.44\times10^{4}.
      \end{aligned}
      \]
      波长横跨四个数量级。最高频维度 6 个 token 转一圈，最低频维度要五万多个 token 才转一圈。



      设预训练长度 \(L=4096\)。哪些维度**从未转满一圈**？解 \(2\pi b^{2i/d}\gt L\)：

      \[
      \begin{aligned}
      \frac{2i}{d}&\gt\log_b\frac{L}{2\pi}\\
      \Longrightarrow\quad i&\gt\frac d2\log_b\frac{L}{2\pi}
      =64\cdot\frac{\ln 651.9}{\ln 10^4}\\
      &=64\times0.7036\approx 45 .
      \end{aligned}
      \]
      也就是说 \(d=128\) 的 64 个平面里，**有 18 个（\(i\gt45\)）在整个预训练过程中相位都没走完一圈**。对这些维度，相位 \(m\theta_i\) 只覆盖了 \([0,L\theta_i]\subsetneq[0,2\pi)\) 这一段弧。



      这就是外推失效的根因，而且它比「相对位置应该能外推」这个直觉**正好相反**。推理时若 \(m\gt L\)，低频维度的相位落进 \((L\theta_i,2\pi)\) 甚至绕圈——**这是模型从未见过的输入区域，是彻头彻尾的分布外**。YaRN 论文点破了这层：正因为这些维度没转满，第一个 token 到其他每个 token 的相位差都是唯一的，网络可以据此反推**绝对位置**。

      \[
      \underbrace{\text{数学上}}_{\text{对任意 }\Delta\text{ 成立}}\ \text{相对}
      \quad\ne\quad
      \underbrace{\text{统计上}}_{\text{只见过 }[0,L\theta_i]}\ \text{相对}
      \]
      一个数学上完美的相对性质，被**有限的训练长度**打破了——因为相对性是关于整个圆周的性质，而训练只给了你圆周的一段弧。这是一条关于「数学性质 vs 统计可达性」的普适教训：**一个恒等式成立，不代表网络学到了它所蕴含的不变性。**



      **Position Interpolation（Chen et al., 2023）。**既然外推是分布外，那就别外推——把新位置压回旧区间：

      \[
      m\longmapsto \frac{m}{s},
      \qquad
      \theta_i\longmapsto\frac{\theta_i}{s},
      \qquad s=\frac{L'}{L}.
      \]
      位置 \(L'\) 被映射到 \(L\)，所有相位都落回训练见过的范围，**零分布外**。代价立刻可见：相邻 token 的相位差从 \(\theta_i\) 降到 \(\theta_i/s\)。对 \(i=0\)（\(\theta_0=1\)）、\(s=8\)，相邻位置的旋转角从 1 rad 压到 0.125 rad——原本用来区分「上一个词」和「上上个词」的高频信号被压扁 8 倍，直接损害局部语法建模，表现为短上下文困惑度上升。



      **NTK-aware：把「均匀插值」换成「改基底」。**核心想法是让高频维度不动、低频维度插满。改 \(b\to b'\)，写出两个边界条件：

      (i) **最高频不变**——对任何 \(b'\) 自动成立：

      \[ \theta_0'=b'^{\,0}=1=\theta_0 . \]
      (ii) **最低频插满 \(s\) 倍**：

      \[ \theta'_{\text{last}}=\frac{\theta_{\text{last}}}{s} \]
      \[
      \Longleftrightarrow\quad
      b'^{\,-\frac{d-2}{d}}=\frac1s\,b^{\,-\frac{d-2}{d}} .
      \]
      条件 (i) 是**免费**的——因为 \(i=0\) 时指数为 0，任何基底都给出 \(\theta_0=1\)。这正是「改基底」比「改缩放因子」高明的地方：它把「高频不动」这个要求变成了恒等式而不是约束。



      解这个方程。两边取 \(\frac{d}{d-2}\) 次幂：

      \[
      b'^{\,\frac{d-2}{d}}=s\cdot b^{\,\frac{d-2}{d}}
      \;\Longrightarrow\;
      \boxed{\;b'=b\cdot s^{\frac{d}{d-2}}\;}
      \]
      对 \(d=128\)，指数是 \(128/126=1.0159\)，几乎就是 \(b'\approx b\cdot s\)。代入 \(b=10^4,\ s=8\)：\(b'=10^4\times8^{1.0159}\approx8.3\times10^4\)。

      **这就是社区那条「把 rope base 从 10000 调到 500000 就能扩长文」经验法则的数学来源**——它不是玄学，是这个约束方程的解。反解一下：\(b'=5\times10^5\) 对应 \(s=(50)^{126/128}\approx47\)，即 4K 预训练可撑到约 19 万 token。



      **YaRN（Peng et al., 2023）：把渐变显式化。**NTK-aware 的问题是「给定 \(s\) 该用哪个 \(b'\) 只能靠试」。YaRN 直接按**转数**分段：

      \[ r(i)=\frac{L}{\lambda_i}=\frac{L}{2\pi b^{2i/d}}, \]
      \[
      \gamma(r)=\begin{cases}0,& r\lt\alpha\\ 1,& r\gt\beta\\ \dfrac{r-\alpha}{\beta-\alpha},&\text{otherwise}\end{cases}
      \]
      \[ \theta_i'=\big(1-\gamma(r(i))\big)\frac{\theta_i}{s}+\gamma(r(i))\,\theta_i . \]
      \(r(i)\) 大 = 高频 = 训练时转了很多圈 = 只编码相对位置 = 不要动；\(r(i)\) 小 = 低频 = 偷偷编码了绝对位置 = 必须插值。LLaMA 系列的经验值是 \(\alpha=1,\beta=32\)：**转不满 1 圈的全插，转过 32 圈的完全不动，中间线性过渡。**可以看到这就是第 (9) 步那个「\(i\gt45\)」判据的连续化版本。



      YaRN 还加了一个温度。上下文变长后 softmax 要在更多 key 上分配概率质量、注意力熵上升，于是：

      \[
      \operatorname{Softmax}\!\left(\frac{q_m^{\top}k_n}{t\sqrt d}\right),
      \qquad
      \sqrt{\frac1t}=0.1\ln s+1 .
      \]
      **这个式子纯粹是经验拟合**——原文明说是在 LLaMA 7b/13b/33b/65b 上对不同 \(s\) 扫描 \(\sqrt{1/t}\) 取困惑度最低点再拟合出的直线，**没有任何理论推导**。取 \(s=8\) 得 \(\sqrt{1/t}\approx1.208\)，即把 logit 放大约 1.21 倍、锐化注意力。实现上极优雅：它只是给 \(q\)（或 \(k\)）乘一个常数，可以直接吸收进 RoPE 的预计算表，零额外开销、完全兼容 flash kernel。注意这一项与 B17 第 (4) 步的 \(\ln n\) 项在做同一件事——对抗稀释。



      把四种方案写成同一个自由度上的不同取法：所有方法都是「给第 \(i\) 维频率乘一个因子 \(\eta_i\)」。

      \[ \theta_i'=\eta_i\theta_i, \]
      \[
      \eta_i=\begin{cases}
      1 & \text{直接外推}\\
      1/s & \text{PI（均匀）}\\
      (b'/b)^{-2i/d} & \text{NTK-aware（隐式渐变）}\\
      (1-\gamma_i)/s+\gamma_i & \text{YaRN（显式分段）}
      \end{cases}
      \]
      三者在低频端**行为完全一致**（都插满 \(s\) 倍），差别只在高频端与过渡区的精细度。这解释了效果排序 PI  3.1 是两条产品线的**命名错位**——小数位是后训练版本号——**它本身不构成「Flash 整体比 Pro 强」的证据**。可横比的只是 MRCR 这一格。）

本章此前在这里写的是一个「有一道数学的墙」式的叙事。**那个叙事已被同口径证据证伪，本轮整体撤回；「墙 / 上限 / 物理瓶颈 / 架构硬限制」这类措辞在本节一律不再使用。**理由就在上表里：

  **Flash 线在 1M pointwise 上，两个月内从 26.6% 涨到 54.0%——同一 benchmark、同一针数、同一长度档，翻了一倍还多。**
    一个能在两个月内被工程翻倍的数字，**不可能是这一代架构的能力上限**。

  **★而这恰恰让 Pro 线更可疑，也让问题变得更有意思。**如果 1M 上的低分是某种普遍的数学性质，那 Flash 线不该涨；既然 Flash 线涨了，那么 **Pro 线在 3 Pro → 3.1 Pro 两代之间纹丝不动，就更像是优先级或训练配方的结果，而不是能力边界。**
    **于是该问的不再是「为什么 1M 做不到」，而是：Google 为什么把长上下文的工程投入放在 Flash 线，而不是旗舰 Pro 线？**

  这个版本的问题比原来那个信息量大得多，因为**它是可追问、也可能被回答的**：一个关于资源分配的问题有真实答案，一堵「数学的墙」没有。
    （必须同时说清边界：54.0% 能**反驳**「26.3% 是全模型共有的物理硬上限」，但**不能证明**原因就是 Pro 线的资源分配——那需要 Google 披露两条线的长上下文训练配置，而这是不公开的。**这里换掉的是一个被证伪的答案，不是换上了一个新答案。**）



  **图 6.10** 与模型厂商无关的第三方证据：同一条关键信息放在上下文的不同位置，准确率呈 **U 形**——开头结尾找得到，放到中间就丢。有效上下文不仅比名义窗口**短**，还**在窗口内分布不均**。**这一点下面的模型解释不了**：它是位置无关的，只预测「随 \(n\) 整体变难」，不预测「中间比两端更难」；U 形要靠位置编码与训练分布来解释。
    **★读这张图必须带上它的实际口径（本轮开图核对后补）**：图题写明是 **20 篇检索文档、约 4K token**，模型是 **gpt-3.5-turbo-0613**，纵轴 accuracy 约在 54%–76% 之间，红色虚线是同模型的 closed-book 基线（约 56%）。
    **也就是说这是一个 4K 量级的实验，被用来讨论 1M 量级的现象时跨了两个多数量级——它能说明「位置效应存在」，不能给出 1M 上位置效应的形状或幅度。**
    [@src-6ee8321847]出处：Lost in the Middle（Liu et al.），2023




    B17
    注意力稀释与有效上下文
    机制模型（前提显式声明）／ Liu et al., 2023 · arXiv:2307.03172




      符号表

| | (n) | 参与 softmax 的 key 个数（≈ 上下文 token 数） | 正整数

| | (d,;d_h) | 模型宽度、单头维度 | 演示取 (d=4096,;d_h=128)

| | (s_i) | 第 (i) 个 key 的注意力 logit（已除 (\sqrt{d_h})） | 无量纲，单位记作 nat

| | (s^\star) | 目标（「针」）的 logit | nat

| | (X_i) | (n-1) 个干扰 logit，已减去均值 | (\mathbb E X_i=0)

| | (\sigma) | 干扰 logit 的次高斯（sub-Gaussian）参数 | 演示取 (\sigma=2)

| | (\Delta) | 间隔 (=s^\star-\mathbb E[s_i])，本节核心量 | nat

| | (a_i) | softmax 后的注意力权重 | (\sum_i a_i=1)

| | (\kappa_Q,\kappa_K) | (|W_Q|{\mathrm{op}},|W_K|{\mathrm{op}}) 算子范数 | 训练中可自由增长

| | (\gamma) | RMSNorm 的可学习 gain | 同样不受归一化约束

| | (\rho) | 「读出成功」要求的信噪比阈值 | 演示取 (\rho=1)

逐步推导 · 共 10 步（点击展开）

      把「检索」写成可判定的问题。单头对查询 \(\mathbf q\) 与 \(n\) 个 key 计算

      \[ s_i=\frac{\langle \mathbf q,\mathbf k_i\rangle}{\sqrt{d_h}},\qquad a_i=\frac{e^{s_i}}{\sum_{j}e^{s_j}},\qquad \mathbf o=\sum_{i}a_i\mathbf v_i. \]
      \(1/\sqrt{d_h}\) 的来历是**方差论证**：若 \(\mathbf q,\mathbf k\) 各分量独立、均值 0 方差 1，则内积方差为 \(d_h\)，除以 \(\sqrt{d_h}\) 拉回 \(O(1)\)。[@src-a7468c6851][Vaswani 2017] **这只是初始化时刻的方差控制，不是对训练后 logit 的约束**——这个区别在步 (8) 会变成本节最关键的一条。设目标下标 \(\star\)，间隔 \(\Delta=s^\star-\mathbb E[s_i]\)。下面会看到「检索失败」有两种含义，而它们的阶不同。



      先给干扰项最大值的界。设 \(X_1,\dots,X_m\)（\(m=n-1\)）各自 \(\sigma\)-次高斯，即 \(\mathbb E[e^{\lambda X_i}]\le e^{\lambda^2\sigma^2/2}\)。对任意 \(\lambda>0\)：

      \[ \begin{aligned} e^{\lambda\,\mathbb E[\max_i X_i]}&\le\mathbb E\big[e^{\lambda\max_i X_i}\big]=\mathbb E\big[\max_i e^{\lambda X_i}\big]\\ &\le\sum_{i=1}^{m}\mathbb E\big[e^{\lambda X_i}\big]\le m\,e^{\lambda^2\sigma^2/2}, \end{aligned} \]
      \[ \mathbb E[\max_i X_i]\le\frac{\ln m}{\lambda}+\frac{\lambda\sigma^2}{2} \;\xrightarrow{\;\lambda=\sqrt{2\ln m}/\sigma\;}\;\sigma\sqrt{2\ln m}. \]
      三步分别用了：Jensen（\(e^{\lambda\cdot}\) 凸）、把 max 放大成求和（对非负项成立）、次高斯的矩母函数定义。**全程没用到独立性**——放大成求和对任意相关结构都成立，这是次高斯界比经典极值理论更好用的地方。对 i.i.d. 高斯这个界在首阶上是紧的。



      **判据 A（秩判据）：目标是不是最大的那个。**同样的 Chernoff 论证给 \(\Pr[\max_i X_i\ge t]\le m\,e^{-t^2/2\sigma^2}\)，令其 \(\le\delta\) 得 \(t=\sigma\sqrt{2\ln(m/\delta)}\)。于是要以 \(1-\delta\) 概率让目标排第一：

      \[ \Delta_{\mathrm A}(n,\delta)\;\ge\;\sigma\sqrt{2\ln\frac{n-1}{\delta}}\;=\;\Theta\!\big(\sqrt{\ln n}\big). \]
      量纲自查：\(\sigma\) 与 \(\Delta\) 都是 logit（nat），\(\ln\) 的自变量 \((n-1)/\delta\) 是纯数，两边一致。**这就是「\(\sqrt{\ln n}\)」的来源——而它回答的是一个比我们真正关心的问题弱得多的问题。**



      **秩正确 ≠ 读得出来。**取 \(n=2^{20}\approx1.05\times10^6\)、\(\sigma=2\)。此时 \(\mathbb E[\max_i X_i]\approx10.53\)；设 \(s^\star=11.0\)，目标是**严格 argmax**。但 softmax 分母中干扰项之和约 \((n-1)e^{\sigma^2/2}\approx7.75\times10^6\)，而 \(e^{11.0}\approx5.99\times10^4\)：

      \[ a^\star\approx\frac{5.99\times10^4}{5.99\times10^4+7.75\times10^6}\approx0.0077. \]
      **目标稳居第一，却只拿到 0.77% 的权重。**head 的输出是**加权平均**，此时 \(\mathbf o\) 里 99.2% 来自那一百万个干扰 value，目标的 value 根本没被读出来。**这一步是本节与「极值理论标准结论」分道扬镳的地方**：极值理论管「谁最大」，softmax 管「占多大份额」，后者才是 attention 实际使用的量。



      **判据 B（读出判据）：目标要占住足够份额。**记 \(Z=\sum_{i\ne\star}e^{X_i}\)，则 \(\dfrac{1-a^\star}{a^\star}=\dfrac{Z}{e^{\Delta}}\)。由次高斯性 \(\mathbb E[Z]\le(n-1)e^{\sigma^2/2}\)，再用 Markov：以至少 \(1-\eta\) 概率 \(Z\le(n-1)e^{\sigma^2/2}/\eta\)。要求 \(a^\star/(1-a^\star)\ge\rho\)：

      \[ \Delta\;\ge\;\underbrace{\ln (n-1)}_{\text{随长度增长}}+\frac{\sigma^2}{2}+\ln\rho+\ln\frac1\eta\;=\;\Theta(\ln n). \]
      机制是**指数放大**：分母是 \(n\) 个指数之和，要压住一个线性增长的分母，分子必须**指数级**地大，也就是 logit 必须**线性**增长。量纲自查：\(\sigma^2/2\) 是 \(\ln\mathbb E[e^{X}]\) 的上界，仍是 nat；\(\ln\rho\)、\(\ln(1/\eta)\) 是纯数的对数。**这里同样没用到独立性**，只用了 \(\mathbb E[e^{X_i}]\le e^{\sigma^2/2}\)；独立性只在把 Markov 换成集中不等式以收紧 \(\ln(1/\eta)\) 时才需要。



      **判据 B′（向量抵消修正）：干扰的 value 会不会互相抵消？**把输出拆成信号与噪声 \(\mathbf o=a^\star\mathbf v^\star+\sum_{i\ne\star}a_i\mathbf v_i\)。若干扰 value **零均值、各向同性**、\(\mathbb E\|\mathbf v_i\|^2=V^2\)，则

      \[ \mathbb E\Big\|\sum_{i\ne\star}a_i\mathbf v_i\Big\|^2=V^2\!\!\sum_{i\ne\star}a_i^2\approx V^2\frac{(1-a^\star)^2}{n-1}, \]
      要求信噪比 \(a^\star\sqrt{n-1}/(1-a^\star)\ge\rho\)，得

      \[ \Delta\;\ge\;\tfrac12\ln(n-1)+\frac{\sigma^2}{2}+\ln\rho. \]
      抵消把系数从 1 砍到 \(\tfrac12\)，**但没有改变阶**。而且零均值这条假设在真实模型里很可疑：value 存在很大的公共分量（massive activation / attention sink[@src-9f2f8008d0][StreamingLLM]），\(\mathbb E[\mathbf v_i]=\bar{\mathbf v}\ne\mathbf 0\) 时公共分量**不抵消**，噪声退回 \((1-a^\star)\|\bar{\mathbf v}\|\)，系数回到 1。**所以真实系数落在 \([\tfrac12,1]\)，取哪端都是 \(\ln n\)。**



      **三个判据的定量对照**（\(\sigma=2,\rho=1\)，忽略 \(\eta\) 项）：

| | (n) | (\ln n) | A：(\sigma\sqrt{2\ln n}) | B：(\ln n+\tfrac{\sigma^2}{2}) | B′：(\tfrac12\ln n+\tfrac{\sigma^2}{2})

| | 1 K | 6.93 | 7.45 | 8.93 | 5.47

| | 32 K | 10.40 | 9.12 | 12.40 | 7.20

| | 128 K | 11.78 | 9.71 | 13.78 | 7.89

| | 1 M | 13.86 | 10.53 | 15.86 | 8.93

| | 10 M | 16.17 | 11.37 | 18.17 | 10.08

      **本节采用判据 B**，因为 head 的输出是加权平均而非 argmax，「排第一但权重 0.8%」在下游不可用。**结论：间隔须随 \(\ln n\) 而非 \(\sqrt{\ln n}\) 增长。**这个定阶能和一个独立的公开结果对上：Veličković 等人的 Lemma 2.1「softmax must disperse」给出 \(a_k\le\frac1n e^{\delta/\theta}\)（\(\delta\) 为 logit 极差、\(\theta\) 为温度），要维持 \(a_k\ge\tau\) 就必须 \(\delta\ge\theta(\ln n+\ln\tau)\)——**同样是 \(\ln n\) 线性**。[@src-b347f72a06][Softmax is not Enough, ICML 2025]



      **★能不能反过来推出「存在临界长度」？不能，除非再加假设。**要有临界 \(n\)，必须有 \(\Delta\) 的上界。把 logit 拆开：

      \[ |s_i|=\frac{\big|\langle W_Q\mathbf x_q,\;W_K\mathbf x_i\rangle\big|}{\sqrt{d_h}}\le\frac{\kappa_Q\kappa_K\,\|\mathbf x_q\|\,\|\mathbf x_i\|}{\sqrt{d_h}}. \]
      RMSNorm 保证每维均方为 1，故 \(\|\mathbf x\|\le\sqrt d\,\|\gamma\|_\infty\)，于是

      \[ \Delta\;\le\;2\,\kappa_Q\,\kappa_K\,\|\gamma\|_\infty^{2}\,\frac{d}{\sqrt{d_h}}. \]
      **这个上界里有两个因子归一化完全管不着**：算子范数 \(\kappa_Q,\kappa_K\) 与 gain \(\|\gamma\|_\infty\)，二者都是可训练参数，**原则上随训练无界增长**。这不是理论洁癖：Zhai 等人实测到训练中 attention logit 的谱范数持续增长并导致熵坍缩（entropy collapse），而他们的修法**正是显式加谱归一化**（σReparam）——**若归一化自动提供了约束，就不需要这个修法**。[@src-fed4ebad73][Zhai et al., ICML 2023] **所以：不存在通用临界长度 \(n_{\mathrm{crit}}\)；「无论训练多久都不可能」这类断言是错的，本节不做这种断言。**



      **要谈有限上界，必须显式追加下列假设之一——并看清它给出的数量级。**取 \(d=4096,d_h=128,\sigma=2,\rho=1\)，按判据 B 反解 \(n_{\mathrm{crit}}=e^{\Delta_{\max}-\sigma^2/2}\)：

| | 追加的假设 | (\Delta_{\max}) | (n_{\mathrm{crit}})

| | 算子范数受限 (\kappa_Q\kappa_K\le0.02) | 14.5 | (2.6\times10^{5})

| | 同上，但 (\kappa_Q\kappa_K\le0.03) | 21.7 | (3.7\times10^{8})

| | QK-normalization（Gemma 3 明确使用），gain 取 1 | 22.6 | (9\times10^{8})

| | logit soft-capping（Gemma 2 明确使用，(c=50)） | 100 | (\sim10^{42})

      QK-norm 把 \(|s|\) 压到 \(\sqrt{d_h}\|\gamma_q\|_\infty\|\gamma_k\|_\infty\)[@src-cf5ce22f4d][Gemma 3]（注意 gain 仍可学，所以它也不是无参数的硬界）；soft-capping 用 \(s\leftarrow c\tanh(s/c)\) 把 \(|s|\) 压在 \(c\) 内，Gemma 2 自注意力取 \(c=50.0\)[@src-0c32b54fd7][Gemma 2]。**这张表最重要的信息在后三行**：QK-norm 与 soft-capping 对应的 \(n_{\mathrm{crit}}\) 比任何现实上下文长度**大好几个数量级**，**它们不可能是任何现实性能悬崖的原因**。只有第一行能落到 \(10^5\)–\(10^6\)，而它依赖一个**外部完全观察不到**的 \(\kappa\)——\(\kappa\) 从 0.02 改到 0.03，\(n_{\mathrm{crit}}\) 就跳三个数量级。



      **最后自查：这个模型自己能不能造出一个悬崖？**设间隔在样本间有分布 \(F\)，成功率 \(=1-F(\theta(n))\)，\(\theta(n)=\ln n+\sigma^2/2+\ln\rho\)。从 128K 到 1M：

      \[ \Delta\theta=\ln\frac{2^{20}}{2^{17}}=\ln 8=2.08\ \text{nat}\quad(\text{判据 A 仅}\ 0.82\ \text{nat}). \]
      **要被解释的观测量必须重新定义一次**——因为公开材料里**不存在 128K 的 pointwise 值**，「128K→1M 的落差」这个量**外部算不出来**（详见本节开头的噪声地板 callout）。能被解释的只有**绝对水位**：1M 档 8 针合成分 26.3%，按独立近似折成 per-needle 是 \(0.263^{1/8}=84.6\%\)；而 8 针噪声地板 15% 折成 per-needle 是 \(0.15^{1/8}=77.8\%\)。
        **也就是说，模型在单针水平上距离「随机」只有约 6.8 个百分点。**要靠 2.08 nat 的阈值移动把 per-needle 推到这个位置，logistic 型间隔分布的尺度须窄到 \(s\approx1\) nat 量级。

      **这是本节最该被记住、也是它推翻自己的一条。**\(\ln n\) 增长得**极慢**——1K 到 1M 一共才涨 6.9 nat，128K 到 1M 只涨 2.08 nat（约 15%）。
        **而所需的那个「间隔分布很集中」的假设，是为对上观测而拟合出来的，不是模型预测出来的。**
        还有一条更硬的自证伪：**同一个模型对 Flash 线应当给出接近的预测，而 Flash 线在同一格上是 54.0%——是 Pro 线的两倍**。位置无关的稀释模型解释不了这个差。**所以本节只能给「机制上说得通」，给不出「就是它」。**

• 最强的一条：干扰 logit 的次高斯参数 (\sigma) 与 (n) 无关。真实语料里上下文越长，「看起来也像答案」的干扰越多，(\sigma) 会随 (n) 上升，阈值增长会快于 (\ln n)——本节定阶是下界，不是精确刻画。

• 单头、单层、full softmax。真实模型有 (L\times h) 个头可分工（粗筛头 + 精读头），多层可做两跳检索，因此这个模型系统性偏悲观。

• 目标 logit (s^\star) 与 (n) 无关，且目标唯一——多针任务不满足后者。

• 步 (6) 的抵消论证假设干扰 value 零均值各向同性，真实模型不满足（见该步说明）。

• 步 (8) 假设 RMSNorm 把 (|\mathbf x|) 精确压到 (\sqrt d)，忽略 (\epsilon) 项与残差流的尺度漂移。

• 步 (9) 的 (d=4096,d_h=128,\kappa=0.02) 与全节演示用的 (\sigma=2,\rho=1) 都是为演示挑的数值，不是任何 Gemini 模型的披露值；Gemini 的宽度、头维、是否用 QK-norm 或 soft-capping，官方一律未公开。

• 步 (10) 的 logistic 间隔分布是为拟合观测而选的函数形式，没有独立证据支持。

• 标准 softmax：无 attention sink 专用槽、无 off-by-one、无推理期自适应温度。任何一个都会改变结论。

• **本节不给通用上限。**没有「算子范数有界 / QK-norm / soft-capping / 固定温度」四条之一，就没有 (n_{\mathrm{crit}})。「无论训练多久都不可能」是错的。

• 而四条里 QK-norm 与 soft-capping 给出的 (n_{\mathrm{crit}}) 都在 (10^8) 以上，解释不了 (10^5)–(10^6) 处的任何现象。

• 模型是位置无关的，解释不了图 6.10 的 U 形，也解释不了为何 Flash 线（54.0%）在 1M 上好过 Pro 线（26.3%）——同一机制对两条线的预测应当接近。

• 现代长上下文实现不是 full attention。Gemma 3 用 5:1 的局部滑窗／全局层交错，滑窗层的有效 (n) 是窗口宽度而非序列长度，稀释只作用在稀疏的全局层上（滑窗与外推的关系见 B2）。若 Gemini 采用类似结构（官方未披露），本节模型只对少数层适用。

• KV cache 与显存／带宽是另一本账，不在本节射程内；成本侧见 基础设施章关于 KV cache 与长上下文服务的一节。

• 外置检索（RAG）把 (n) 换成召回窗口大小，整体绕开这个机制——这也说明注意力稀释不是一个必须在架构内解决的问题。

    在「干扰 logit 为 \(\sigma\)-次高斯、目标 logit 固定、单头 full softmax」三条显式前提下：**秩判据**要求 \(\Delta\gtrsim\sigma\sqrt{2\ln n}\)，**读出判据**要求 \(\Delta\gtrsim c\ln n+\sigma^2/2\)（\(c\in[\tfrac12,1]\)）。attention 输出是加权平均，故取读出判据：**间隔必须随 \(\ln n\) 线性增长**。而 \(\Delta\le2\kappa_Q\kappa_K\|\gamma\|_\infty^2 d/\sqrt{d_h}\) 中的算子范数与 gain **不受 LayerNorm / RMSNorm 约束**，因此**不存在通用临界长度**；只有额外假设算子范数有界、QK-norm、logit soft-capping 或固定温度，才谈得上有限的 \(n_{\mathrm{crit}}\)。且 \(\ln n\) 增长极慢（128K→1M 仅 2.08 nat），**稀释本身不足以产生观测量级的性能悬崖**。

  softmax 的注意力预算恒等于 1，这不是实现缺陷，是归一化的定义。key 越多，每个分到的越薄。Veličković 等人把它证成了定理：在 logit 有界的前提下，softmax head 的系数随 (n\to\infty) 必然弥散，(a_k=\Theta(1/n))。^[2][Veličković et al., 2025] 值得注意的是那条前提是从「词表有限 ⇒ 特征落在紧集 ⇒ logit 有界」推出来的，不是从 LayerNorm 推出来的；而这个界依赖训练出来的权重，所以它给出的临界规模随训练可变——这正是本节反复强调的那条边界。

  第二层：极值理论与 softmax 管的是两件事。「谁最大」是秩问题，代价 (\sqrt{\ln n})；「占多大份额」是质量分配问题，代价 (\ln n)。混起来会把长上下文的难度低估到平方的量级。步 (4) 那个算例——严格 argmax 却只有 0.77% 权重——是这个区别最直观的形态。

  **第三层，也最反直觉：(\ln n) 慢得离谱。**上下文放大 8 倍，阈值只升 2 nat。**所以「注意力被稀释」根本不足以解释断崖式的分数下跌。**真正的陡峭必须来自别处：间隔分布的形状、训练分布在超长区间的稀疏、评测的合成口径。本节这一版的结论与上一版相反——上一版把稀释当成硬约束，这一版的算术表明它更像一个温和的背景斜坡。

  **图 6.11** Gemini 1.5 报告里长上下文「真的有用」的证据：**两个并排面板**——左为 *Cumulative Average NLL for Long Documents*（\(R^2=0.997\)），右为 *Cumulative Average NLL for Code*（\(R^2=0.995\)）；每个面板三条序列（Gemini 1.5 Flash / Gemini 1.0 Pro / Gemini 1.5 Pro）加一条 power law 拟合虚线。累积平均 NLL 随 token 位置**单调下降**。
    （**本轮开图核对时发现本地这张图是裁切版，横轴刻度被切掉了**，因此「一路延伸到百万量级」这一点**无法从本地图上直接读出**，只能依据报告正文；本图注据此已删去该表述作为图上证据。）
    **但它与 MRCR 的 26.3% 并不矛盾，因为两者量的不是同一件事。**NLL 是**均值**指标，由海量容易 token（虚词、重复实体、局部话题一致性）主导，模型靠「越读越知道这篇在说什么」就能把它压下去；找到第 7 根针则是**尖峰**能力，要求某个 head 在一百万个 key 里把权重集中到一个位置上。**平均 NLL 下降，不等于能锁定第 7 根针**——均值指标对尖峰能力几乎不敏感，这是长上下文评测里最常被混淆的一处。[@src-79a8d5beef]出处：Gemini 1.5 技术报告，2024

  先把话说死：以下全部是假说，不是原因。在上述 toy model 的示例参数下（(d=4096,d_h=128,\sigma=2,\rho=1,\kappa_Q\kappa_K\approx0.02)），临界规模落在 (2.6\times10^5)，位于 128K 与 1M 之间。这提供了一个可能的机制解释，但没有任何因果证据，也不能排除数据分布、长上下文训练时长、评测构造等其它解释。

  ★而且「悬崖就在 128K 与 1M 之间」这个前提本身是可疑的，必须写出来。MRCR 的出处论文 Michelangelo（arXiv:2409.12640，Google DeepMind 自己做的）报告的曲线形状是：所有前沿模型都有一次发生在短上下文的急剧超线性下跌，此后曲线趋于平坦；论文甚至有一节标题直写 Gemini’s Non-Decreasing Performance from 128K to 1M^[3][Michelangelo]。 如果这个形状可以外推，那么衰减主要发生在 32K 之前，本节把临界点定位在 (10^5)–(10^6) 之间就找错了地方。 （同时必须给出这条反证自己的边界：Michelangelo 测的是 2024 年的 Gemini 1.5、用的是原版 MRCR、画的是累计曲线——这三点没有一点与 3.1 Pro 的 8 针 pointwise 相同，因此它不能被直接外推成后者的曲线。它能做的是动摇「悬崖在 128K 之后」这个前提，不能证明悬崖在 32K 之前。）

  **而且这个「量级吻合」的证据强度接近于零，理由一并写出。**五个参数无一有公开值，全是为对上量级挑的；其中 (\kappa_Q\kappa_K) 从 0.02 挪到 0.03，临界规模就从 (2.6\times10^5) 跳到 (3.7\times10^8)——三个数量级。一个能被单个不可观测参数的 50% 变化推翻三个数量级的「吻合」，只能当量级自洽性检查，不能当证据。

  一个有意思的对账，同样只是观察，不是因果。Gemini 3 Pro / 3.1 Pro 的 API 定价切在 200K：输入 ≤200K 时每百万 token 2.00 美元，>200K 时 4.00 美元，且一旦越线整个请求（含输出）都按长上下文价计。^[4][Gemini API 定价] 而本节的 toy model 把临界规模也放在 (10^5) 量级——两个位置相近。这可能意味着定价分档挂在某个内部工程分档上（例如 KV cache 分片策略或服务分层），也可能纯属巧合。现有公开证据不足以判定，本材料不做因果解释。 （注意这个对账已经比上一版弱了一档：上一版写的是「MRCR 的性能悬崖出现在 128K 之后，与定价悬崖位置相近」，而按上面 Michelangelo 那条，「悬崖在 128K 之后」这个前提本身不牢，所以现在只能拿 toy model 的临界规模去对，而 toy model 的参数又是拟合出来的——这条对账的证据强度因此接近于零，保留它只是为了记录这个巧合，不是为了论证。）

  代际对账只能这样写：Pro 线严格是 2.5 Pro 16.4% → 3 Pro 26.3% → 3.1 Pro 26.3%，后两代未动（不是「三代零进步」）；同期 Flash 线从 26.6% 涨到 54.0%。 由于 3.6 Flash 模型卡已标明是 8-needle，这两条线在这一格上是同口径可比的——所以「1M 低分是全模型共有的能力上限」这个读法已被同口径证据排除。 但要立刻补上边界：可比的只有 MRCR 这一格；3.6 > 3.1 仍然是命名错位，不能推广成「Flash 整体比 Pro 强」。

  本节的解释可能是错的。下面五条替代解释都不需要动用注意力稀释，而且按现有公开证据，前两条的解释力很可能强于本节的机制模型。

  **① 那个「悬崖」在数值上根本没有确定形状。**本节想解释的对象，长期以来被写成「从 128K 到 1M 掉了 58.6 个百分点」——而这个量不存在：它是累计平均减逐点值，且公开材料里没有 128K 的 pointwise 值。 **所以严格说，本节此前是在为一个算不出来的落差建模型。**改用噪声地板之后，能被解释的对象只剩「绝对水位距随机约 11pp」这一条，而稀释模型对绝对水位没有预测力（它只预测随 (n) 的相对变化）。这一条本身就足以让本节的机制模型退到「定性说明」的位置。

  **② 多针合成放大。**8 针合成指标会把 per-needle 的小幅不完美放大成看起来灾难性的分数：per-needle 84.6% 合成出来就是 26.3%，per-needle 77.8%（噪声地板）合成出来是 15%。 也就是说，26.3% 与「随机」之间在单针水平上只差约 6.8 个百分点，而在合成分上看起来差 11 个百分点、在直觉上看起来差得更多。 合成指标把一个中等程度的单针退化，显示成了一个断崖。（此折算依赖「各针独立」，MRCR v2 的打分细则官方未完整披露，故为量级估计。）

  ③ 训练分布在超长区间稀疏。>128K 的自然长文档极少，超长训练样本多半靠拼接与合成，模型在那个区间没见过足够多「跨百万 token 的真实依赖」——这是数据问题而非注意力容量问题。这条可证伪：若某模型仅靠在超长真实文档上继续训练就显著抬高 1M 分数，本节的机制解释就被削弱。3.6 Flash 的 54.0% 在这个方向上是值得追的线索。

  ④ 评测构造本身偏难。MRCR 的干扰项是刻意构造成与目标高度相似的（同类请求的多个版本），这恰好把上面模型里的 (\sigma) 顶得很高。此时分数衡量的是评测的对抗强度而非上下文长度本身；换一个干扰更弱的长上下文任务，同一模型的曲线形状可能完全不同。

  **⑤ 架构可能根本不是 full attention。**若采用局部滑窗与全局层交错（Gemma 3 是 5:1），绝大多数层的有效 (n) 是窗口宽度，压根不经历 (\ln n) 的增长，稀释只作用在少数全局层。Gemini 的注意力结构官方从未披露，所以本节把它当 full attention 建模这一步本身就没有依据。

  **最后是对本节自身的元批判。**用一个自建的稀释模型去解释一个官方公布的分数，天然有「先看到答案再挑参数」的风险，步 (9) 那张临界规模表正是在这种风险下写出来的。本节的价值应当被限定在「解释名义长度与有效长度为什么会分开」这个定性问题上；至于 26.3% 为什么是 26.3%，现有公开证据不足以判定，本材料也不打算判定。

  把 B17 写成「1M 低分的**机制解释**」**本身就抬高了它的地位**。按现有公开证据，它**不是**最有解释力的那个候选，甚至进不了前两名——它只是本章唯一能写成公式的那个。
  
  **三条硬证据都指向别处，而不是指向注意力稀释：**
  
    **其一，同厂同口径的反证。**Flash 线在 1M pointwise 上两个月内 26.6%→54.0%。**稀释模型是位置无关、与模型规格无关的**，它对两条线应给出接近的预测——**解释不了两倍的差，也解释不了两个月的变化**（架构在两个月内不会重做，训练配方会）。
  
    **其二，出处论文的曲线形状。**Michelangelo 报告衰减集中在短上下文、**128K 到 1M 之间不降**——若可外推，本节把临界点定位在 \(10^5\)–\(10^6\) 就找错了位置（作用域限制见上方「落到 Gemini」）。
  
    **其三，模型自身的参数敏感性。**\(\kappa_Q\kappa_K\) 变化 50%，结论跨三个数量级。**一个能被单个不可观测参数推翻三个数量级的模型，不具备与数据竞争的分辨率。**
  
    相比之下，失效边界 ③（**超长区间训练分布稀疏**）与 ④（**评测对抗性构造**）都不需要动用任何注意力机制，**且都能自然解释 Flash 线的两个月翻倍**（改训练数据与改后训练配方都在两个月的可行范围内）。
  
  **本节的机制模型仍然成立的条件很具体，不是「它错了」这么简单：**
    ① Gemini 实际使用**接近 full attention** 的全局层（若为 5:1 交错，大多数层的有效 \(n\) 是窗口宽度，稀释根本不发生）；
    ② 干扰 logit 的分布尺度确实窄到 \(s\approx1\) nat 量级；
    ③ 观测到的低分主要来自**读出**失败而非**检索**失败。**这三条目前一条都无法从公开材料验证。**
  
  正方改写归因之争 **反方赢了排序，但没有赢得答案——这两件事必须分开。**
  
    **① 反方赢的部分：**本节此前的定位（「1M 低分的机制解释」）应当整体降级为「**一个在前提被满足时才成立的定性说明**」，
      **并且要明说它在候选列表里排不进前两名**。本轮已在「落到 Gemini」与失效边界里执行；上方章末的空洞 4 也已补上「Flash 线证据方向上削弱 B17」。
  
    **② 反方没有赢的部分——这一条是本轮最要紧的自检。**
      「训练分布稀疏」与「评测构造偏难」**同样没有被证明**：前者没有任何一方公布过 >128K 区间的训练数据构成，后者没有 MRCR v2 的逐 bin 曲线。
      **它们现在只是更简约的竞争解释，不是已识别的真因。**
      **本节因此不设新答案**：把 B17 从「解释」降到「候选之一」，然后诚实地停在「四个候选，零个被识别」。
      （自检问题：我是在说 B17 不够充分，还是在说训练数据才是答案？——只能是前者。推翻一个解释，不等于证明了另一个。）

  交互 6-A · 拖动滑杆：KV cache 显存如何吃掉一颗芯片

  这张图把 B1 的结论变成可以拨弄的东西。三条曲线分别是全局 MHA、全局 GQA、 GQA + 5:1 局部/全局交错。把上下文拖到 1M，会看到第一条曲线早就冲出了任何单芯片的 HBM 容量； 而交错方案之所以有效，是因为在 5:1 的配比下每六层里有五层（六分之五）根本不需要保存全长的 K/V。

    KV cache 显存 vs 上下文长度
    拖动滑杆改变 KV 组数、并发数、窗口与精度
  
  
  
  
  
    固定 \(L=64\)、\(h_q=64\)、\(d_h=128\)，这是一组**显式声明的通用 Transformer 配置，不是 Gemini 的参数**（官方未披露）。
    公式见 B1：\(M_{\mathrm{KV}}=2LBn\,h_{kv}d_h s\)；交错方案按 \(L_g n+L_l\min(n,w)\) 计。
    横线为 **TPU 8i 单芯片 288 GB HBM** 的官方规格
    （[@src-7fcb28f154]Google Cloud, 2026-04-22，
    **已官宣、截至 2026-07-25 尚未 GA**）。

  组 2 · 稀疏与路由

  这一组回答同一个问题的三个侧面：当一个模型「知道很多但每次只想一点」时，代价具体记在哪本账上。B3 处理路由本身——为什么一个不可导的负载统计乘上一个可导的软概率就能训练 router；B4 处理路由的硬边界——专家容量是编译器逼出来的，而不是数学要求的；B18 把三者合账，说明总参数、每 token 激活参数、FLOPs、通信字节是四件必须分开报告的事，把它们混成一个 (k/E) 比例正是上一版材料虚构「万亿参数、千亿成本」的根源。

  Switch 原文与本项目的独立裁定文件都用 (N) 表示专家数，而组 3 的 (N) 表示参数量。为免混淆，组 2 全部改用 (E) 表示专家数、(k) 表示每 token 激活的专家数；凡引用原式处会同时给出原记号。

  **Gemini 的 MoE 配置官方从未公开。**专家数、(k)、capacity factor、用 token-choice 还是 expert-choice、有没有辅助损失、激活参数量——一个都没有。Gemini 1.5 技术报告只确认了一句「Gemini 1.5 Pro is a sparse mixture-of-expert (MoE) Transformer-based model」^[5][Gemini 1.5]，Gemini 1.0 报告连 MoE 都没提。本组所有具体数字来自 GLaM / Switch / GShard / ST-MoE / DeepSeek-V3 / Gemma 4 这些有公开出处的模型，不是 Gemini 的架构披露，也不可用来反推 Gemini。

  B3 · Sparse MoE 的 top-k 门控与负载均衡辅助损失

  一句话。top-k 门控用不可微的 argmax 把 token 分给少数专家，负载均衡损失用「不可导的实际负载 × 可导的平均软概率」把梯度接回 router；它是一个 piecewise-smooth 的代理目标，有效，但并不像 Switch 原文所说的「在均匀分布处取到最小值」——本节给出反例。

  **图 6.13** 稀疏门控 MoE 层：gating network 输出**稀疏**权重，落选专家既不算也收不到梯度——本节全部复杂度都源于这个「梯度断口」。 [@src-4fc64bb81f]出处：Sparsely-Gated MoE, 2017
  
  
  
  
    B3
    Top-k 门控与 Switch 的辅助损失
    Shazeer et al., 2017 · arXiv:1701.06538 ／ Fedus et al., 2021 · arXiv:2101.03961
  
  
  
  
  
      符号表

| | (T,,E,,k) | batch / router group 内 token 数；专家数（标量）；每 token 激活专家数 | Switch (k=1)，GShard (k=2)

| | (E_i(\cdot)) | 第 (i) 个专家网络，与标量 (E) 同字母（沿用 Switch 记法），靠下标与括号区分 | (\mathbb R^d\to\mathbb R^d)

| | (x_t,,W_r) | token 表示；router 权重 | (\mathbb R^d,\ \mathbb R^{E\times d})

| | (z_{ti},,p_{ti}) | router logit；softmax 软概率 | (\sum_ip_{ti}=1)

| | (\mathcal S_t,,g_{ti}) | top-k 专家集合；重归一后的 combine weight | (|\mathcal S_t|=k)

| | (f_i) | 硬路由到专家 (i) 的 token 比例，停止梯度 | (\sum_if_i=1)

| | (P_i) | 专家 (i) 的平均软概率，可导 | (\sum_iP_i=1)

| | (\alpha,,\beta) | 辅助损失 / z-loss 系数 | (10^{-2}) / (10^{-3})

逐步推导 · 共 11 步（点击展开）

      前向：线性 router 打分、softmax、取 top-k、在选中的 \(k\) 个上重归一、加权求和。

      \[ z_{ti}=(W_rx_t)_i,\qquad p_{ti}=\frac{e^{z_{ti}}}{\sum_{j=1}^{E}e^{z_{tj}}},\qquad \mathcal S_t=\operatorname{TopK}(p_t,k), \]
      \[ g_{ti}=\mathbf 1\{i\in\mathcal S_t\}\frac{p_{ti}}{\sum_{j\in\mathcal S_t}p_{tj}},\qquad y_t=\sum_{i=1}^{E}g_{ti}E_i(x_t). \]
      **教学标准形式，非实现披露**：真实系统可能不重归一、加噪声探索 [@src-4fc64bb81f][Shazeer17]、设 capacity factor 丢弃溢出 token、或挂一个恒激活的 shared expert。**Gemini 的专家数、\(k\)、激活率官方从未披露。**



      为什么要外加损失？落选专家收不到梯度，被多选中的专家又学得更快、更容易再被选中，rich-get-richer 的终点是 routing collapse。Switch 的补法是 **top-1** 形式的辅助损失——硬负载 \(f\)、软概率均值 \(P\)：

      \[ f_i=\frac1T\sum_{t=1}^{T}\mathbf 1\{\arg\max_j p_{tj}=i\},\qquad P_i=\frac1T\sum_{t=1}^{T}p_{ti},\qquad \boxed{\;L_{\mathrm{aux}}=\alpha E\sum_{i=1}^{E}f_iP_i\;} \]
      Switch Eq. 4–6 [@src-bf9cd21d7a][Switch]，原文 \(\alpha=10^{-2}\)。\(f\)＝实际发生了什么，\(P\)＝router 想要什么，这个区分是全节枢纽。



      唯一严格成立的等式：均匀路由 \(f_i=P_i=1/E\) 代入即得 \(L_{\mathrm{aux}}=\alpha E\cdot E\cdot\frac1{E^2}=\alpha\)，前置因子 \(E\) 的作用正是让这个值不随专家数变化。

      但它只说明「均匀点的值是 \(\alpha\)」，**没有说明 \(\alpha\) 是最小值**——混淆二者的后果见第 (6) 步。



      top-k 的扩展**不止一种，且与 top-1 原式不等价**。常见写法把指示改成「是否进入 top-k」并除以 \(k\)：

      \[ f_i^{(k)}=\frac1{kT}\sum_{t=1}^{T}\mathbf 1\{i\in\mathcal S_t\},\qquad \sum_i f_i^{(k)}=1 . \]
      GShard 的 top-2 改用**实际 dispatch count** \(c_i/T\) 乘平均 gate \(m_i\) [@src-d9fce71dac][GShard]，统计的是容量截断后真正被处理的 token。动机相同，**数值与梯度都不同**，不能把 top-1 原式冒充唯一的 top-k 标准式。



      **近似动机。**先设 \(f\approx P\)，则 \(L_{\mathrm{aux}}\approx\alpha E\sum_iP_i^2\)。对这个**代理量**用 Cauchy–Schwarz \(\big(\sum_iP_i\cdot1\big)^2\le E\sum_iP_i^2\)，代入 \(\sum_iP_i=1\)：

      \[ \sum_{i=1}^{E}P_i^2\ \ge\ \frac1E \quad\Longrightarrow\quad \alpha E\sum_iP_i^2\ \ge\ \alpha,\quad\text{等号当且仅当 }P_i\equiv\tfrac1E. \]
      不等式没问题，问题在它约束的对象：**这是代理量的下界，不是真实损失 \(\alpha E\,f^\top P\) 的下界**。\(f\approx P\) 只在两个极端成立——\(p_t\) 接近 one-hot 时它**精确**成立，接近均匀时两者都 \(\approx1/E\)；**中间地带可以严重背离**。



      **★反例：\(\alpha E\,f^\top P\) 可以低于 \(\alpha\)。**取 \(E=2,\,T=4\)：三个 token 的软概率为 \(p=(0.5001,\,0.4999)\)，第四个为 \(p=(0.0001,\,0.9999)\)。用分数逐项复算（无舍入）：

      \[
      \begin{aligned}
      f&=(0.75,\ 0.25),\quad P_1=\tfrac{3\times0.5001+0.0001}{4}=0.3751,\quad P_2=\tfrac{3\times0.4999+0.9999}{4}=0.6249,\\
      E\,f^\top P&=2\times(0.75\times0.3751+0.25\times0.6249)=2\times0.43755=\mathbf{0.8751}\ \lt\ 1 .
      \end{aligned}
      \]
      同一组数代入代理量却是 \(E\sum_iP_i^2=2\times(0.3751^2+0.6249^2)=1.06240004\ \ge\ 1\)。

      **两个量在同一点上分居 1 的两侧**，这是「代理量的下界不能搬给真实量」最干净的证明。\(f\) 递减而 \(P\) 递增，二者**反序**，切比雪夫和不等式方向随之反转，「\(f\) 与 \(P\) 同序（comonotone）故 \(L_{\mathrm{aux}}\ge\alpha\)」的论证在此失效。直觉：**重载专家是「险胜」来的，轻载专家是「压倒性胜出」的**，排序被拧反。



      那真实损失**有没有**下界？有，但不是 \(\alpha\)。被选中者的概率必为最大值，故 \(p_{t,a_t}\ge1/E\)，只保留自己那批 token 的贡献即得 \(P_i\ge f_i/E\)；代入后再用一次 Cauchy–Schwarz：

      \[ E\sum_i f_iP_i\ \ge\ \sum_i f_i^2\ \ge\ \frac1E \quad\Longrightarrow\quad \boxed{\;L_{\mathrm{aux}}\ \ge\ \frac{\alpha}{E}\;} \]
      该界严格成立（20 万组随机配置数值复核无一违反），量级上也接近可达：让 \(r\) 个专家零负载、其余均分，可构造出 \(Ef^\top P=\frac{E}{(r+1)(E-r)}\)，最低约 \(4/E\)。**「有全局下界 \(\alpha\)」不只是未经证明，偏差可达 \(E/4\) 倍。**



      真正解释它**为什么有用**的是梯度。把 \(f_i\) 视为 stop-gradient 常数，只有 \(P_i\) 传梯度，且 \(\frac{\partial P_i}{\partial z_{tj}}=\frac1T\frac{\partial p_{ti}}{\partial z_{tj}}\)。代入 softmax Jacobian \(\frac{\partial p_{ti}}{\partial z_{tj}}=p_{ti}(\mathbf 1\{i=j\}-p_{tj})\)：

      \[
      \begin{aligned}
      \frac{\partial L_{\mathrm{aux}}}{\partial z_{tj}}
      &=\frac{\alpha E}{T}\sum_i f_i\,p_{ti}\big(\mathbf 1\{i=j\}-p_{tj}\big)
      =\frac{\alpha E}{T}\Big(f_jp_{tj}-p_{tj}\sum_i f_ip_{ti}\Big)\\
      &=\boxed{\;\frac{\alpha E}{T}\,p_{tj}\Big(f_j-\sum_i f_ip_{ti}\Big)\;}
      \end{aligned}
      \]
      关键是 \(f_i\) 被当成常数抽到求和号外，否则 \(\arg\max\) 处处不可导，式子根本写不出来。



      读这个式子。记 \(\bar f_t=\sum_i f_ip_{ti}\)（以当前 token 路由概率为权的平均负载），梯度符号完全由 \(f_j-\bar f_t\) 决定，且逐 token 零和：\(\sum_j\partial L_{\mathrm{aux}}/\partial z_{tj}=\frac{\alpha E}{T}(\sum_jp_{tj}f_j-\bar f_t)=0\)。

      **竞争性**：负载高于 \(\bar f_t\) 的专家梯度为正、logit 被压低，低于的被抬高；零和说明它只**重新分配** logit，不改变整体水位。**前置因子 \(p_{tj}\)**：router 本来就不打算选的专家几乎不被推动——惩罚精准落在「真的想选它」的 token 上，代价是**死掉的专家很难被它救活**。



      为什么「不可导的 \(f_i\) 乘可导的 \(P_i\)」仍然有效？四条理由：(i) \(f_i\) 是**测量值**（已经发生了什么），只需要值不需要导数；(ii) \(P_i\) 是**控制变量**（router 能连续调什么），梯度经它回到 \(W_r\)；(iii) 若两者都用 hard top-k，目标几乎处处分段常数、**梯度恒为 0**；(iv) 只约束 \(P_i\) 则软概率均衡并不保证 capacity 截断后的**实际 dispatch** 均衡。

      代价是 \(f\) 在 logit 排名跨界时跳变：这是 **piecewise-smooth 的代理优化**，不是对离散负载的精确微分，也不保证收敛到均衡。



      配套的 **router z-loss**（ST-MoE）压住 logit 幅度以稳定训练。记 \(\mathrm{LSE}_t=\log\sum_ie^{z_{ti}}\)，由 \(\partial\mathrm{LSE}_t/\partial z_{tj}=p_{tj}\)：

      \[ L_z=\frac1T\sum_{t=1}^{T}\mathrm{LSE}_t^2,\qquad \frac{\partial L_z}{\partial z_{tj}}=\frac2T\,\mathrm{LSE}_t\,p_{tj},\qquad L=L_{\mathrm{LM}}+\alpha L_{\mathrm{aux}}+\beta L_z . \]
      动机是 router 只关心 argmax，整体放大 logits 不改变排序却会让数值精度与梯度一起恶化 [@src-28a00f0094][ST-MoE]。但上式有个推论：单步更新后 \((z_{tj}-z_{tk})\) 的变化量为 \(-\frac{2\eta}{T}\mathrm{LSE}_t(p_{tj}-p_{tk})\)，**正比于概率差**，\(\mathrm{LSE}_t\gt0\) 时**压缩** logit 间距。所以 z-loss 并非「对相对 logits 中性」，只是小步长下通常不翻转排序。

• batch / router group 足够大，(f_i) 才是稳定的负载估计；小 batch 下抽样噪声可能盖过真实不均衡。

• (f_i) 被显式 stop-gradient；若框架对 argmax 做了松弛，本节梯度式不适用。

• 损失每个 MoE 层各算一份再相加；跨层共用一个 (\alpha) 隐含「各层不均衡程度可比」。

• (\alpha/E) 下界依赖 top-1 与 softmax 归一（用到 (p_{t,a_t}\ge1/E)）；(k\ge2) 或 sigmoid affinity 须重推。

• **它不保证收敛到均衡。**硬分配在 logit 排名跨界时不连续，目标是分段光滑的代理；反例说明均匀点甚至不是全局最小点，写成「保证均衡」在任何配置下都过强。

• 它只促使数量均衡，不管专家是否学到不同语义、是否分到同等难度的 token。

• capacity overflow、token dropping 与设备拓扑会使「路由比例均衡 ≠ 运行时间均衡」，wall time 另见 B19。

• (\alpha) 两难：偏小压不住 rich-get-richer，偏大挤占主任务 loss；Switch 的 (10^{-2}) 是在其规模与数据上扫出来的，换配置未必仍合适。

• top-k、shared expert、expert-choice、无辅助损失路线都会改变合适的辅助项；现有证据不足以判定哪种在超大规模下普遍更优。

• Gemini 用不用这一族辅助损失、系数几何，官方从未披露；不能由「Google 发明了它」推断「Gemini 在用它」。

    \(L_{\mathrm{aux}}\) 的梯度 \(\frac{\alpha E}{T}p_{tj}(f_j-\bar f_t)\) 是一个以「概率加权平均负载」为基准、在专家间零和再分配 logit 的竞争机制。均匀路由时其值恒为 \(\alpha\)，但 \(\alpha\) **不是**全局下界——反例给出 \(0.8751\alpha\)，严格下界只有 \(\alpha/E\)；「\(\ge\alpha\)」只对代理量 \(\alpha E\sum_iP_i^2\) 成立。
  
  
  
  
  
  
  
  **图 6.14** Switch 的 top-1 路由：门控值同时充当输出缩放系数——正因为它**乘在输出上**，router 才能从主任务 loss 拿到梯度，辅助损失只是额外一条通路。 [@src-bf9cd21d7a]出处：Switch Transformer, 2021

  它到底在说什么。MoE 要解一个组合优化问题——把 (T) 个 token 分给 (E) 个专家且各家工作量相当——但反向传播只处理连续变量，于是把不可微的部分冻成常数（(f)），把可微的部分留作把手（(P)），让它们相乘。梯度式刻画了这个把手：它是相对竞争而非绝对配额，基准线由当前 token 自己的偏好加权决定。优雅与局限是同一件事：正因为惩罚被 (p_{tj}) 加权，它才不骚扰无关专家；也正因如此，彻底死掉的专家几乎收不到复活信号——真正把模型从坍缩里拉回来的往往是初始化尺度、噪声门控与 capacity 这些损失之外的机制。

  Gemini 从 1.5 起自述为 sparse MoE Transformer，技术报告把 Shazeer 2017 到 ST-MoE 整条谱系逐一点名 ^[5][Gemini 1.5]，但专家数、(k)、激活率、辅助损失系数，官方一个数字都没给过。可引用的公开锚点只有三组：GLaM 的 1.2T 总参 / 96.6B 激活 / 64 专家 / top-2 ^[6][GLaM]；Switch 的 top-1 / 1.6T；Gemma 4 的 26B-A4B——25.2B 总参 / 3.8B 激活 / 128 专家取 8 + 1 个 shared expert。只有最后一组是 Google 自家的开源模型，但它与 Gemini 是两条产品线，不能互相代入。工程侧的账见基础设施章。

  **图 6.15** 稀疏模型训练不稳定的**两个并排面板**（图上无 (a)(b) 标号、无图例）——**注意两者纵轴量程差了约 44 倍，必须分开读，不能叠看**。**左面板（纵轴 0–350）**是发散的那一次：loss 在 13000 步前一直贴底在个位数（10500 步附近只有一个约 10 的小鼓包），此后毫无征兆地垂直拉升，14500 步冲到约 **340**。**右面板（纵轴 1–8）**是正常收敛的那一次：从 8.0 一路降到约 **1.7**。两图并置说明发散是随机发生、事前无预兆的。**⚠️ 至于把病因定位到 router logits 的无界增长、以及用 z-loss 压制——这两点在 ST-MoE 论文正文，不在本图上**：图里既没有 router logits 曲线，也没有开/关 z-loss 的对照，**本图不能作为该因果链的证据**（它与负载均衡是两个问题这一点同样出自正文）。另：论文图注行被裁掉，因此**图上也没有任何文字说明这两次 run 用的是同一份配置**。 [@src-28a00f0094]出处：ST-MoE, 2022，图 1

  被判错的一步，以及它的来历。本节最初的版本声称 (f) 与 (P) 同序，据此用切比雪夫和不等式证明 (L_{\mathrm{aux}}\ge\alpha)，第 (6) 步的反例推翻了它。值得指出的是这个错误并非本材料首创——Switch 原文在 Eq. 4–6 之后写道「the auxiliary loss of Equation 4 encourages uniform routing since it is minimized under a uniform distribution」^[7][Switch, JMLR v23]。按字面读这句话不成立：均匀分布是「标称值 (\alpha)」的所在，不是全局最小点。可辩护的读法是把它理解成对代理量 (\alpha E\sum_iP_i^2) 的陈述，但原文没加这个限定。

  这在实践中有多要紧？反例要求重载专家的 token 全停在决策边界上，是刻意构造的位形，训练中未必自发停留。更公允的判断是：不是「Switch 的损失不 work」，而是「它 work 的理由是梯度结构，不是那条不等式」。但训练早期 logits 尚未分化、或 z-loss 系数偏大把 logits 压得过平时，router 会较长时间处在「险胜」区域，背离可能不再可忽略。

  另外两条不宜照抄的说法。其一，z-loss「不干扰 logits 之间的相对大小」——第 (11) 步显示它按 (p_{tj}) 加权地压缩间距，中性只在「不翻转排序」这个弱得多的意义上成立。其二，「三项式 (L_{\mathrm{LM}}+\alpha L_{\mathrm{aux}}+\beta L_z) 是所有生产级 MoE 的标配」——DeepSeek-V3 的主路线改用逐专家偏置项（按过载/欠载动态增减，只影响 top-k 选择、不进入门控值），辅助损失退化为系数极小的序列级兜底项 ^[8][DeepSeek-V3]，依据是「辅助损失过大会损害模型质量」^[9][Loss-Free Balancing]。这条线上存在两种并行路线，哪种更优现有证据不足以判定；Gemini 走哪条同样未披露。

  B4 · Capacity factor 与 token dropping 的期望丢弃率

  一句话。专家容量是 TPU 静态编译逼出来的硬上限；在均匀路由假设下 CF=1 的丢弃率只有 (0.4/\sqrt{\mu})，真实系统却能丢 20%–40%——这五个数量级的落差说明不均衡不是统计问题，是学习动力学问题。

    B4
    专家容量、期望丢弃率与 padding 浪费
    Lepikhin et al., 2020 · arXiv:2006.16668 ／ Fedus et al., 2021 · arXiv:2101.03961 ／ Zhou et al., 2022 · arXiv:2202.09368
  
  
  
  
      符号表

| | (T) | 一个 batch（或 routing group）的 token 总数 | 正整数

| | (E) | 专家数 | 正整数

| | (\mathrm{CF}) | capacity factor | (\ge1)，典型 1.0 / 1.25 / 2.0

| | (C) | 每个专家的容量上限，(C=\mathrm{CF}\cdot T/E) | 正整数（实现上取整）

| | (\mu) | 每专家期望负载 (T/E) | 正实数

| | (X_i) | 路由到专家 (i) 的 token 数（随机变量） | (0\le X_i\le T)

| | (\sigma) | (X_i) 的标准差，(\sqrt{\mu(1-1/E)}) | 正实数

| | (z) | 标准化阈值 ((C-\mu)/\sigma) | 实数

| | (\phi,\Phi) | 标准正态的密度与累积分布函数 | —

| | (q_i) | 真实（非均匀）路由到专家 (i) 的概率 | (\sum_i q_i=1)

逐步推导 · 共 13 步（点击展开）

      先问「为什么会有容量这个东西」。答案不在数学里，在编译器里：**TPU 与 XLA 要求张量形状在编译期静态确定**，而路由决策是运行时才知道的。工程上的唯一出路是给每个专家预分配一个固定大小的 buffer：

      \[ C=\underbrace{\frac TE}_{\mu}\times\mathrm{CF}. \]
      超出 \(C\) 的 token 被「丢弃」——不是真的扔掉，而是**跳过这一层的 FFN，直接由残差连接传到下一层**，相当于这一层对它是恒等映射。MoE 的定义里没有任何东西要求每个专家处理固定数量的 token；capacity factor 纯粹是一个编译器约束的产物。



      建立最简概率模型：假设每个 token 独立、均匀地路由到 \(E\) 个专家之一。

      \[ X_i\sim\operatorname{Binomial}\!\Big(T,\frac1E\Big),\qquad \mathbb E[X_i]=\mu,\qquad \operatorname{Var}(X_i)=\mu\Big(1-\frac1E\Big). \]
      专家 \(i\) 的溢出量是 \((X_i-C)^+\)，全 batch 的期望丢弃率为
      \[ \mathbb E[\text{drop}]=\frac1T\sum_{i=1}^{E}\mathbb E\big[(X_i-C)^+\big]=\frac ET\,\mathbb E\big[(X-C)^+\big]=\frac1\mu\,\mathbb E\big[(X-C)^+\big]. \]
      第二个等号用了对称性：均匀假设下所有专家同分布，所以只需算一个。



      用正态近似。当 \(\mu\) 较大时 \(X\approx\mathcal N(\mu,\sigma^2)\)。令 \(u=(x-\mu)/\sigma\)、\(z=(C-\mu)/\sigma\)：

      \[ \mathbb E\big[(X-C)^+\big]=\int_C^{\infty}(x-C)\frac1\sigma\phi\Big(\frac{x-\mu}\sigma\Big)dx =\int_z^{\infty}(\sigma u+\mu-C)\,\phi(u)\,du . \]
      换元把上下限从 \((C,\infty)\) 变成 \((z,\infty)\)，被积函数拆成「\(\sigma u\phi(u)\)」和「常数 \(\times\phi(u)\)」两块，各有闭式。



      两项分别积。第一项用 \(\phi'(u)=-u\phi(u)\)，即 \(\int u\phi(u)\,du=-\phi(u)\)：

      \[ \sigma\int_z^{\infty}u\phi(u)\,du=\sigma\big[-\phi(u)\big]_z^{\infty}=\sigma\phi(z). \]
      第二项是 \(-(C-\mu)\int_z^\infty\phi(u)du=-(C-\mu)\big(1-\Phi(z)\big)\)。合并：
      \[ \mathbb E\big[(X-C)^+\big]=\sigma\,\phi(z)-(C-\mu)\big(1-\Phi(z)\big),\qquad z=\frac{C-\mu}{\sigma}. \]
      这正是精算与期权定价里的「看涨期权期望收益」，形式与 Bachelier 模型一致——溢出量就是以容量为行权价的看涨期权。



      于是丢弃率的通式为（代入 \(C-\mu=(\mathrm{CF}-1)\mu\)）：

      \[ \mathbb E[\text{drop}]=\frac{\sigma\phi(z)-(\mathrm{CF}-1)\mu\big(1-\Phi(z)\big)}{\mu},\qquad z=\frac{(\mathrm{CF}-1)\mu}{\sigma}. \]
      注意 \(z\) 只依赖 \((\mathrm{CF}-1)\sqrt\mu\) 这一个组合量（因为 \(\sigma\approx\sqrt\mu\)）。这解释了为什么「合适的 CF」不是一个常数，而是随 \(1/\sqrt\mu\) 变化的量。



      一个漂亮的特例：\(\mathrm{CF}=1.0\)。此时 \(C=\mu\)、\(z=0\)，第二项整个消失，\(\phi(0)=1/\sqrt{2\pi}\)：

      \[ \mathbb E[\text{drop}]\Big|_{\mathrm{CF}=1}=\frac{\sigma\phi(0)}\mu=\frac{\sqrt{\mu(1-1/E)}}{\mu\sqrt{2\pi}}\approx\frac1{\sqrt{2\pi\mu}}\approx\frac{0.399}{\sqrt\mu}. \]
      丢弃率只按 \(\mu^{-1/2}\) 衰减——这是中心极限定理的直接后果，相对涨落 \(\sigma/\mu\sim\mu^{-1/2}\)。



      推论：**专家越多，丢弃越严重。**把 \(\mu=T/E\) 代回：

      \[ \mathbb E[\text{drop}]\Big|_{\mathrm{CF}=1}\approx0.399\sqrt{\frac ET}. \]
      固定 \(T=32768\) 个 token：

| | 专家数 (E) | (\mu=T/E) | CF=1.0 理论丢弃率

| | 64 | 512 | 1.75%

| | 256 | 128 | 3.50%

| | 2048 | 16 | 9.97%

      这是一个**结构性张力**：MoE 的吸引力来自「专家越多、总参数越多」，但专家越多每个专家的期望负载越小、相对涨落越大、丢弃越严重。要维持同样的丢弃率，**batch 必须随 \(E\) 线性增长**——这解释了为什么大规模 MoE 训练要用百万 token 量级的 batch，也解释了为什么 MoE 在**推理**时（batch 小几个数量级）的负载均衡问题远比训练时棘手。这一条会在 B18 的「三重惩罚」里再次出现。



      代入具体数值（\(E=64\)，容量取整）。下表用的是正态近似；在 \(\mu\) 较大时它与精确二项分布相当接近，
        但**尾部相对误差随 \(z\) 增大而变差**，所以这些数字应当读成量级而不是精确值：

| | (\mu) | CF | 容量 (C) | (\sigma) | (z) | 丢弃率

| | 128 | 1.00 | 128 | 11.22 | 0.00 | 3.50%

| | 128 | 1.05 | 134 | 11.22 | 0.53 | 1.64%

| | 128 | 1.25 | 160 | 11.22 | 2.85 | 0.006%

| | 512 | 1.00 | 512 | 22.45 | 0.00 | 1.75%

| | 512 | 1.25 | 640 | 22.45 | 5.70 | (\lt 10^{-6})

| | 2048 | 1.00 | 2048 | 44.90 | 0.00 | 0.87%

| | 2048 | 1.25 | 2560 | 44.90 | 11.40 | 数值上为零

      读这张表要读出的是：在均匀路由假设下，**CF=1.25 已经是极度奢侈的**——它把阈值放到 \(5.7\sigma\) 之外。



      但实测完全不是这样。Switch 报告的丢弃率是「典型 \(\lt1\%\)」，Expert Choice 报告的 over-capacity ratio 却高达 **20%–40%**。与上表的 \(10^{-6}\) 相差五个数量级。**说明均匀假设错了，而且错得离谱。**真实 router 有强烈偏好（某些专家吸引标点、数字、特定语言），此时丢弃率的主导项不再是随机涨落，而是系统性偏差：

      \[ \mathbb E[\text{drop}]\approx\sum_{i=1}^{E}\Big(q_i-\frac{\mathrm{CF}}{E}\Big)^{+}. \]
      这是一个 \(O(1)\) 的量，**与 \(\mu\) 无关——加大 batch 完全救不了它**。步 (6)–(8) 算出的不是「预测」，而是**理论下界**。



      把偏斜程度参数化（\(q\sim\text{Dirichlet}(\kappa\mathbf 1)\)，\(E=64\)，300 次采样平均）可以看出量级：

| | 路由偏斜程度 | CF=1.0 | CF=1.25 | CF=2.0

| | 完全均匀（(\kappa\to\infty)） | 0.00% | 0.00% | 0.00%

| | 轻微偏斜（(\kappa=50)） | 5.63% | 0.31% | 0.00%

| | 中度偏斜（(\kappa=10)） | 12.37% | 4.49% | 0.09%

| | 强偏斜（(\kappa=3)） | 22.33% | 13.22% | 2.65%

      **这张表是构造出来的模型，不是从真实 router 统计出来的**（见假设第 4 条），只用于说明「偏斜导致 \(O(1)\) 丢弃」这个定性机制和量级。强偏斜下的 13%–22% 与 Expert Choice 实测的 20%–40% 量级吻合。**辅助损失（B3）的全部工作，就是把系统从「强偏斜」那一行推回「轻微偏斜」甚至「完全均匀」那一行。**



      另一半账：padding 浪费。设专家 \(i\) 实际收到 \(X_i\) 个 token，被浪费在 padding 上的算力比例是

      \[ \text{waste}=\frac{\sum_i\big(C-\min(X_i,C)\big)}{E\cdot C}=1-\frac{\sum_i\min(X_i,C)}{\mathrm{CF}\cdot T}. \]
      在均匀极限下 \(X_i\approx\mu\)、\(\min(X_i,C)=\mu\)，于是
      \[ \text{waste}\approx1-\frac{E\mu}{\mathrm{CF}\cdot T}=1-\frac1{\mathrm{CF}}. \]
      **CF=1.25 浪费 20%，CF=2.0 浪费 50%。**这是个残酷的账：为了把丢弃率从 1.7% 压到接近零，你付出了 20% 的算力。**丢弃率与浪费率是同一枚硬币的两面**——CF 就是在两种纯损耗之间取舍的旋钮。



      实测对照（Switch 论文 Table 1，Switch-Base）：

| | CF | 吞吐（样本/秒） | 质量（负对数困惑度）

| | 2.00 | 860 | −1.554

| | 1.25 | 910 | −1.553

| | 1.00 | 1000 | −1.561

      CF 从 2.0 降到 1.25，速度涨 6%、质量不变；再降到 1.0，速度涨 16% 但质量掉了。理论上 CF 从 2.0 降到 1.0 应省 50% 的专家算力，实测只涨 16%——差距是因为专家 FFN 只占整层的一部分（这一点在 B18 会被量化）。Switch（top-1）在低 CF 下表现更好，因为 top-1 天然只需要一半 buffer。



      理解了 \(1-1/\mathrm{CF}\) 这道税，就能理解 2024 年后所有人都想废掉 capacity factor 的三条路线：

• Megablocks（2022）：用块稀疏矩阵乘法替代 dense 分组 GEMM，允许每个专家的 batch 大小不同——从编译层面消灭「静态形状」这个前提，既不丢 token 也不 padding。代价是需要定制 kernel。

• Expert Choice（见 B3）：用配额制保证 (X_i\equiv C)，浪费率与丢弃率同时恒为 0。代价是破坏因果性，不能用于自回归解码。

• DeepSeek-V3 的无辅助损失均衡：路由用 (z_i+b_i) 排序但门控值仍用 (z_i)，每步之后按负载在线调整 (b_i)。它把均衡从「梯度惩罚」降级为「控制器反馈」，因此完全不干扰主损失的梯度。

      三条路线的共同点是：**它们都不再试图把不均衡「优化掉」，而是改变问题的表述使不均衡不再造成代价。**

• 步 (2) 假设 token 之间独立路由。真实序列里相邻 token 高度相关（同一句话常路由到同一专家），实际方差远大于二项分布的预测——这是真实丢弃率高于理论下界的又一个原因。

• 正态近似要求 (\mu) 足够大。它对中心区域拟合良好，但尾部（也就是我们真正关心的丢弃事件）的相对误差会随 (z) 变大， 需要精确数值时应当直接用二项分布的尾和，而不是查正态表。

• 模型假设 top-1 路由。top-k 时每个 token 占 (k) 个槽位，等效 (\mu\to k\mu)，容量需相应放大——这正是 Switch 说「top-1 的 buffer 可以减半」的意思。

• 步 (10) 的 Dirichlet 偏斜模型是为了量化影响而构造的，不是从真实 router 统计出来的，只作机制与量级的说明。

• 丢弃率与浪费率都按「专家 FFN 的算力」计，不含 attention、router、通信。

• 丢弃的危害程度没有被这个模型刻画。被丢的 token 走残差直连，少量丢弃可能无害甚至有正则化效果；但若系统性地总丢同一类 token（比如稀有语言），损害会集中在特定能力上而不体现在平均困惑度里——这是一个 metric 盲区。

• 训练与推理的 CF 常常不同（ST-MoE 用 train CF=1.25 / eval CF=2.0），存在 train–test 失配。

• Switch 自己试过 No-Token-Left-Behind（把溢出 token 依次路由到第二、第三选择），结果没有任何收益。解释是：一旦模型学到了 token–专家的关联，强行改变这个关联反而更糟。这是一个反直觉但重要的负面结果——「丢弃」未必比「错误分配」更差。

• 现代方案很多已经绕开容量，所以「capacity factor 与 token dropping」在今天更像一个历史概念——但理解它才能理解后来的方案为什么要那样设计。

• **Gemini 是否 drop token：无任何公开信息。**Gemini 1.5 报告确认了 MoE，但没有提 capacity factor、没有提 token dropping、没有提路由策略。

    均匀路由下 \(\mathbb E[\text{drop}]\big|_{\mathrm{CF}=1}\approx0.399/\sqrt\mu\)，且随专家数按 \(\sqrt{E/T}\) 增长；但真实丢弃由路由偏斜主导，是一个与 batch 大小无关的 \(O(1)\) 量。而抑制丢弃的代价是 \(1-1/\mathrm{CF}\) 的 padding 浪费。**丢弃与浪费是同一枚硬币的两面，CF 只是那个旋钮。**
  
  
  
  
  
  
  
  **图 6.16** **两个并排面板**（图上无 (a)(b) 标号）。**左面板**是专家数的 scaling 收益：横轴为稀疏模型参数量（对数轴），点上逐个标注专家数，Test Loss 从 1e 的约 6.00 单调降到 256e 的约 4.84（4e≈5.70、16e≈5.28、64e≈5.01），且**降幅逐档收窄**。**右面板**是样本效率：纵轴 **Neg Log Perplexity（负对数困惑度，越高越好，因此曲线是上升的）**对训练步数（0–45 万步），Switch-Base 的 16e / 32e / 64e / 128e 四条曲线**全程高于 T5-Base**，45 万步时分别约为 −1.42 / −1.37 / −1.33 / −1.31，而 T5-Base 约 −1.56。把左面板和步 (7) 的表对照着看最有意思：**专家数既是收益的来源，也是丢弃率的来源**。**⚠️ 注意「等算力 / FLOP 对齐」是论文的实验设定，图面上并没有标出来。**[@src-bf9cd21d7a]出处：Switch Transformers（Fedus, Zoph, Shazeer），2021，图 1

  **它到底在说什么。**capacity factor 在数学上毫无必要——MoE 的定义里没有任何东西要求每个专家处理固定数量的 token。它纯粹是因为 TPU + XLA 要求编译期静态张量形状而被逼出来的。一个纯粹的编译器约束，最后变成了一个影响模型质量的超参数，还催生了辅助损失、No-Token-Left-Behind、Expert Choice 一整套算法研究。而步 (8) 与步 (10) 两张表的五个数量级落差告诉我们一件更深的事：**MoE 的负载不均衡不是统计问题，是学习动力学问题。**你不能靠「多给点 buffer」解决它，因为 router 的偏好是被梯度主动塑造出来的，它会主动填满你给的任何 buffer——就像修更宽的路不会缓解拥堵，因为需求会诱导性增长。真正的解法要么是收税（辅助损失），要么是改规则（配额制）。

  这一节对理解 Gemini 的价值不在「Gemini 的 CF 是多少」（未披露），而在它解释了为什么 Google 会走上和别人不一样的 MoE 路线。Megablocks 这类块稀疏 kernel 是 GPU 侧对静态形状约束的正面突破，而 Google 手里是 TPU + XLA：静态形状既是负担（逼出了 capacity factor），也是压力源（逼出了 Expert Choice 这种改问题表述的解法）。同样重要的是步 (7) 那个 (\sqrt{E/T})：推理时 (T) 比训练小几个数量级，同一个模型在服务端的负载均衡难度天然高一到两个量级。这条不等式会在 B18 里长成三重惩罚，最后长成第八代 TPU 为什么要分裂成两颗芯片。

  步 (8) 那张表最容易被误用成「所以 CF=1.25 就够了」。它是理论下界，不是预测值；真实丢弃率高出它 2–3 个数量级。反过来，步 (10) 的 Dirichlet 表也不能当成实测——它是一个构造的偏斜模型。两张表放在一起唯一稳健的结论是定性的：丢弃率由偏斜而非涨落主导，因此加大 batch 无效、加辅助损失有效。任何把这两张表的具体数字套到某个闭源模型上的做法都是过度外推。

  B18 · MoE 的 all-to-all 通信量与专家并行 roofline：四件事必须分开报告

  一句话。总参数决定存储、每 token 激活参数决定算术、FLOPs 决定下界时间、all-to-all 字节决定真实时间——四本账各随不同的量增长；而 MoE 的计算/通信比约完之后只剩一个与 batch、专家数、top-k 都无关的量——但它的具体数值取决于你数的是几次 all-to-all，三种口径必须分开报告。

  下面的推导里，「通信量」有三个不同口径，混用会差 2–4 倍：

• 单次 all-to-all：(V_1\approx \mathrm{CF}\cdot kTd\cdot b) 字节。用于分析单个集合通信原语的带宽利用率。

• forward 全量：一个 MoE 层的前向有 dispatch 与 combine 两次 all-to-all，故 (V_{\rm fwd}\approx 2\mathrm{CF}\cdot kTd\cdot b)。本节的 (d_{ff}) 门槛一律采用这个口径。

• 训练全量：反向还要再传一遍梯度，次数与 forward 同阶但常数依实现而定（是否重算、是否融合），不能简单说「比值不变」。

    B18
    总参数 / 激活参数 / FLOPs / 通信字节的四本账，与专家并行的 roofline
    Lepikhin et al., 2020 · arXiv:2006.16668 ／ Du et al., 2021 · arXiv:2112.06905 ／ Jouppi et al., 2023 · arXiv:2304.01433 ／ PaLM FLOPs 口径 · JMLR 24(240)
  
  
  
  
      符号表

| | (L) | Transformer 层数 | 整数

| | (d) | residual / model width | 整数

| | (d_{ff}) | 单个专家的 FFN 中间维 | 整数

| | (m) | 单专家 FFN 的权重矩阵数；普通 FFN 约 2，SwiGLU 类约 3 | 2 或 3

| | (E) | 每个 MoE 层的专家总数 | 整数

| | (k) | 每 token 激活的专家数 | 1–8

| | (P_s) | 每层共享参数：attention、norm 等 | 个

| | (P_e) | 单个专家参数量，(\approx m,d,d_{ff}) | 个

| | (P_r) | router 参数量，(\approx dE) | 个

| | (M) | 专家并行的设备数（专家均分到 (M) 台） | 整数

| | (T) | 每设备本地 token 数 | 整数

| | (b) | 每元素字节数 | bf16 = 2，fp8 = 1

| | (B) | 每设备可用的单向出口带宽 | B/s

| | (F) | 每设备峰值算力 | FLOP/s

| | (\mathrm{CF}) | capacity factor | (\ge1)

| | (D) | 训练 token 总数 | 个

逐步推导 · 共 13 步（点击展开）

      先声明口径，否则后面每个数字都会差 2 倍：**一次乘法加一次加法计 2 FLOPs**。若某个来源采用 fused multiply-add = 1 operation（MAC 计数），它的数字是本节的一半。

      这条声明在 MoE 语境下尤其重要，因为「稀疏度」「激活率」「等效稠密算力」这些词在不同论文里的分母都不一样，不先钉死单位就无法比较。



      **第一本账：总参数。**忽略 bias，\(P_e\approx m\,d\,d_{ff}\)、\(P_r\approx dE\)。若每层都是 MoE 层：

      \[ P_{\text{total}}\approx P_{\text{embed}}+L\big(P_s+E\,P_e+P_r\big). \]
      若只有一部分层是 MoE（GShard、GLaM 都是**隔层**放 MoE），只能在这些层乘 \(E\)，其余层保留 dense FFN。总参数决定的是 **checkpoint 体积、optimizer state、HBM 常驻占用**——它是「存储账」，与单 token 的算术量无关。



      **第二本账：每 token 激活参数。**

      \[ P_{\text{act/token}}\approx P_{\text{embed,used}}+L\big(P_s+k\,P_e+P_r\big). \]
      两个细节最容易错。**其一**：router 为了取 top-k，通常仍要算**全部** \(E\) 个 logit，所以 \(P_r\) **不能**按 \(k/E\) 缩掉。**其二**：embedding 是 lookup 不是 matmul，它算不算「激活参数」必须声明口径，否则小模型的比较会全乱。



      **整体激活比**——这是本节最容易被滥用的一个量：

      \[ \rho_{\text{whole}}=\frac{P_s+kP_e+P_r}{P_s+EP_e+P_r}. \]
      只有当 \(EP_e\gg P_s,P_r\) 时才退化成 \(\rho_{\text{whole}}\approx k/E\)。取 \(P_s/(EP_e)=0.1\)、\(E=64\)、\(k=2\) 并忽略 router：
      \[ \rho_{\text{whole}}=\frac{0.1+2/64}{1.1}=\frac{0.13125}{1.1}\approx11.9\%, \]
      而不是 \(2/64=3.125\%\)。**差 3.8 倍。**
      所以 \(k/E\) 只是 **expert-only 极限近似**，绝不能拿它去乘整个 Transformer 的 FLOPs。共享的 attention、norm、router 一点都不会因为稀疏而消失。



      这不是纸上推演，两个**公开**模型的官方数字就把 \(k/E\) 直接证伪了：

| | 模型 | 总参数 | 每 token 激活 | 实际激活比 | (k/E) | 倍数

| | GLaM（2021）^[6][GLaM] | 1.2T | 96.6B | ≈8.3% | 2/64 = 3.1% | 2.7×

| | Gemma 4 26B-A4B（2026-04） | 25.2B | 3.8B | ≈15.1% | 8/128 = 6.3% | 2.4×

      GLaM 是 64 专家 top-2、32 个 MoE 层且与 dense 层交替；Gemma 4 是 128 专家取 8 再加 1 个 shared expert（把 shared 算进去也只有 \(9/128=7.0\%\)）。**两个公开模型的实际激活比都比 \(k/E\) 高 2 倍以上**，方向与上一步那个 11.9% 的构造算例完全一致。这是对「\(k/E\) 只是 expert-only 近似」最硬的实证。



      **第三本账：FLOPs。**对线性层，前向每个被使用的权重每个 token 约 2 FLOPs；训练再加反向的两个矩阵乘（推导见 B20）：

      \[ C_{\text{fwd,linear}}\approx2D\big(P_s+kP_e+P_r\big),\qquad C_{\text{train,linear}}\approx6D\big(P_s+kP_e+P_r\big). \]
      完整成本还要加上不含参数的那些项：
      \[ C_{\text{train}}\approx C_{\text{train,linear}}+C_{\text{attn}\,n^2}+C_{\text{softmax}}+C_{\text{routing}}+C_{\text{recompute}} . \]
      **对 MoE 最容易犯的两个错误都在这一步**：用 \(6P_{\text{total}}D\) 会严重高估 token matmul；用 \(6(k/E)P_{\text{total}}D\) 又会把共享参数错误地缩掉。正确做法只有一个——**拆项**。



      **第四本账：通信字节。**它**不是 FLOPs**，却常常决定 wall time。dispatch 阶段每个 token 产生 \(k\) 份拷贝、每份 \(d\) 维，本设备总共发出 \(kTd\) 个元素，均匀路由下约 \(1/M\) 落在本地：

      \[ V_{\text{out}}=kTd\cdot\frac{M-1}{M}\ \text{个元素}=kTdb\cdot\frac{M-1}{M}\ \text{字节}. \]
      combine 阶段收回同样体积，所以**一层两次 all-to-all**，单次耗时
      \[ T_{\text{comm}}\approx\frac{kTdb\,(M-1)/M}{B}\ \xrightarrow[M\gg1]{}\ \frac{kTdb}{B}. \]
      加上 capacity factor 后实际搬运量还要乘 \(\mathrm{CF}\)，而其中相当一部分是 padding 的零（B4 步 11）。**CF=1.25 相对 CF=1.0 多付 25% 的通信，这是一笔纯损耗。**



      把计算与通信相除。稳态下每设备收到约 \(kT\) 个 token，每个过一个 \(d\to d_{ff}\to d\) 的两层 FFN，前向 \(2dd_{ff}+2d_{ff}d=4dd_{ff}\) FLOPs，故 \(T_{\text{comp}}=4kTd\,d_{ff}/F\)。于是

      \[ \frac{T_{\text{comp}}}{T_{\text{comm}}}=\frac{4kTd\,d_{ff}/F}{kTdb(M-1)/(MB)}=\frac{4\,d_{ff}\,B}{F\,b}\cdot\frac{M}{M-1}\ \xrightarrow[M\gg1]{}\ \frac{4\,d_{ff}\,B}{F\,b}. \]
      **\(k\)、\(T\)、\(d\) 全部约掉了。**这意味着：增大 batch 不改善通信占比（计算与通信同比例增长）；增加专家数不改善（每个 token 仍只过 \(k\) 个）；提高 top-k 不改善；加宽模型 \(d\) 也不改善。**唯一能改善的是把专家做「胖」（增大 \(d_{ff}\)），或者换更好的互联 / 更弱的算力。**反向传播的 FLOPs 是前向的 2 倍、all-to-all 也多两次，比值不变，所以这个结论对训练全程成立。



      代入真实硬件（bf16，\(b=2\)；\(B\) 取官方标注的「双向 ICI 带宽」折半作为单向出口带宽）。令比值为 1 解出打平所需的 \(d_{ff}\)：

| | 芯片 | (F)（bf16） | ICI 双向 | (B) 取值 | 单次 all-to-all 打平 (d_{ff}) | 整层（2 次）

| | TPU v5p | 459 TFLOPS | 1200 GB/s | 600 GB/s | ≈383 | ≈765

| | TPU v6e | 918 TFLOPS | 800 GB/s | 400 GB/s | ≈1148 | ≈2296

| | Ironwood（v7） | 2307 TFLOPS | 1200 GB/s | 600 GB/s | ≈1922 | ≈3845

      从 v5p 到 Ironwood，**算力涨了 5.03 倍而 ICI 带宽一点没变**（都是 1200 GB/s 双向），于是打平门槛也涨了 5 倍。作为参照，DeepSeek-V3 与 Kimi K2 的单专家 FFN 中间维都是 **2048**——在 v5p 上通信可以被完全掩盖（2048 > 765），在 Ironwood 上则低于打平线 3845，**通信会成为瓶颈**。这解释了为什么「细粒度 MoE（很多个小专家）」这个算法趋势与新一代加速器的方向是**冲突的**。



      一个反直觉的推论：**低精度不改变打平点。**把权重与激活都换成 fp8（\(b=1\)）并用 Ironwood 的 fp8 算力 \(F=4614\) TFLOPS：

      \[ \frac{4d_{ff}B}{Fb}=\frac{4\,d_{ff}\times6\times10^{11}}{4.614\times10^{15}\times1}=\frac{d_{ff}}{1922}, \]
      与 bf16 **完全相同**。
      因为量化同时把通信字节数和算力改善了同样的倍数。要真正改善 MoE 的通信瓶颈，只能**量化通信而不量化计算**（例如 fp8 传输 + bf16 计算），或者提高互联带宽。



      拓扑也进账。设 \(P\) 个节点、每节点发出 \(V\) 字节：

      \[ \text{fat-tree（二分带宽}\propto P\text{）}:\ \frac{PV/2}{P\,b_{\text{link}}/2}=\frac{V}{b_{\text{link}}}\quad(\text{与 }P\text{ 无关}), \]
      \[ \text{3D torus（边长 }s,\ P=s^3,\ \text{二分面链路}\propto P^{2/3}\text{）}:\ \frac{PV/2}{c\,P^{2/3}b_{\text{link}}}\propto V\,P^{1/3}. \]
      代入 TPU v5p 一个完整 pod 的 8960 芯片，\(P^{1/3}\approx20.8\)：**pod 级的全 all-to-all 比小切片慢约 20 倍**。这正是为什么专家并行组在实践中被限制在一个小的 torus 切片内（几十到几百芯片），而不是铺满整个 pod。torus 对 all-reduce 是近乎最优的（ring 算法在 torus 上带宽最优），劣势恰好在 all-to-all——而 MoE 偏偏是 all-to-all 密集的。TPU v4 从 2D torus 升级到 3D torus 的官方理由正是「embeddings processing requires significant all-to-all communication」。



      推理侧的三重惩罚，合起来就是「MoE 推理必须凑大 batch」的完整论证：

• 消息尺寸：all-to-all 耗时是 (\max(\alpha_{\text{lat}},V/B))，(\alpha_{\text{lat}}) 是固定启动延迟。取 (\alpha_{\text{lat}}=5,\mu\text{s})、(B=600) GB/s，则 (V_{\text{crit}}=3) MB；以 (k=8,d=7168,b=2) 算，(T_{\text{crit}}=V_{\text{crit}}/(kdb)\approx26) token/设备。低于这个数，通信时间就被延迟锁死，而计算时间仍在线性下降。

• 容量因子：B4 步 (7) 的 (\sqrt{E/T}) 说明小 batch 下丢弃率暴涨，必须把 CF 提到 2 以上，通信量再翻倍。

• 访存摊销：decode 阶段读权重的成本要被 batch 摊销；而 MoE 更糟——每个专家只被 (kB_{\text{batch}}/E) 个 token 用到，所以摊销所需的 batch 要再乘 (E/k)。以 (E=384,k=8) 算就是 48 倍。

      三者叠加的结论是：**MoE 推理的最优 batch 比稠密模型高一到两个数量级**，而这又与 KV cache 的显存上限直接冲突。这个张力是 MoE 服务化最核心的工程难题，也解释了为什么 MoE 在「高吞吐批处理」场景远比在「低延迟交互」场景划算。
  
  
  
      把四本账并排放在一起，这一节的全部结论就是下面这张表：

| | 账目 | 公式 | 随什么增长 | 它决定什么

| | 总参数 | (P_{\text{embed}}+L(P_s+EP_e+P_r)) | 专家总数 (E) | checkpoint 体积、optimizer state、HBM 常驻

| | 激活参数 / token | (P_{\text{embed,used}}+L(P_s+kP_e+P_r)) | (k)，不随 (E) | 单 token 的算术量、模型「便宜」的程度

| | FLOPs | (6D(P_s+kP_e+P_r)+C_{\text{attn}}+C_{\text{recompute}}) | 激活参数 × token 数 | 算力下界（不是账单、不是 wall time）

| | 通信字节 | 每层 (2\cdot\mathrm{CF}\cdot kTdb,\frac{M-1}{M}) | (k)、(d)、(\mathrm{CF})、设备数 | 真实 wall time、拓扑选择、batch 下限

      四列的增长因子各不相同：只有第一本账随 \(E\) 增长，只有第四本账随 \(\mathrm{CF}\) 和拓扑变化。**把它们合并成一个「稀疏度 \(k/E\)」，就是上一版材料推出「万亿参数、千亿成本」的全部技术原因。**

• 口径声明（最重要的一条）：(T_{\text{comp}}/T_{\text{comm}}) 是 expert-only 口径——分子只计专家 FFN 的 FLOPs，不含 attention、router、LayerNorm；分母只计 MoE 层自身的两次 all-to-all，不含数据并行的 all-reduce、不含流水并行的点对点传输。因此这个比值只在专家 FFN 主导整层计算时才近似成立（典型 MoE 层里 FFN 约占 2/3 算力，所以它是一个偏乐观的估计）。凡引用本节 (d_{ff}) 门槛数字处都必须带上这句声明。

• 均匀路由。真实路由有热点专家，尾部延迟由最忙的设备决定，实际通信时间可能比均值高 1.5–3 倍。

• (B) 取官方「双向 ICI 带宽」的一半——这个折算是一个假设；若官方数字本身已是单向，表中所有 (d_{ff}) 门槛要减半。

• 假设通信与计算可以完全重叠（用 (T_{\text{comp}}/T_{\text{comm}}\ge1) 作为「可掩盖」判据）；实际需要软件流水，且首尾有不可掩盖的部分。

• 专家 FFN 用两层结构。SwiGLU 是三个矩阵，前向变成 (6dd_{ff})，会把打平门槛降到 2/3。

• 一次乘加 = 2 FLOPs。

• 跨 pod 时带宽掉一个量级：TPU v5p 的 DCN 带宽是 50 Gbps/芯片 = 6.25 GB/s，比 ICI 的 1200 GB/s 低约 192 倍。任何跨 pod 的专家并行在通信上都是灾难，所以专家维必须留在 pod 内。

• 推理时消息小到被延迟主导而非带宽主导，(T_{\text{comm}}) 不再随 (T) 线性下降，通信占比暴涨。

• 约分结论假设专家计算是稠密 matmul；grouped GEMM 在专家负载不均时效率会掉。

• 未建模 router 本身的开销（对 (E) 个专家做 softmax、top-k、辅助损失），(E) 很大时不可忽略。

• (d_{ff}) 门槛表的三个数字全部依赖上面那条带宽折算假设与 expert-only 口径，它们是量级判断，不是可以直接引用的硬指标。

    四本账：总参数 \(\propto E\)、激活参数 \(\propto k\)、FLOPs \(=6D\times\)激活参数（再加 attention 与重算）、通信字节 \(\propto \mathrm{CF}\cdot k\cdot d\)（**每层前向两次**）。
      计算/通信比在**单次 all-to-all** 口径下是 \(4d_{ff}B/(Fb)\)，在**forward 全量**（dispatch + combine）口径下减半为 \(2d_{ff}B/(Fb)\)；
      训练全量还要再加反向的传输，常数依实现而定。**三者都与 batch、\(E\)、\(k\)、\(d\) 无关，但门槛值差 2 倍以上，引用时必须写明口径。**
      本节所有 \(d_{ff}\) 门槛数字采用 **forward 全量** 口径。
      另外：**\(k/E\) 只是 expert-only 极限近似，GLaM 与 Gemma 4 的公开数字都比它高 2 倍以上。**
  
  
  
  
  
  
  
  
  **图 6.17** GLaM 的架构：MoE 层与 dense 层**交替**，每 token 取 top-2。正因为交替、且共享 attention 不稀疏，它的实际激活比是 8.3% 而不是 \(2/64=3.1\%\)。[@src-9e69989f50]出处：GLaM（Du et al.），2021
  
  
  
  **图 6.18** GLaM 的学习效率对比，**共 8 个面板（2 行 4 列，(a)–(h)）**：上行 NLG、下行 NLU；每行前三格 (a)(b)(c) / (e)(f)(g) 分别是 Zero-shot、One-shot、Few-shot，**横轴是训练 token 数（×10⁹，100 → 631）**；每行第四格 (d)/(h) 是 *Scaling in TPU years*，**横轴换成 TPU×年（10 → 300，对数）**。实线为 MoE（64B/64E、1.7B/64E、0.1B/64E），虚线为同量级 dense（137B、1.7B、0.1B），六个 token 面板里都另标了 GPT-3 的参照点。读法：同一分数下 MoE 实线所需的 token 数与 TPU-年都明显少于 dense 虚线。**⚠️ 本章上一版说「同一张图里同时画 FLOPs 与 TPU-years」——全图 8 个面板**没有任何一个横轴或纵轴是 FLOPs**，那个并置在图上并不存在。「FLOPs 账与时间账不等价」这个论点本身成立（中间隔着 all-to-all 与 MFU，见本节推导），但**不能引本图作证**；若要用图，只能用 (d)(h) 的 TPU-年横轴去对照正文给出的 FLOPs 数字。**[@src-9e69989f50]出处：GLaM（Du et al.），2021，图 4
  
  
  
  
  
  
  **图 6.19** **两个面板对比同一个 Dot 算子的两种切分方式**（面板标签 (a)(b) 印在图上）。**面板 (a) MPMD**：切分被显式展开成 4 条独立分支，**4 个各自着色的 dot + 4 个 all-reduce**——每个分片是一段不同的程序。**面板 (b) SPMD**：同样的切分只写成一条分支，用两次 *dynamic slice* 取出 M×(K/4) 与 (K/4)×N，汇入**单个 dot 与单个 all-reduce**——所有分片跑同一段程序。读法就是数方框个数：(a) 的程序体积随分片数线性膨胀，(b) 恒定，这正是 SPMD 能扩到上千分片的原因。**⚠️ 图上没有出现「程序员标注」「编译器推导」「capacity factor」中的任何要素**：「代价是通信模式在编译期被固定，因而 capacity factor 必须是静态常数」是本节的推论与 GShard 正文的结论，本图只画出它的结构性原因。（本地图片底部原题注被从中间截断。）[@src-d9fce71dac]出处：GShard（Lepikhin et al.），2020，图 2
  
  
  
  **图 6.20** twisted torus 相对规则 torus 的 all-to-all 吞吐提升（1.63× / 1.31×）。Google 愿意为 all-to-all 单独改拓扑，本身就说明这条通信路径有多贵。[@src-9eee0ed8a5]出处：TPU v4（Jouppi et al., ISCA'23），2023

  它到底在说什么。(\frac{T_{\text{comp}}}{T_{\text{comm}}}=\frac{4d_{ff}B}{Fb}) 这个式子干净得有些残酷：MoE 能不能跑得动，只由硬件的「带宽/算力比」和一个架构超参 (d_{ff}) 决定；你在 batch size、专家数、top-k 上做的所有调优都不改变这个比值。更深的含义是一个行业级的结构性剪刀差：过去五年加速器的算力增长（v5p→Ironwood 的 5 倍）远快于片间带宽增长（0 倍），而 MoE 的算法趋势是细粒度化——(d_{ff}) 从 8192 一路降到 2048。硬件要求 (d_{ff}\ge3845)，算法想要 2048。两个趋势方向相反，这个剪刀差不会自己消失，只能靠三条路化解：提高互联带宽、量化通信而不量化计算、或者接受通信不可掩盖并用更激进的流水重叠。

  这两个公式的最干净落点，是第八代 TPU 为什么要分裂成两颗芯片。Google 在 2026-04 的 Next ‘26 上预览了 TPU 8t（Sunfish，训练）与 TPU 8i（Zebrafish，推理）——已官宣，截至 2026-07 尚未 GA。分裂的逻辑几乎是 B18 与 roofline 的逐条推论：训练侧的主要通信模式是 all-reduce，torus 的邻居通信在这上面近乎最优，所以 8t 保留 3D torus；推理侧的瓶颈是 all-to-all 的延迟与访存带宽，而 torus 的直径成了尾延迟税——官方自己给的数学是，1024 芯片的 8×8×16 torus 直径为 (8/2+8/2+16/2=16) 跳，改用高基数的 Boardfly 拓扑后同样 1024 芯片降到 7 跳（−56%），整体 all-to-all 延迟改善「最高 50%」。更能说明问题的是 8i 的取舍：片上 SRAM 提到 384 MB（Ironwood 的 3 倍）、HBM 带宽 8601 GB/s 高于 8t 的 6528 GB/s，而峰值算力反而更低（10.1 vs 12.6 PFLOPS FP4）。一颗故意牺牲 FLOPS 换带宽的芯片——这是把 B18 的通信账和 decode 的访存账直接刻进硅里。（制程、代工、量产时间等仅有媒体报道，可信度 B。）

  以下是判断，不是事实。Shazeer 2017 → GShard 2020 → Switch 2021 → GLaM 2021 → ST-MoE 2022 → Expert Choice 2022，这条线整条都是 Google 的，Gemini 3 Pro 的模型卡里仍把 Shazeer 2017 列在参考文献第一条。但 Google 从未公开过 Gemini 的 MoE 配置，而 DeepSeek-V3 公开了全部细节（256 专家、每 token 激活 8 个、共享专家、无辅助损失负载均衡，激活率约 5.5%）。我认为原因有三，重要性递减：（a）披露激励相反——Google 用 MoE 服务数十亿用户，架构细节是竞争资产；DeepSeek 用公开架构换取生态影响力与人才。（b）约束不同催生不同创新——DeepSeek 在受限算力下必须把稀疏度推到极限，Google 没有这个压力，可能停在一个更保守、更稳定的配置上；「被卡脖子」是 MoE 极致化的直接原因。（c）Gemma 4 是一个有意思的反证——Google 直到 2026-04 才发布第一个 MoE 的开源 Gemma（26B-A4B），比 Mixtral 晚了两年多，而且它采纳了 DeepSeek 在 DeepSeekMoE 里推广的 shared expert 设计。**这是这条谱系上第一次出现反向流动。**再叠加一个组织事实：Switch 的两位一作 Fedus 与 Zoph 后来都去了 OpenAI，而 Shazeer 本人 2024 年回归 Gemini 任 co-lead 之后，已于 2026-06 再度离职加入 OpenAI。Google 发明了 MoE，训练出了会训 MoE 的人，然后把人送给了对手。

  三条硬边界。其一：(d_{ff}) 门槛表建立在「官方双向 ICI 带宽折半」这个未经确认的折算和 expert-only 口径之上，是量级判断而非可引用的硬指标。其二：(k/E) 永远只是 expert-only 极限近似；任何把 (k/E) 乘到整个模型 FLOPs 上再乘单价得出的「成本」数字都是错的——这正是上一版材料被判为 P0 的那个错误的完整机制。其三：本节所有硬件数字（v5p / v6e / Ironwood / 8t / 8i）都是 TPU 规格，不是 Gemini 的训练配置；Google 从未披露 Gemini 用了多少芯片、哪一代、多长时间。把这些规格和一个假想的参数量相乘去「反推」训练成本，是 B20 会专门警告的事。

  组 3 · Scaling law

  这一组的三个公式在文献里被引用得最多，也被误用得最狠。B20 先把 (C\approx6ND) 的六个 FLOPs 一项项数出来，并明确列出它排除了什么——排除的东西比包含的东西更重要。B5 在这个约束上做完整的拉格朗日，解出带常数的 (N^,D^)，并说明那个著名的「20 tokens/param」其实不是从这套公式来的。B6 追问 Kaplan 与 Chinchilla 相差 0.36 的指数究竟差在哪三个具体的实验设置上。顺序上 B20 必须在 B5 之前，因为 B5 的约束就是 B20 的结论。

  B20 · (C\approx6ND) 的逐项推导，以及它排除了什么

  一句话。前向 (2N)、反向对输入 (2N)、反向对权重 (2N)，合计每 token (6N)——这是一条关于矩阵乘次数的恒等式，不是经验规律；但它排除了 self-attention、embedding/logits、重计算、optimizer、通信，所以它是记账单位与下界，不是账单。

    B20
    训练 FLOPs 的逐项推导与五类修正
    Kaplan et al., 2020 · arXiv:2001.08361 ／ Chowdhery et al., PaLM · arXiv:2204.02311（FLOPs 口径）／ Du et al., GLaM · arXiv:2112.06905
  
  
  
  
      符号表

| | (C) | 训练总 FLOPs | FLOP

| | (N) | 参数量；MoE 用每 token 激活参数 (N_{\text{act}}) | 个

| | (D) | 训练 token 数 | 个

| | (n_{\text{layer}}) | 层数 | 整数

| | (d_{\text{model}}) | 模型宽度 | 整数

| | (n_{\text{ctx}}) | 上下文长度 | 整数

| | (V) | 词表大小 | 整数

| | (x,W,y) | 层输入 / 权重 / 输出，(y=Wx) | —

| | (N_s,N_e,N_r) | MoE 的共享参数 / 单专家参数 / router 参数 | 个

| | (\mathrm{MFU}) | model FLOPs utilization | ((0,1])

逐步推导 · 共 11 步（点击展开）

      基本事实，也是全节唯一的算术前提：一个 \(m\times k\) 矩阵乘 \(k\times n\) 矩阵需要 \(2mkn\) FLOPs。

      输出有 \(mn\) 个元素，每个是长度 \(k\) 的内积 = \(k\) 次乘法 + \((k-1)\) 次加法 \(\approx2k\) 次浮点运算，故总计 \(2mkn\)。**口径声明：一次乘加 = 2 FLOPs。**若来源采用 fused multiply-add = 1 operation，它的数字会是本节的一半——这个 2 倍差异在跨论文比较时是最常见的对不上账的原因。



      **前向：每 token \(2N\)。**考虑一层 \(y=Wx\)，\(W\in\mathbb R^{d_{\text{out}}\times d_{\text{in}}}\)，单 token 时 \(x\in\mathbb R^{d_{\text{in}}}\)。代入 \(m=d_{\text{out}},k=d_{\text{in}},n=1\)：

      \[ \text{FLOPs}_{\text{fwd}}=2\,d_{\text{out}}d_{\text{in}}\cdot1=2\,|W| . \]
      对所有层求和：**每 token 每参数恰好 2 FLOPs**，总计 \(2N\)。注意 \(N\) 在这里的严格含义是「参与 matmul 的权重个数」，不是「模型文件里的浮点数个数」。



      **反向：每 token \(4N\)。**反向传播要算两件事，各自恰好是一次矩阵乘：

      \[ \frac{\partial L}{\partial x}=W^{\top}\frac{\partial L}{\partial y}\ :\ (d_{\text{in}}\times d_{\text{out}})\times(d_{\text{out}}\times1)\ \Rightarrow\ 2\,d_{\text{in}}d_{\text{out}}=2|W| , \]
      \[ \frac{\partial L}{\partial W}=\frac{\partial L}{\partial y}x^{\top}\ :\ (d_{\text{out}}\times1)\times(1\times d_{\text{in}})\ \Rightarrow\ 2\,d_{\text{out}}d_{\text{in}}=2|W| . \]
      两项各 \(2N\)，合计 \(4N\)。**「反向是前向的 2 倍」不是经验规律**，而是因为反向必须同时回答两个问题——「误差怎么继续往前传」和「这个权重该怎么改」——每个问题一次矩阵乘，而前向只有一次。



      合计：

      \[ C\approx\underbrace{2N}_{\text{fwd}}+\underbrace{2N}_{\partial L/\partial x}+\underbrace{2N}_{\partial L/\partial W}=6N\ \text{FLOPs / token},\qquad C=6ND . \]
      PaLM 论文的原话口径是「2N forward + 4N backward，**excluding self-attention**」。这句 excluding 必须原样保留——它不是免责声明，它是这个公式成立的定义域。



      **明示它排除了什么。**这是全节最重要的一步：

• self-attention 的 (QK^\top) 与 (AV)——它们不消耗参数，所以不在 (6N) 里；

• embedding / 输出 logits / softmax / LayerNorm / 激活函数；

• activation checkpointing 的重算（常额外增加一次 forward）；

• optimizer update（Adam 的一阶/二阶矩更新）；

• padding、稀疏 kernel 的低利用率；

• 数据 / 模型 / 流水线并行的通信——它根本不是 FLOPs。

      因此 \(6ND\) 适合**数量级估计与 compute-optimal 分析**，不是账单、不是 wall time、也不是任意 MoE 的精确公式。把它当成「下界与记账单位」是唯一稳健的读法：它给出「至少需要这么多算力」，其余修正项全部往上加。
  
  
  
      **修正 (a)：attention。**每层每个 query token，\(QK^\top\) 与 \(n_{\text{ctx}}\) 个 key 各做一次 \(d_{\text{model}}\) 维内积 = \(2n_{\text{ctx}}d_{\text{model}}\)；\(AV\) 同样 \(2n_{\text{ctx}}d_{\text{model}}\)。因果掩码下平均每个位置只看一半，故前向每 token 每层约 \(2n_{\text{ctx}}d_{\text{model}}\)，加反向共 \(6n_{\text{layer}}n_{\text{ctx}}d_{\text{model}}\)。占比：
  
      \[ \frac{C_{\text{attn}}}{C_{\text{param}}}=\frac{6\,n_{\text{layer}}n_{\text{ctx}}d_{\text{model}}}{6N}=\frac{n_{\text{layer}}n_{\text{ctx}}d_{\text{model}}}{N}. \]
      对标准 Transformer（\(d_{ff}=4d\)，每层约 \(12d^2\) 参数，故 \(N\approx12n_{\text{layer}}d_{\text{model}}^2\)）：
      \[ \frac{C_{\text{attn}}}{C_{\text{param}}}\approx\frac{n_{\text{ctx}}}{12\,d_{\text{model}}}. \]
      取 \(d_{\text{model}}=8192\)（**一个演示用的量级，不是任何模型的披露值**），\(12d=98304\)：8K 上下文时 attention 占 8.3%，32K 时 33%，约 98K 时与全部参数运算**持平**，1M 时是参数项的十倍。结论：**\(n_{\text{ctx}}\gtrsim10\)K 时注意力就不可忽略，\(n_{\text{ctx}}\approx12d_{\text{model}}\) 时它与参数项等价。**对 MoE 更糟：分母换成 \(N_{\text{act}}\) 后变小，而 attention 分子**一点不减**，所以同样上下文长度下 MoE 的 attention 占比比 dense 更高。
  
  
  
      **修正 (b)：MoE。FLOPs 与通信必须分成两个方程，不能写进同一个式子。**先看 FLOPs 一侧，用**激活参数**替换总参数并把三类参数拆开：
  
      \[ C_{\text{FLOPs}}\approx6D\big(N_s+kN_e+N_r\big)+C_{\text{attn}}+C_{\text{topk/softmax}}+C_{\text{recompute}},
         \qquad N_{\text{total}}=N_s+EN_e+N_r . \]
      通信一侧**单独报告，单位是字节与时间，不是 FLOPs**：
  
      \[ V_{\text{all2all}}\approx 2\,\mathrm{CF}\cdot k\,T\,d\cdot b\ \text{bytes/层/前向},
         \qquad t_{\text{all2all}}\approx V_{\text{all2all}}/\beta . \]
      **三个必须分清的点。**其一，\(N_r\) 已经把 router 的投影参数计进去了，所以
      **不能再额外加一个 \(C_{\text{router}}\) 项**——那是重复计数；这里单列的 \(C_{\text{topk/softmax}}\) 指的是
      top-k 排序与 softmax 这些**非 matmul** 的开销，与参数无关。
      其二，**all-to-all 的量纲是字节 / 时间，不是 FLOPs**，把它加进 FLOPs 方程是量纲错误；
      它可能主导 wall time，但必须作为第四本账单独报告（见 B18）。
      其三，对 MoE 用 \(6N_{\text{total}}D\) 会高估 token matmul；用 \(6(k/E)N_{\text{total}}D\) 又会错误地把共享参数缩掉。**正确做法只有拆项。**
      顺带给个量级：router 的算术开销是每 token 一次 \(d_{\text{model}}\to E\) 的投影加 top-k，
      以 \(d=8192,E=384\) 计约 \(6.3\times10^{6}\) FLOPs/token/layer，相对 \(6N_{\text{act}}\approx1.9\times10^{11}\)（取 \(N_{\text{act}}=32\)B），
      即便乘上几十个 MoE 层也只在千分之几的量级。
  
  
  
      **修正 (c)：激活重计算。**梯度检查点在反向时重跑一次前向，额外 \(+2N\)：
  
      \[ C\approx8ND\quad(\text{完整重计算}). \]
      PaLM 报告的 HFU/MFU \(=57.8/46.2=1.251\)，反推额外开销为 \(0.251\times6N\approx1.5N\)，即约 **75%** 的完整重计算——说明它用的是**选择性**重计算而非全量。这个 1.25 倍的系数在把 \(6ND\) 换算成真实机时时是不可省的。
  
  
  
      **修正 (d)：词表 softmax 与 embedding。**输出投影是 \(d_{\text{model}}\times V\)，前向每 token \(2Vd_{\text{model}}\)。以 \(V=256000,d=8192\)：
  
      \[ 2\times2.56\times10^{5}\times8192=4.19\times10^{9}\ \text{FLOPs/token（前向）}. \]
      对比 \(2N\)：若 \(N=30\)B 则 \(2N=6\times10^{10}\)，占比约 **7%**；但若 \(N=1\)B 则 \(2N=2\times10^{9}\lt4.19\times10^{9}\)——**输出层比整个模型还贵**。这就是 \(6ND\) 在「小模型 + 大词表」上会显著失准的原因。embedding lookup 本身是 gather，FLOPs 近似为零但访存不小。
  
  
  
      **修正 (e)：多模态。**两处偏差同时发生。其一，视觉/音频编码器的参数**不在语言主干的 \(N\) 里**，但它的 FLOPs 是实打实的；其二，**token 膨胀**——一张图在 Gemini 3 Pro Image 的官方计费里是 560 个输入 token，视频按帧展开可以到每秒数百 token。
  
      所以对原生多模态训练，**\(D\) 这个「token 数」本身就依赖于模态混合比例**。\(6ND\) 里的两个符号**都**失去了唯一含义——这不是精度问题，是模型选错了。
  
  
  
      最后示范一次反推有多脆。Epoch AI 估 Gemini 1.0 Ultra 的训练算力约 \(5\times10^{25}\) FLOP，**他们自己把置信度标为 "Speculative"**。由 \(C=6N_{\text{act}}D\)：
  
      \[ D=10\text{T}\ \Rightarrow\ N_{\text{act}}=\frac{5\times10^{25}}{6\times10^{13}}=8.3\times10^{11};\qquad D=20\text{T}\ \Rightarrow\ N_{\text{act}}=4.2\times10^{11}. \]
      仅仅因为 \(D\) 在 10T 与 20T 之间摇摆，「激活参数量」就在 420B 与 830B 之间跳，**而 \(D\) 本身也从未公开**。再叠加步 (6) 的长上下文低估（1M 时可达十倍）、步 (8) 的重计算、步 (10) 的多模态 token 口径，误差可以是数倍。**这不是一个可以用来「估算」Gemini 参数量的方法。**

• (2mkn) 把乘和加各算一次 FLOP，这是行业惯例；也有文献只算 MAC，会差 2 倍。

• (N\approx12n_{\text{layer}}d^2) 假设 (d_{ff}=4d) 与标准 MHA。SwiGLU 让 FFN 变成 3 个矩阵（(d_{ff}) 通常取 (\tfrac83d) 来配平），系数会变。

• 反向的 (4N) 忽略了不需要权重梯度的层（最后一层的输入梯度、frozen 参数）。

• 步 (6)、(9) 里的 (d_{\text{model}}=8192)、(V=256000) 是为演示取的量级，不是任何闭源模型的披露值。

• Gemini Ultra 那个算例完全建立在第三方估算之上，且假设全程使用同一代硬件与某个固定 MFU。

• 长上下文下偏差最大：步 (6) 显示 1M 上下文时 (6ND) 能低估约十倍。Gemini 的训练必然包含长上下文阶段，所以对 Gemini 用 (6ND) 是系统性低估。

• 多模态编码器不在 (N) 里，图像 token 的高倍膨胀也没被建模。

• MoE 的 all-to-all 时间不是 FLOPs。(6N_{\text{act}}D) 算出的是「必需算力」，实际墙钟时间要除以 MFU，而 MoE 的 MFU 通常显著低于稠密模型。

• 第三方算力估算本身有大误差棒；Epoch AI 把 Gemini 1.0 Ultra 标为 “Speculative”。

• 不包括超参搜索、失败的 run、以及 post-training（SFT + RL）。RL 阶段在 2025–2026 的推理模型上可能是与预训练可比量级的额外开销——这一条对「今天的模型花了多少算力」这个问题的影响，可能比上面所有修正项加起来还大。

    \(C\approx6ND\) 成立的严格条件是：**dense、parameter-matmul 主导、一次乘加计 2 FLOPs、排除 self-attention、排除 embedding/logits/softmax/norm、排除激活重计算、排除 optimizer update、排除通信。**MoE 必须改写为 \(6D(N_s+kN_e+N_r)\) 并单独报告 all-to-all 字节。它是下界与记账单位，不是估计量。
  
  
  
  
  
  
  
  **图 6.21** scaling law 的奠基图：损失对算力、数据量、参数量的三条幂律。注意横轴的「Compute」正是用 \(6ND\) 这类口径算出来的——**后面所有关于指数的争论，都发生在这个横轴的定义上**（详见 B6）。[@src-85f66a6419]出处：Scaling Laws for Neural Language Models（Kaplan et al.），2020

  它到底在说什么。(6ND) 能统治这个领域，是因为它把一个极其复杂的系统压缩成两个可测量的数，而它成立的理由干净得像一条守恒律：每个参数在前向被用一次（2 FLOPs），在反向被用两次（4 FLOPs）。但恰恰是这份简洁掩盖了 2024 年之后最重要的变化——**(6ND) 里没有 (n_{\text{ctx}})。**在 2K 上下文的时代忽略它无伤大雅；到了 1M 上下文，这一项是主项的十倍。同样地，MoE 让 (N) 这个符号本身变得歧义：是总参数还是激活参数？稀疏度 3% 的模型和稠密模型用同一个公式，得到的「训练算力」含义完全不同。一个公式最危险的时刻，是它的适用条件被时代悄悄改掉、而它的形式没变。

  这是本章最需要被记住的一条禁令。用 (C=6ND) 从「训练算力」反推「参数量」，至少要叠三层假设：（1）训练算力本身是第三方估算（Epoch AI 自标 “Speculative”）；（2）训练 token 数 (D) 从未公开，10T 与 20T 之间的差别就让答案差一倍；（3）(6ND) 在长上下文、多模态、MoE、重计算、RL 后训练这五个方向上全部是低估。三层叠加，误差可以是数倍。所以关于 Gemini 参数量的正确写法只有一种：官方未公开。凡是给出量级的地方，必须写成「未公开；外部估算为 X，依据 Y」，并且放在批注块里而不是正文里。

  B5 · Chinchilla 最优点的完整拉格朗日推导，与「20 tokens/param」的真实来源

  一句话。在 (C=\kappa ND) 约束下最小化 (L=E+AN^{-\alpha}+BD^{-\beta})，最优点满足等边际条件 (\alpha AN^{-\alpha}=\beta BD^{-\beta})，由此解出 (N^\propto C^{\beta/(\alpha+\beta)})、(D^\propto C^{\alpha/(\alpha+\beta)})——只有 (\alpha=\beta) 时才各半；而那个著名的 20:1 其实来自另外两种方法，与这套公式互相矛盾。

    B5
    算力约束下的最优参数–数据分配
    Hoffmann et al., 2022 · arXiv:2203.15556 ／ Besiroglu et al.（Epoch AI）, 2024 · arXiv:2404.10102 ／ Sardana & Frankle, 2024 · arXiv:2401.00448
  
  
  
  
      符号表

| | (N) | 模型参数量 | (10^{7}\sim10^{12})

| | (D) | 训练 token 数 | (10^{9}\sim10^{14})

| | (C) | 训练算力，(C=\kappa ND) | FLOP

| | (\kappa) | FLOPs 系数，(\approx6)（口径见 B20） | 无量纲

| | (L(N,D)) | 最终预训练损失 | nats/token，(\gt E)

| | (E) | 不可约损失 | Hoffmann 拟合 1.69

| | (A,B) | 有限容量 / 有限数据的惩罚系数 | Hoffmann 拟合 406.4 / 410.7

| | (\alpha,\beta) | 参数 / 数据的幂律指数 | Hoffmann 拟合 0.34 / 0.28

| | (\lambda) | 拉格朗日乘子（算力的影子价格） | 实数

| | (a,b) | (N^\propto C^{a},\ D^\propto C^{b})，(a+b=1) | ((0,1))

| | (G) | 最优分配的前置常数 | (\gt0)

| | (r) | 偏离最优的参数量倍数 (N=rN^*) | (\gt0)

逐步推导 · 共 15 步（点击展开）

      起点是一个**假设**而不是推导：把损失分解成不可约的熵、模型容量不足的惩罚、数据不足的惩罚三项，且**可加分离**。

      \[ L(N,D)=E+\frac{A}{N^{\alpha}}+\frac{B}{D^{\beta}} . \]
      动机是 \(N\to\infty\) 且 \(D\to\infty\) 时 \(L\to E\)，两个惩罚项相互独立。**但可加分离没有理论依据**——Kaplan 用的是不可分离的形式（见 B6 步 2），两者对同一批数据可以给出不同的最优分配。这是全节最脆弱的一块砖。



      约束来自 B20：

      \[ C=\kappa ND,\qquad \kappa\approx6 . \]
      **注意这里继承了 B20 的全部排除项**：dense、parameter-matmul 主导、排除 self-attention、排除重计算。一旦上下文很长使 attention 项抬头，约束就变成 \(C=6ND+6n_{\text{layer}}n_{\text{ctx}}d\,D\)，最优比例会向「更小的模型、更多的数据」偏移，因为增大 \(N\) 的边际成本上升了。



      构造拉格朗日函数，把约束优化转成无约束：

      \[ \mathcal L(N,D,\lambda)=E+AN^{-\alpha}+BD^{-\beta}+\lambda\big(\kappa ND-C\big). \]
      \(E\) 是常数，对求导无影响，但保留它可以让后面 \(L^*-E\) 的表达式直接读出来。



      三个一阶条件（用 \(\frac{d}{dN}N^{-\alpha}=-\alpha N^{-\alpha-1}\)）：

      \[ \frac{\partial\mathcal L}{\partial N}=-\alpha AN^{-\alpha-1}+\lambda\kappa D=0, \]
      \[ \frac{\partial\mathcal L}{\partial D}=-\beta BD^{-\beta-1}+\lambda\kappa N=0, \]
      \[ \kappa ND=C . \]
      三个方程三个未知数 \((N,D,\lambda)\)，闭合。



      关键技巧：**第一式乘 \(N\)、第二式乘 \(D\)**，两边都变成 \(\lambda\kappa ND=\lambda C\)：

      \[ \alpha AN^{-\alpha}=\lambda\kappa ND=\beta BD^{-\beta} \quad\Longrightarrow\quad \alpha AN^{-\alpha}=\beta BD^{-\beta}. \]
      这一步的物理含义非常漂亮：**最优点处，「把算力投给参数」与「把算力投给数据」的边际损失下降率相等**——这是经济学等边际原理在 scaling law 上的化身。顺带也读出了 \(\lambda\) 的含义：两边同时等于 \(\lambda C\)，所以 \(\lambda\) 就是**单位算力的影子价格**。



      用约束消掉 \(D=C/(\kappa N)\)：

      \[ \alpha AN^{-\alpha}=\beta B\Big(\frac{C}{\kappa N}\Big)^{-\beta}=\beta B\Big(\frac{\kappa N}{C}\Big)^{\beta}=\beta B\Big(\frac{\kappa}{C}\Big)^{\beta}N^{\beta}. \]
      把 \(N\) 的幂次归并到一边：
      \[ N^{\alpha+\beta}=\frac{\alpha A}{\beta B}\Big(\frac C\kappa\Big)^{\beta}. \]
      注意 \(\alpha+\beta\) 出现在指数上——这个和决定了两个「弹性」如何合成，也是下一步分母的来源。



      两边取 \(\frac1{\alpha+\beta}\) 次幂，得到**带常数的完整表达式**：

      \[ N^{*}=\Big(\frac{\alpha A}{\beta B}\Big)^{\frac1{\alpha+\beta}}\Big(\frac C\kappa\Big)^{\frac{\beta}{\alpha+\beta}},\qquad D^{*}=\Big(\frac{\beta B}{\alpha A}\Big)^{\frac1{\alpha+\beta}}\Big(\frac C\kappa\Big)^{\frac{\alpha}{\alpha+\beta}} . \]
      退化到指数关系：
      \[ N^{*}\propto C^{\beta/(\alpha+\beta)},\qquad D^{*}\propto C^{\alpha/(\alpha+\beta)},\qquad L^{*}-E\propto C^{-\alpha\beta/(\alpha+\beta)} . \]
      **只有 \(\alpha=\beta\) 时两个指数才严格等于 \(1/2\)。**把 \(N,D\propto C^{1/2}\) 无条件地写出来是错的——这是本章最常见的一处以讹传讹。\(a+b=1\) 则是自动满足的，它是 \(C=\kappa ND\) 这个乘性约束的必然结果，不含任何信息。



      代入数值。用论文正文的四舍五入值 \(\alpha=0.34,\beta=0.28\)：

      \[ a=\frac{0.28}{0.62}=0.4516,\qquad b=\frac{0.34}{0.62}=0.5484, \]
      \[ G=\Big(\frac{0.34\times406.4}{0.28\times410.7}\Big)^{1/0.62}=\Big(\frac{138.18}{115.00}\Big)^{1.6129}=1.2016^{1.6129}=1.3447 . \]
      用 Epoch AI 从 arXiv 源文件注释中挖出的高精度值 \(\alpha=0.3392,\beta=0.2849\) 则得 \(a=0.4565,\ b=0.5435,\ G=1.3004\)。**这就是经验 frontier 的 \(N\propto C^{0.46},\ D\propto C^{0.54}\) 的来源。**



      现在算配比。这一步是全节的引爆点：

      \[ \frac{D^{*}}{N^{*}}=\frac{G^{-1}(C/\kappa)^{b}}{G(C/\kappa)^{a}}=G^{-2}\Big(\frac C\kappa\Big)^{b-a}. \]
      **只有当 \(a=b=\tfrac12\)（即 \(b-a=0\)）时，配比才与算力无关，才配叫「一条规则」。**而 Approach 3 给出 \(b-a=0.087\)，配比是**随算力增长**的。



      代入 Chinchilla 自己的算力 \(C=6\times70\text{B}\times1.4\text{T}=5.88\times10^{23}\)：

| | 参数来源 | (a) | (G) | (N^{}) | (D^{}) | (D^{}/N^{})

| | 论文正文四舍五入值 | 0.4516 | 1.3447 | 32.5 B | 3.02 T | 92.8

| | TeX 源码高精度值 | 0.4565 | 1.3004 | 40.7 B | 2.41 T | 59.2

| | Epoch AI 2024 重拟合 | 0.5126 | 0.1196 | 73.0 B | 1.34 T | 18.4

      **Approach 3 的拟合参数根本推不出 20 tokens/param，它推出的是 60–90。**而且同一组公式，仅仅因为 \(\alpha,\beta\) 保留两位还是四位小数，答案就在 59 与 93 之间跳——这本身就说明了这套参数有多脆。



      **那个 20 到底从哪来？来自 Approach 1 和 Approach 2。**Chinchilla 论文用了三种方法：

• Approach 1（min over training curves）：固定一组模型扫训练步数，画损失–算力包络线取最低点 → (a=0.50,\ b=0.50)。

• Approach 2（IsoFLOP profiles）：固定 9 个算力预算，每个预算下训一系列不同大小的模型，对每条 IsoFLOP 曲线取抛物线最低点 → (a=0.49,\ b=0.51)。

• Approach 3（参数化损失拟合）：就是上面推的这套 → (a=0.454,\ b=0.546)。

      Approach 1、2 都给 \(a\approx b\approx0.5\)，此时 \(b-a=0\)、配比与算力无关，**才成为一条干净的常数规则**。而 Chinchilla 实际训的 70B/1.4T（比值正好 20）是按 Approach 1、2 的结论选的，**不是**按 Approach 3。也就是说：**「Chinchilla 最优 = 20 tokens/param」这句话与 Approach 3 的公式互相矛盾，整个社区却把两者缝在一起用了三年。**
  
  
  
      **Epoch AI 2024 的复现质疑。**他们从 Hoffmann 图 4 反解出约 240 个数据点，重新拟合 Approach 3，发现三个问题：

• 拟合不成立：Hoffmann 报告的参数对重建数据拟合极差，似然比检验 (p\lt10^{-235})。

• 置信区间窄得不可能：Hoffmann 报 (a\in[0.454,0.455])（宽度 0.001）；Epoch 估计 (a) 的标准误是 0.018，80% 置信区间宽约 0.05——宽 50 倍。要达到 Hoffmann 报告的窄度大约需要 (240\times50^{2}=6\times10^{5}) 次训练，而 Hoffmann 只有「400 多次」观测。

• 重拟合结果：(L(N,D)=1.8172+\dfrac{482.01}{N^{0.3478}}+\dfrac{2085.43}{D^{0.3658}})，(a=0.5126)（标准误 0.02）。

      Hoffmann 团队的回应给出了根因：他们在 L-BFGS-B 优化器里**对 Huber loss 取了样本平均而非求和**，导致 loss scale 过大、优化器在收敛前就提前终止。这同时解释了两件事——点估计偏离真值，以及 bootstrap 时参数几乎不动、从而给出荒谬地窄的置信区间。**这是一个纯粹的数值实现 bug，不是方法论错误。**
  
  
  
      反讽之处在于：**Epoch 的重拟合反而「救回」了 Approach 3。**他们的 \(a=0.5126\pm0.02\) 与 Approach 1、2 的 0.50、0.49 完全一致，配比 18.4 回到 20 附近，算出的 \(N^{*}=73.0\)B 与 Chinchilla 实际训的 70B 几乎重合。
  
      所以正确的表述是**「Chinchilla 的结论是对的，Chinchilla 论文里的那组参数是错的」**。很多二手解读把这篇质疑论文误读成「Chinchilla 被推翻了」——这个区分极其重要。
  
  
  
      **最优点有多「尖」？**这是决定实践意义的一步。把 \(D=C/(\kappa N)\) 代回损失得到固定算力下的一维函数：
  
      \[ \ell(N)=E+AN^{-\alpha}+B\Big(\frac{\kappa}{C}\Big)^{\beta}N^{\beta}. \]
      记 \(u=AN^{*-\alpha}\)、\(v=BD^{*-\beta}\)（最优点满足 \(\alpha u=\beta v\)），偏离到 \(N=rN^{*}\) 时：
      \[ \ell(rN^{*})-\ell(N^{*})=u\big(r^{-\alpha}-1\big)+v\big(r^{\beta}-1\big). \]
      代入高精度参数与 \(C=5.88\times10^{23}\)（此时 \(u=0.10238,\ v=0.12189\)，且 \(\alpha u=\beta v=0.03473\) 验证了最优条件）：

| | (r) | (N) | (D) | (D/N) | (L) | 损失增量（nats）

| | 0.25 | 10.2 B | 9.63 T | 947 | 1.9394 | +0.0217

| | 0.50 | 20.3 B | 4.82 T | 237 | 1.9230 | +0.0053

| | 1.00 | 40.7 B | 2.41 T | 59 | 1.9177 | 0（最优）

| | 1.72 | 70 B（Chinchilla 实际） | 1.40 T | 20 | 1.9208 | +0.0032

| | 4.00 | 163 B | 602 B | 3.7 | 1.9383 | +0.0206

| | 6.88 | 280 B（Gopher 规模） | 350 B | 1.2 | 1.9578 | +0.0401

      **参数量偏离最优 2 倍，损失只涨 0.003–0.005 nats；偏离 4 倍才涨 0.02。最优点极其平坦。**这解释了为什么 Llama-3 敢用 \(D/N\approx1875\)（相当于 \(r\approx0.18\)）：沿 \(r\lt1\) 方向走，质量代价是二阶小量，而推理成本的节省是一阶的。**Gopher 的问题不在于偏离，而在于偏离的方向错了**（\(r\gt1\)）：它既多花了训练算力，又留下一个推理更贵的模型，两头都亏。



      最后一步不是数学，是目标函数被换掉了。Sardana & Frankle 指出真正该优化的是全生命周期成本：设模型部署后要服务 \(D_{\text{inf}}\) 个推理 token，

      \[ \min_{N,D}\ \underbrace{6ND}_{\text{训练}}+\underbrace{2N\,D_{\text{inf}}}_{\text{推理}}\qquad\text{s.t.}\quad L(N,D)\le\ell . \]
      推理只有前向，约 \(2N\) FLOPs/token。**注意约束从「固定算力」变成了「固定质量」——这是问题的重新表述，不是同一个问题的修正。**在这个目标下 \(N\) 同时出现在两项里，而推理项的系数 \(2D_{\text{inf}}\) 可以远大于训练项，于是最优解**系统性地偏向更小的 \(N\)、更大的 \(D\)**。直观说：如果一个模型要被调用一万亿次，多花 10 倍训练算力去换一个小一半的模型是划算的。

• (L=E+AN^{-\alpha}+BD^{-\beta}) 的可加分离形式是假设，没有理论推导；真实的交互项、数据质量、数据重复都被忽略。

• (C=\kappa ND) 继承 B20 的全部排除项（attention、embedding、重计算、通信）。

• 一阶条件给出的是驻点；需验证它是极小值——由于 (L) 在约束流形上关于 (\log N) 是严格凸的（两项分别是 (\log N) 的递减凸函数与递增凸函数），驻点唯一且为极小。

• 假设数据是「新鲜」的（单 epoch、无重复）。多 epoch 时 (B/D^{\beta}) 项的形式会改变。

• 假设 (N,D) 可连续取值，且模型形状（深宽比）不影响损失；固定架构族、optimizer、tokenizer 与训练分布。

• Approach 3 的参数不可信。任何直接引用 (E=1.69,A=406.4,B=410.7,\alpha=0.34,\beta=0.28) 做外推的工作，都建立在一次优化器提前终止之上。改用 Epoch 的重拟合值时也要注意其标准误很大（(B) 的标准误 1293，比点估计 2085 的一半还大）。

• 配比 (D^/N^=G^{-2}(C/\kappa)^{b-a}) 对 (a-b) 极度敏感：(a) 从 0.4516 变到 0.4565（第三位小数）就让配比从 93 变到 59。「最优配比」这个数字在统计上几乎不可辨识——好消息是损失曲面本身极平坦，所以它也不太要紧。

• 拟合数据的算力范围是 (6\times10^{18}\sim3\times10^{22}) FLOPs，而今天的前沿模型在 (10^{25}\sim10^{26})。外推了 3–4 个数量级，且 (E) 项在外推中的作用会被放大。

• 损失（nats/token）不等于能力。Chinchilla 优化的是困惑度，而下游任务性能、推理能力、指令跟随与困惑度的关系是非线性且任务相关的。

• 完全没有考虑数据质量、数据重复、课程学习与蒸馏。Gemma 3 全系用蒸馏训练，这直接打破了「损失只依赖 (N,D)」的前提。

    \(N^{*}=\big(\tfrac{\alpha A}{\beta B}\big)^{\frac1{\alpha+\beta}}\big(\tfrac C\kappa\big)^{\frac{\beta}{\alpha+\beta}}\)、\(D^{*}=\big(\tfrac{\beta B}{\alpha A}\big)^{\frac1{\alpha+\beta}}\big(\tfrac C\kappa\big)^{\frac{\alpha}{\alpha+\beta}}\)，经验 frontier 约 \(C^{0.46}\) 与 \(C^{0.54}\)，**不是无条件的 0.5/0.5**。20 tokens/param 来自 Approach 1、2，与 Approach 3 的公式互相矛盾；而 Approach 3 的那组参数已被证实源于一个优化器实现 bug。
  
  
  
  
  
  
  
  
  **图 6.22** **三个并排面板。****左面板**是 Approach 2 的 IsoFLOP 曲线族：9 个算力档（图例 6e18 / 1e19 / 3e19 / 6e19 / 1e20 / 3e20 / 6e20 / 1e21 / 3e21）各扫一条 Training Loss 对 Parameters 的 U 形曲线，每条曲线的谷底给出该算力下的最优模型规模，谷底随算力增大而右移下移；**注意谷底附近有多平**——这就是步 (15) 说的平坦性。**中、右两个面板**把这些谷底外推到更大算力：中面板纵轴是 Parameters、图上用青色引出线标注 **63B**，右面板纵轴是 Tokens、标注 **1.4T**。**那个著名的 20:1 正是这两个印在图上的数字之比（1.4T ÷ 63B ≈ 22）**，来自 IsoFLOP 谷底的经验外推，**不是从拉格朗日公式来的**。[@src-46fd66187e]出处：Training Compute-Optimal Large Language Models（Hoffmann et al.），2022，图 3
  
  
  
  **图 6.23** **请按图里实际画的东西读：这是一张「重建出来的数据集」，不是拟合结果图。**
    横轴是训练 FLOP（\(10^{18}\)–\(10^{22}\)）、纵轴是模型规模（约 \(4\times10^7\)–\(10^{10}\)）、**点的颜色是最终 loss**（右侧色标 1.8–5.0）——
    它展示的是 Epoch AI 从 Hoffmann 原文图中**反解出的约 240 个训练运行**，也就是这次复现赖以成立的原材料。
    **结论本身（重拟合后的不确定性远大于原文报告的 0.001 宽度）在论文正文里，不在这张图上。**
    （本轮打开原图核对时发现：文件名里的 `isoflop-refit` 与图的实际内容不符，
    **这正是 SPEC 警告过的「文件名与 manifest 描述都不可信」那一类，本图注已按实际内容重写。**）
    [@src-d99dacd386]出处：Chinchilla Scaling: A Replication Attempt（Besiroglu et al., Epoch AI），2024

  它到底在说什么。Chinchilla 最深的贡献不是那个 20，而是揭示了整个行业在 2020–2022 年系统性地训练了一批「营养不良」的模型：GPT-3（比值 1.7）、Gopher（1.07）、MT-NLG（0.5）全都严重欠训。Chinchilla 70B 用相同算力打败 Gopher 280B，是 scaling law 研究史上最有说服力的一次实证——一个纯粹的理论推导（步 5 那个等边际条件）直接改变了整个行业的资本配置。而步 (10)–(11) 揭示的矛盾同样值得停下来想：一句被引用了成千上万次的话，与它所依附的公式其实互相矛盾；社区把 Approach 1、2 的结论和 Approach 3 的公式缝在一起用了三年，直到 2024 年才发现缝合处对不上，而对不上的原因竟然是一个 loss scale 的实现 bug。这是一个关于科学传播如何丢失细节的绝佳案例：论文里三种方法的分歧被浓缩成一个数字，数字被浓缩成一句口号，而口号的出处早已无人回溯。

  因为 (N) 这个符号在 MoE 里同时指两件事。约束 (C=6ND) 里的 (N) 必须是每 token 激活参数（B18 第二本账、B20 步 7），否则算力会被严重高估；但损失项 (A/N^{\alpha}) 里的 (N) 代表的是模型容量，而容量显然与总参数（B18 第一本账）更相关——一个 1.2T 总参 / 96.6B 激活的模型，它的「容量」既不是 1.2T 也不是 96.6B。正确的做法是把约束重写成 (C=6D(N_s+kN_e+N_r))，然后承认损失项里该填什么是一个开放问题：GLaM 的公开数字暗示「等效稠密参数」大约介于总参数与激活参数之间（有人用几何平均 (\sqrt{N_{\text{total}}N_{\text{act}}}) 做启发式，但这条规则没有理论依据，只能作数量级参考）。在此之上还要加 all-to-all 通信——它根本不进 (C)，却决定 wall time。结论：Chinchilla 的最优点公式不能直接套到 MoE 上，因为它的两个符号在 MoE 里各自分裂成了两个量。

  因为目标函数被整个换掉了。Chinchilla 优化的是「给定训练算力，最小化最终 loss」；2024 年之后大家实际在优化「给定目标能力，最小化训练 + 推理的总支出」^[10][Beyond Chinchilla-Optimal]。这不是同一个问题的修正，而是把约束和目标对调了（步 16）。两个后果：其一，当一个模型要服务上万亿 token 的推理时，推理项 (2ND_{\text{inf}}) 主导，最优解移向更小的模型 + 更多的训练数据，Llama-3-8B 训 15T token 在这个目标下完全合理——它不是违背 scaling law，它是在优化一个不同的目标函数。其二，也是更根本的：多轮 RL / RLVR 的算力根本不在 (6ND) 里。(D) 是预训练 token 数，而 RL 阶段要反复采样、验证、更新，其算力在 2025–2026 的推理模型上可能与预训练可比。一个只描述预训练的公式，无法为一个把大量算力花在后训练的模型定最优点。

  B6 · Kaplan 与 Chinchilla 分歧的根源：三个实验设置，值几十亿美元

  一句话。0.73 与 0.50 相差的 0.23 个指数，主因不是流传最广的「学习率调度」，而是三件更平淡的事：参数计数口径导致漏算最后一层 FLOPs（−0.16）、warmup 设得太长（−0.10）、优化超参没随规模调（−0.07）。

    B6
    两条 scaling law 的机制性对账
    Kaplan et al., 2020 · arXiv:2001.08361 ／ Hoffmann et al., 2022 · arXiv:2203.15556 ／ Porian et al., 2024 · arXiv:2406.19146
  
  
  
  
      符号表

| | (a) | (N^{*}\propto C^{a}) 中的指数 | Kaplan 0.73（原始拟合 0.88）／ Chinchilla ≈0.46–0.50

| | (\alpha_N,\alpha_D) | Kaplan 的参数 / 数据幂律指数 | 0.076 / 0.095

| | (\alpha_S,\alpha_B) | Kaplan 的步数 / batch 幂律指数 | 0.76 / 0.21

| | (\alpha_C^{\min}) | 损失对最小算力的指数 | 0.054（原文）／ 0.052（复算）

| | (N) | 参数量的定义——关键分歧点 | Kaplan：不含 embedding，也不含 head 的 FLOPs

| | (d) | 隐层宽度 | 整数

| | (V) | 词表大小 | 约 5 万

| | (\rho^{*}) | 最优 token/参数比 | Kaplan 个位数；Chinchilla ≈20

逐步推导 · 共 12 步（点击展开）

      先量化冲突有多大。Kaplan 报告 \(N\propto C_{\min}^{0.73}\)、\(D\propto C^{0.27}\)；Chinchilla 报告 \(a\approx0.46\)（Approach 3）到 \(0.50\)（Approach 1、2）。从 \(10^{21}\) 外推到 \(10^{25}\) FLOPs（四个数量级）：

      \[ \text{Kaplan}:\ 10^{4\times0.73}=10^{2.92}\approx830\ \text{倍};\qquad \text{Chinchilla}:\ 10^{4\times0.50}=100\ \text{倍}. \]
      **参数量的处方差 8 倍。**这就是 GPT-3、Gopher、MT-NLG 全部严重欠训的直接原因。



      要定位错在哪，先看清 Kaplan 自己的推导。他的两条边际律是

      \[ L(N)=\Big(\frac{N_c}{N}\Big)^{\alpha_N},\ \alpha_N=0.076;\qquad L(D)=\Big(\frac{D_c}{D}\Big)^{\alpha_D},\ \alpha_D=0.095, \]
      联合形式是**不可分离**的（与 Chinchilla 的可加形式不同）：
      \[ L(N,D)=\left[\Big(\frac{N_c}{N}\Big)^{\frac{\alpha_N}{\alpha_D}}+\frac{D_c}{D}\right]^{\alpha_D}. \]
      由此他推出 \(D\propto N^{\alpha_N/\alpha_D}=N^{0.80}\)——**数据应该次线性于参数增长**。这已经蕴含了「参数优先」的结论。**这是第一个机制性分歧：函数形式不同。**可加分离与不可分离对同一批数据可以给出不同的最优分配，而两种形式都没有第一性原理依据。



      他的最优模型规模来自另一条路径：把损失写成 \(L(N,S_{\min})\)（\(S_{\min}\) 是最小优化步数）再对固定算力优化：

      \[ \alpha_C^{\min}=\frac1{1/\alpha_S+1/\alpha_B+1/\alpha_N},\qquad N(C_{\min})\propto C_{\min}^{\alpha_C^{\min}/\alpha_N}. \]
      验算：\(1/(1/0.76+1/0.21+1/0.076)=1/(1.316+4.762+13.158)=1/19.24=0.052\)，与原文的 0.054 一致；\(0.054/0.076\approx0.71\)。
      **注意 \(\alpha_N=0.076\) 出现在分母上——它很小，所以 \(\alpha_C^{\min}/\alpha_N\) 很大。整条结论的杠杆全压在 \(\alpha_N\) 这一个数字上。**这是第二个机制：任何系统性地扰动 \(\alpha_N\) 拟合的实验设置错误，都会被放大十几倍地传到最终指数上。



      Porian et al. 用 900 多次训练实验做了逐步对账：在同一套代码里，把 Kaplan 的设置**一项一项**改成 Hoffmann 的设置，每改一步测一次指数。

| | 步骤 | 改了什么 | (a)（OpenWebText2） | (a)（RefinedWeb） | 增量

| | 0 | 复现 Kaplan 原设置 | 0.864 | 0.835 | —

| | 1 | 计入最后一层（head）的 FLOPs | 0.699 | 0.706 | −0.16

| | 2 | warmup 长度随模型规模缩放 | 0.603 | 0.602 | −0.10

| | 3 | 按 token 预算逐个设余弦衰减 | 0.574 | 0.571 | −0.03

| | 4 | 调 batch size / 学习率 / (\beta_2) | 0.518 | 0.497 | −0.07

| | — | Hoffmann 目标值 | 0.50 | 0.50 | —

      两个数据集上的增量高度一致，说明这不是数据集的偶然。**注意第 3 行——那是流传最广的解释，它只值 0.03。**



      **因素 (a)：参数计数口径 → 最后一层 FLOPs 漏算（贡献最大的 0.16）。**Kaplan 定义 \(N\) 为不含 embedding 的参数量，理由是这样让 scaling law 在不同深度间更一致。但因为他的 embedding 与输出 head 是**权重绑定**的，他顺带也把 head 的**计算量**从 FLOPs 里去掉了。head 是一个 \(d\times V\) 的矩阵乘（\(V\approx5\) 万），其 FLOPs 与 \(d\) 成正比，而模型主体与 \(d^2\) 成正比：

      \[ \frac{\text{head FLOPs}}{\text{总 FLOPs}}\sim\frac{dV}{d^{2}\cdot\text{const}}\propto\frac Vd . \]
      **模型越小、\(d\) 越小，漏算比例越大。**Porian 实测：大模型漏算约 10%，小模型高达 **90%**。这意味着 Kaplan 系统性地**低估了小模型的真实算力消耗**——小模型看起来比实际「更便宜」，但性能又不够好，于是「小模型性价比低」的假象被放大，最优点被人为推向大模型。**这是「参数计数口径」如何变成「资本配置错误」的完整链条。**



      **因素 (b)：warmup 过长（0.10）。**Kaplan 全程用固定的 3000 步 warmup，batch 为 \(2^{19}\) token，即 \(3000\times2^{19}\approx1.57\times10^{9}\) 个 token 的 warmup。这个长度是为「训到完全收敛」设计的。

      但在算力受限的实验里，**小模型的最优训练 token 数本身就小于或接近 warmup 长度**——它们整个训练过程都还没走出 warmup，学习率都没升到峰值。机制上这如何抬高 \(a\)？因为小算力端的 \(D^{*}\) 被 warmup 人为顶高，\(N^{*}=C/(6D^{*})\) 就被人为压低；低算力端的点被压低、高算力端不变，**拟合出来的斜率自然变陡**。修正方法很朴素：令 warmup 的 token 数等于模型参数量 \(N\)。



      **因素 (c)：优化超参未随规模调整（0.07）。**Kaplan 全程用固定 batch size \(2^{19}\) token，小模型在这个 batch 下只能训几百步，严重不足。Porian 对 5M–108M 的模型扫 batch size 与学习率，拟合出各自随 \(N\) 的幂律。

      一个意外发现值得单独记住：**必须同时调 AdamW 的 \(\beta_2\)**——batch 变小则梯度二阶矩估计的噪声变大，需要更强的平滑，\(\beta_2\) 要从 0.95 提到 0.99 甚至 0.999，否则小 batch 下结果很差。这是一个「超参之间有耦合、单独扫一个会得到错误结论」的典型例子。



      **因素 (d)：学习率衰减——Hoffmann 自己的假说，被证伪。**Hoffmann 等人在原文中猜测差异源于 Kaplan 没有为每个 token 预算单独设置余弦衰减。Porian 直接检验了这一点，发现它**只贡献 0.03**（0.603 → 0.574），远不足以解释 0.36 的总差距。

      他们的解释很有说服力：Kaplan 的余弦衰减周期设在 1310 亿 token，而在他实际的算力尺度下最优训练量从不超过约 100 亿 token——**模型只走完了衰减曲线的很小一段，学习率基本就没衰减过**，谈不上「衰减不匹配」。Porian 论文摘要里写得很直白：「Counter to a hypothesis implied in Hoffmann et al., we find that careful learning rate decay is not essential for the validity of their scaling law.」**这直接反驳了流传最广的那个解释。**



      一个容易被忽略的细节：**Kaplan 自己也知道有问题，并做了修正——但没修够。**他图 14 的原始拟合是 \(N\propto C^{0.88}\)；论文中他意识到固定 batch size 会让小模型训得步数太少，于是用临界 batch size 模型做**后处理**修正，把结果调到 0.73。Porian 复现这个 "adjusted Kaplan" 流程得到 0.717——与 Kaplan 报告的 0.73 高度吻合，说明复现是可信的。但 0.73 离 0.50 仍有 0.23。

      这说明什么？**Kaplan 正确识别了「小模型受超参不当影响」这个问题类别，但他选择了事后统计修正，而不是重新调参重训。**Porian 的做法是直接对每个规模扫最优 batch size / 学习率 / \(\beta_2\)，得到 0.518。**同一个问题，「用模型修正」与「重新做实验」，差了 0.2 个指数。**



      算例一：同算力下 Gopher 与 Chinchilla。Gopher 280B / 300B token，\(C=6\times2.8\times10^{11}\times3\times10^{11}=5.04\times10^{23}\)，比值 1.07；Chinchilla 70B / 1.4T，\(C=5.88\times10^{23}\)，比值 20。用 Hoffmann 的损失函数代入：

      \[ \begin{aligned} L(280\text{B},300\text{B})&=1.6934+\frac{406.4}{(2.8\times10^{11})^{0.3392}}+\frac{410.7}{(3\times10^{11})^{0.2849}}=1.9673,\\ L(70\text{B},1.4\text{T})&=1.6934+\frac{406.4}{(7\times10^{10})^{0.3392}}+\frac{410.7}{(1.4\times10^{12})^{0.2849}}=1.9208 . \end{aligned} \]
      同等算力下损失低 **0.047 nats**。这个数字看着小，但 Chinchilla 论文的实测更狠：它在 MMLU 上超 Gopher 7 个百分点以上，几乎所有评测全面胜出，**而且推理成本只有 1/4**。（口径提示：这里混用了 \(A,B,E\) 的一种取值与 \(\alpha,\beta\) 的高精度值，属于 B5 步 (13) 已经指出「不可信」的那组参数，所以这两个数只用于**相对**比较，不应单独引用。）



      算例二：反过来看 Kaplan 的处方。他的 \(D\propto C^{0.27}\) 意味着在这个尺度上 token/参数比会停在个位数——**正是 Gopher 的 1.07**。把两条处方锚定在同一点（\(C=10^{21}\) 时都取 \(D/N=20\)）再各自外推：

| | 算力 (C) | Chinchilla (N) | Chinchilla (D/N) | Kaplan (N) | Kaplan (D/N) | (N) 之比 | 损失差

| | (10^{21}) | 2.9 B | 20 | 2.9 B | 20 | 1.0× | 0（锚点）

| | (10^{23}) | 28.9 B | 20 | 83.3 B | 2.40 | 2.9× | +0.030

| | (10^{25}) | 289 B | 20 | 2.40 T | 0.29 | 8.3× | +0.052

| | (10^{26}) | 913 B | 20 | 12.9 T | 0.10 | 14.1× | +0.056

      在 \(10^{25}\) FLOPs 这个 2024 年前沿模型的量级上，**Kaplan 的处方是「训一个 2.4 万亿参数的模型，只喂约 6940 亿 token」**——token 比参数还少 3.5 倍。这在今天看来荒谬，但它就是 \(N\propto C^{0.73}\) 的直接推论，也正是 MT-NLG 530B（270B token，比值 0.5）那一代模型的设计逻辑。**Gopher 本身就是「按 Kaplan 训 Chinchilla 算力」的实物证据。**



      把损失差换算成算力代价。求解「Kaplan 配置需要多少算力才能达到 Chinchilla 配置在 \(10^{25}\) 时的损失」：

      \[ L\big(N_{\text{Kaplan}}(C'),D_{\text{Kaplan}}(C')\big)=L\big(N_{\text{Chin}}(10^{25}),D_{\text{Chin}}(10^{25})\big)\ \Longrightarrow\ C'=2.41\times10^{26}. \]
      即 **24 倍算力**。按前沿训练动辄上亿美元计，**这个指数上 0.23 的差异值几十亿美元**，而它的来源是三个平淡无奇的实验设置细节。

• Porian 的复现用的是 Llama 架构 + OpenLM 库 + OpenWebText2/RefinedWeb，不是 Kaplan 的原始代码与 WebText2。他们能复现出 (a=0.86)（对 Kaplan 报告的 0.88）说明设置足够接近，但不是逐位复现。

• 三因素的「增量」是按特定顺序逐步施加得到的，因素之间可能有交互，顺序不同会得到不同的分解。

• 实验规模是 5M–900M 参数，比 Kaplan（最大约 1.5B）和 Hoffmann（最大 16B）都小。结论外推到 100B+ 未经验证。

• (C=6ND) 在两边都用了，其误差在两条 law 的比较中大致抵消——但这也意味着两边同时继承了 B20 的所有排除项。

• 步 (10) 的两个损失值使用了 B5 已判定「不可信」的那组拟合参数，仅用于相对比较。

• 这些结论不意味着 Kaplan 是「错的」。Kaplan 的四条幂律（(L) 对 (N,D,C,S)）本身经受住了时间检验，框架被沿用至今。错的只是「最优分配」这一个推论，而且错因是几个具体的实验设置细节，不是理论框架。

• Porian 的第 (7) 步依赖「在 20 tokens/param 下调最优超参」这个选择，而 20 正是 Chinchilla 的结论——存在轻微的循环论证风险。他们在附录做了敏感性分析认为影响不大，但这个方法论顾虑是真实的。

• 至今没有人在 100B+ 规模上直接验证过 (a=0.5)。所有前沿实验室的实际做法（(D/N) 常在 100–2000）都远离这个所谓最优，理由是推理成本（B5 步 16）。这场争论在实践层面某种意义上已经被第三个目标函数绕过去了。

• 三条修正因素全部是小模型端的偏差。这提示一个更普适的方法论风险：scaling law 的斜率由曲线两端的点决定，而两端恰恰是最容易出实验设置问题的地方（小模型受超参不当影响大，大模型样本少）。任何 scaling law 的置信区间都应该被怀疑地看待。

    0.36 的指数差可以被拆成：漏算 head FLOPs（−0.16）、warmup 过长（−0.10）、优化超参未随规模调（−0.07）、学习率衰减（−0.03）。**流传最广的那个解释（学习率调度）只占八分之一，而最大的一项是「参数计数口径」这样一个看似纯记账的选择。**
  
  
  
  
  
  
  
  **图 6.24** 三种方法的最优参数量预测叠加，以及与 Kaplan 2020 的分歧。**注意 Kaplan 那条线明显更陡**——B6 整节就是在解释这个斜率差从哪来的。同时也能看出 Approach 1/2/3 之间本身就不完全一致，这正是 B5 步 (11) 那个矛盾的图像来源。[@src-46fd66187e]出处：Training Compute-Optimal Large Language Models（Hoffmann et al.），2022

  **它到底在说什么。**三年间，全世界最贵的算力按照一条错误的曲线被分配，损失以数十亿美元计。而错误的根源不是深刻的理论误解，是三个平淡无奇的实验设置细节：忘了数最后一层的 FLOPs、warmup 设得太长、超参没随规模调。没有一个是「聪明」的错误，全都是「手滑」。更值得深思的是纠错过程本身：Hoffmann 等人发现了 Kaplan 的结论有问题，但猜错了原因（归咎于学习率衰减），这个错误解释又被引用了两年，直到 Porian 用 900 次实验把它证伪；然后 Epoch AI 又发现 Hoffmann 自己的 Approach 3 也有 bug。**一条 scaling law，三层错误，四篇论文，四年时间。**在一个实证驱动、复现成本极高的领域，「大家都这么说」的东西可能连一层都没被认真检验过——而 scaling law 恰恰是这个领域里最像「物理定律」、最容易被当成硬事实引用的东西。

  **以下是判断，不是事实。**Chinchilla 是 DeepMind 做的（Hoffmann、Borgeaud、时任 DeepMind 的 Jack Rae 等；Jack Rae 后来参与了 Gemini 的预训练与推理路线，并已于 2025-06 加入 Meta Superintelligence 组织，不应再列作现任 GDM 成员——只有其在 Meta 的精确职级仍 待核），它用一篇论文证明了自家 Gopher 是错的——这种自我否定的能力在工业实验室里非常罕见。它也直接改写了 PaLM 之后 Google 的训练配方：PaLM 540B/780B（比值 1.4）是典型的 Kaplan 式配置，而 Gemini 时代 Google 几乎不再披露参数量、转而强调训练数据的规模与质量，这个叙事转向的技术根源就在这里。然后是反讽本身：DeepMind 发现了它，此后包括 Google 在内的所有人都在违反它（2024 年后主力模型的 (D/N) 普遍在 100–2000）。我认为准确的说法是——Chinchilla 从未被证伪，它只是被换了目标函数（B5 步 16 与失效边界二）；这不是打脸，是约束条件变了。而更深一层的尴尬是：Google 拥有全世界最好的 scaling law 研究能力，却在 2022 年被 ChatGPT 打了个措手不及。**知道怎么最优地花算力，和知道该拿这些算力做什么，是两回事。**我认为这是理解 Gemini 后来那种「技术极强、产品追赶」气质的一把钥匙。

  **图 6.25** **单面板示意图——请先注意它的性质：纵轴没有任何数值刻度，横轴只标了两个位置，这是一张说明性草图而不是实测数据图。**纵轴是 **Pretraining Loss**、横轴是 **Pretraining FLOPs**：要达到同一条水平虚线所标的目标损失 \(\mathscr{L}\)，Chinchilla 最优的 **13B** 需要 **4.5×10²²** 预训练 FLOPs，而图上标注 *train smaller model on more data* 的 **7B** 需要 **5.2×10²²**——即多花约 **16%** 的预训练算力，换一个小得多、推理便宜得多的模型。**⚠️ 推理成本本身并没有画在这张图上**：两个坐标轴都是预训练量，图里没有推理 FLOPs 轴、也没有总预算曲线。「把推理计入总预算后最优模型变小、训练变久」是论文的目标函数结论，**本图只呈现了它在预训练侧的代价**——所以它是这个结论的一个侧面，不是它「最直接的图像证据」。[@src-9234db6adf]出处：Beyond Chinchilla-Optimal（Sardana & Frankle），2024，图 1a

  其一，不要用 Chinchilla 反推 Gemini 的参数量。Gemini 各代的参数量、训练 token 数、专家配置官方从未公开；任何基于 (C=6ND) 的反推都叠了三层假设（B20 步 11），误差可以是数倍。其二，不要把「(D/N) 远大于 20」当成 Google 违背科学。2024 年后所有人都这么做，是因为优化目标从「给定训练算力最小化 loss」换成了「给定训练 + 推理总成本最小化总支出」。其三，注意版本号口径。截至 2026-07-25，最新旗舰是 Gemini 3.1 Pro Preview（仍未 GA），最新 Flash 是 Gemini 3.6 Flash（2026-07-21 GA，上一版 3.5 Flash 于 2026-05-19 GA）；Pro 线与 Flash 线的版本号是脱节的，不要因为 3.6 > 3.1 就以为 Flash 更强。而且 Gemini 3.x 没有技术报告，只有模型卡——2.5 的技术报告（arXiv:2507.06261）是最后一份公开的。这意味着本章所有推导在 Gemini 上都只能作为解释框架，不能作为架构结论。

  把 Chinchilla 当作本章 scaling law 的地基**有两个独立的问题**：**（甲）拟合层面**——Approach 3 的那组系数从未被独立复现，原文报告的置信区间窄到不可能；**（乙）前提层面**——它是一个**无约束**优化的解，而 \(D\) 从 2024 年起有了上界。
  
  
    **（甲）拟合层面。**Besiroglu 等（Epoch AI）从原文图里反解出约 240 个数据点重做拟合，发现原文 Approach 3 的报告置信区间**窄得与数据不相容**，重拟合后的不确定性大得多[@src-d99dacd386][arXiv:2404.10102]（见上方图 6.23）。
      **并且原始的 400+ 次训练三元组至今未公开**——这意味着这条被整个行业当作定律引用的曲线，**三年来没有任何人能真正复现它**。
  
    **（乙）前提层面。**更根本的挑战来自 Ilya Sutskever 在 NeurIPS 2024 Test-of-Time 演讲上的判断：
  
    But **pre-training, as we know it, will unquestionably end.** Why will it end? Because while computation keeps growing through better hardware, better algorithms, and logic clusters—all those things keep increasing your compute—**the data is not growing. We have but one internet.** You could even say **data is the fossil fuel of AI.** It was created somehow, and now we use it. We've achieved peak data and there'll be no more. We have to deal with the data that we have. **It will still let us go quite far**, but there's only one internet.
  
      Ilya Sutskever2024-12-13NeurIPS 2024 Test-of-Time 获奖演讲，Vancouver [@src-0dd9069ae9][原始视频]A（原始视频 + 两份独立逐字稿措辞一致）
  
    **★这段话必须整段引，不能只引前半句。**中文圈广泛流传的版本停在「data is the fossil fuel of AI」，而**紧跟其后的 “It will still let us go quite far” 是同一口气里说出来的限定语**——
      他并没有主张预训练**立刻**失效。另外注意限定词是 **as we know it**：他质疑的是「把整个互联网过一遍」这个**具体配方**，**不是幂律关系本身**。把它读成「标度律失效」是一次系统性误读。
  
    **而且他本人后来又让了一步。**2025-11-25 的 Dwarkesh 访谈里，他把 2020–2025 描述为「scaling 的时代」，并判断「现在又回到研究的时代了，只不过配了大计算机」[@src-24bdaf0e46][官方逐字稿]——**这是一个关于研究范式的判断，不是关于 \(6ND\) 记账是否正确的判断。**
  
  
  
  **（甲）成立的条件**：只要引用的是**那组具体系数**（\(A=406.4,B=410.7,E=1.69\)）或由它算出的精确预测值，反方就成立。**如果引用的只是「存在 \(L=E+A/N^\alpha+B/D^\beta\) 这个形式，且两项的等边际条件决定最优配比」这个结构，反方不成立**——结构层面的推导不依赖那组数字。
  
    **（乙）成立的条件**：\(D^\star(C)\) 超过可用数据存量 \(D_{\max}\)。在 \(D^\star(C)\le D_{\max}\) 的区间内，Chinchilla 解**原样有效**。
  
  正方收窄事实之争（甲）＋归因之争（乙） **两条都成立，但都不构成「Chinchilla 被推翻」。**
  
    **对（甲）**：本章的处理已经是正确的——**全程走一般解 \(N^\star\propto C^{\beta/(\alpha+\beta)}\)，不无条件写 \(C^{1/2}\)**，交互图 6-C 的图注也已声明它只用于说明结构、不可当预测器。反方在这里加强的是**论证的谦逊度，不是结论**。
  
    **对（乙）**：自检一遍——**我是在说 Chinchilla 不够充分，还是在说「数据墙」才是新答案？**只能是前者。
      「预训练终结」本身**也**是一个未被证实的预测，而且提出者自己给了限定语并在一年后调整了措辞。**把「Chinchilla 有前提」升格成「数据墙是新真因」，正是本轮要避免的那种叙事替换。**
      正确的接续不是「Chinchilla 失效」，而是「Chinchilla 需要一个带约束的版本」——那个版本已经有人写出来了，见下一节。

  B5 附 · Chinchilla 之后的两条直接扩展：这一节不能停在 2022 年

  上面（乙）留下的那个接口——「(D) 有上界之后该怎么办」——在 2023–2025 年已经被两条新的标度律接上了。它们都不是对 Chinchilla 的否定，而是把它的适用域切开、各自补上一块。本章此前完全没有覆盖这两条，这是一处遗漏（不是错误），本轮补上。

| | 标度律 | 它优化的问题 | 与原 Chinchilla 的作用域差异 | 核心结论 | 验证规模（★外推风险在这一列）

| | 原 Chinchilla Hoffmann et al., 2022 | 给定训练算力 (C)，最小化预训练 loss | —（基准） | (N) 与 (D) 应同步增长；在 (\alpha\approx\beta) 时给出约 20 tokens/param | 最大 16B 参数 / 500B token；单 epoch、稠密、无数据上界

| | data-constrained scaling Muennighoff et al., NeurIPS 2023 → JMLR v26^[11][2305.16264] | 给定训练算力 (C) 且 (D\le D_{\max})，最小化 loss——即数据成为约束时怎么分配 | 放开了「每条数据只看一遍」这个隐含前提。原 Chinchilla 的 (D) 是唯一 token 数；这条 law 里 (D) 拆成「唯一数据量 × epoch 数」，多出一个自由度 | 重复到 4 个 epoch，验证损失与全新数据的差异可忽略（8.7B 模型 4 epoch 仅高 0.5%，下游无显著差异）；约 16 epoch 是半衰期，之后新增算力价值迅速衰减到零。数据受限时应让 epoch 数比参数量涨得更快 | 400+ 次训练，最大 9B 参数 / 900B token。★要用到前沿规模需外推约三个数量级，公开文献里没有任何一方做过这个验证

| | distillation scaling law Busbridge et al.（Apple）, ICML 2025^[12][2502.08606] | 给定学生算力预算，蒸馏与监督预训练哪个更划算 | 换了被优化的对象。原 Chinchilla 优化的是「从零训一个模型」；这条 law 优化的是「已经有一个 teacher 时该怎么办」，目标函数里多了一项可摊销的沉没成本 | teacher 的规模与 token 数只通过 teacher 的交叉熵影响学生（这是非平凡结论）；蒸馏仅在两条同时满足时才优于监督学习——(i) 学生算力不超过一个随学生规模可预测增长的阈值，(ii) teacher 已存在或成本可摊销。若只蒸一个学生且 teacher 要从头训，应该直接做监督预训练。另有反直觉推论：最优 teacher 规模随总算力先增后趋平甚至下降 | 143M–12.6B 的师生对，最多 512B token

    表 6.3 · Chinchilla 之后两条直接扩展的作用域对照。**请注意第三列而不是第四列**——三条 law 之所以能共存而不打架，是因为**它们优化的根本不是同一个问题**：
      一条问「算力怎么分」，一条问「数据不够时算力怎么分」，一条问「有 teacher 时还要不要自己训」。
      **把它们并排当成「三个互相矛盾的答案」是一种误读；它们是三张互不重叠的地图。**




2024 年之后有一种流行说法：**scaling law 这个范式失效了**。上表是对它最直接的反驳——**2023–2025 年至少产出了两条新的、拟合良好、且带可操作推论的标度律**，而且它们的方法论与 Chinchilla 完全一致（扫一批规模、拟合一个参数化形式、给出最优配比）。**失效的不是范式，是「预训练」这个特定的研究对象的垄断地位。**

  把 B5、上表两条、以及 B18 的 MoE 侧放在一起，能看出研究对象的扩散路径：**预训练 → 重复数据 → 蒸馏 → MoE → RL**。每往前走一步，被优化的目标函数就换一次，而**数学工具一步没换**。这是一个健康的领域该有的样子。

  **但也要如实说出代价。**上表最后一列给的是验证规模：9B、12.6B。而本章讨论的对象是万亿参数级的前沿模型。**这两条 law 在被用到 Gemini 这个量级上时，外推跨度都在两到三个数量级——它们比 Chinchilla 更新，但不比 Chinchilla 更可靠。**本章引用它们，是因为它们填上了「数据受限」与「有 teacher」这两个 Chinchilla 答不了的问题，**不是因为它们的外推更值得信任。**

### 交互 6-B · \(k/E\) 到底低估了多少

B18 反复强调 \(k/E\) 只是 expert-only 极限近似。这张图把误差画出来：
  蓝线是**整模型的真实激活比** \(\rho=\dfrac{r+k/E}{r+1}\)（\(r=P_s/(EP_e)\) 是共享参数与专家参数之比），
  橙线是**朴素的 \(k/E\)**。两个空心点是可核对的公开锚点——
  GLaM 与 Gemma 4 的官方数字都落在蓝线一侧，而不是橙线。



    整模型激活比 vs \(k/E\) 近似
    拖动滑杆改变专家数、激活数与共享参数占比





    锚点数据：**GLaM** 1.2T 总参 / 96.6B 激活 = 8.3%，而 \(k/E=2/64=3.1\%\)
    （[@src-9e69989f50]arXiv:2112.06905）；
    **Gemma 4 26B-A4B** 3.8B 激活 / 128 专家取 8 + 1 shared，激活比约 15%，而 \(k/E=8/128=6.3\%\)
    （[@src-20e9cbbba2]Google, 2026-04-02）。
    **Gemini 的专家数与 top-k 官方从未披露**，本图不含任何 Gemini 参数。




### 交互 6-C · Chinchilla 最优点：把 20:1 拆开看

拖动算力预算 \(C\)，曲线是在该预算下损失随参数量 \(N\) 的变化（\(D=C/6N\) 由约束决定），
  黄点是最优点。**真正要试的是两个指数滑杆**：把 \(\alpha\) 和 \(\beta\) 拨得不相等，
  最优配比 \(D^\star/N^\star\) 会立刻偏离 20——这就是为什么
  「\(N,D\propto C^{1/2}\)」只在 \(\alpha\approx\beta\) 时成立。



    给定算力预算下的最优参数量
    拖动 C / α / β，看最优点与 D*/N* 怎么移动





    曲线用 Hoffmann et al. 2022 Approach 3 的拟合系数 \(A=406.4,\ B=410.7,\ E=1.69\)，约束取 \(C=6ND\)
    （[@src-46fd66187e]arXiv:2203.15556）。
    **请注意**：Epoch AI 的复现（[@src-d99dacd386]arXiv:2404.10102）指出
    原文这组系数的报告置信区间窄得不可能，重拟合后不确定性大得多。
    本图用于说明**结构**（指数如何决定配比），不应被当作可外推的预测器。




## 组 4 · 推理期计算

前三组的公式都在回答「训练时这一份算力该怎么花」。这一组换了战场：**模型已经训完、参数一个不动，只在推理时多花算力，能买到什么。**三条线各自独立、彼此咬合——B7 说明多采样的收益形状（幂律逼近 1，但要有人来判对错），B8 说明同一份延迟预算里如何塞进更多 token（投机解码，且输出分布严格不变），B9 说明如何把一个贵模型的行为压缩进一个便宜模型（蒸馏，但压不出 teacher 没有的东西）。

把三者放在一起看，Google 的产品矩阵就有了公式层面的解释：Gemini 3.1 Pro Preview 承担 teacher 与高算力推理，Gemini 3.6 Flash（2026-07-21 GA）承担被蒸馏后的高吞吐主力，而 thinking_budget / thinking_level 这个 API 参数，就是 B7 里那个「最优策略依赖题目难度与算力预算」的直接产品化。

### B7 · pass@k 的无偏估计量、majority@k 的饱和与 test-time compute 的天花板

**一句话。**多次采样让「至少答对一次」的覆盖率按**幂律**逼近 1、没有上界；多数投票只有在**唯一众数**（正确答案严格比每一个错误答案都更常被采到）这一前提下才按**指数**快速收敛，而且收敛到的仍然是「模型最常给的那个答案」——两条曲线形状的差距，就是 verifier（验证器）的全部价值。



    B7
    pass@k 的组合数无偏估计量、难度重尾与 majority@k 的结构性天花板
    Chen et al., 2021 · arXiv:2107.03374 ／ Brown et al., 2024 · arXiv:2407.21787 ／ Snell et al., 2024 · arXiv:2408.03314




      符号表

| | (p) | 单次独立采样答对的概率，即理论 pass@1 | ([0,1])，未知，需估计

| | (k) | 「一道题允许尝试几次」的次数；也是投票数 | 正整数

| | (n) | 为估计 pass@k 而实际生成的总样本数 | 正整数，要求 (n\ge k)

| | (c) | (n) 个样本中通过验证的个数 | 整数，(0\le c\le n)

| | (\hat p) | pass@1 的朴素频率估计 (\hat p=c/n) | ([0,1])，对 (p) 无偏

| | (a,\ b) | 题目难度分布 (p\sim\mathrm{Beta}(a,b)) 的形状参数 | (>0)；(a) 控制 (p\to0^+) 的尾部厚度

| | (m) | 该题上互不相同的可能答案个数（含正确答案） | 整数 (\ge 2)

| | (p_1) | 「正确答案」被采到的概率 | ((0,1))

| | (p_j) | 第 (j) 个错误答案被采到的概率，(j=2,\dots,m) | ([0,1))，(\textstyle\sum_{j=1}^{m}p_j=1)

| | (p_2) | 约定排序后 (p_2\ge p_3\ge\cdots)，故 (p_2) 是最高频错误答案的概率 | ([0,1))

| | (X_j) | (k) 次采样中答案 (j) 得到的票数 | 整数，(\textstyle\sum_j X_j=k)

| | (\rho_j) | 第 (j) 项的 Chernoff 基底 (1-(\sqrt{p_1}-\sqrt{p_j})^{2}) | ((0,1])

| | (D_2) | 整体指数 (-\ln\rho_2)（由最高频错误答案决定） | (\ge 0)

| | (q) | 一道 prompt（题目） | —

| | (\theta) | test-time 策略的超参（best-of-N / beam / 修订轮数 …） | —

| | (N) | 该题分配到的推理算力预算 | (>0)

逐步推导 · 共 16 步（点击展开）
**先把「理论量」与「观测量」分清楚。**假设对同一道题独立采样 \(k\) 次、每次答对概率恒为 \(p\)，那么「\(k\) 次里至少对一次」的补事件是「\(k\) 次全错」，于是

[ \operatorname{pass@}k ;=; 1-(1-p)^{k}. ]这只是一个定义式，不是估计量。它的输入 (p) 是模型在这道题上的真实成功概率，评测时谁也不知道。整节后面的麻烦全部来自「(p) 未知」这一件事。

    **最自然的做法——插值估计——是错的。**采 \(n\) 次、数出 \(c\) 次正确、令 \(\hat p=c/n\)，然后代进上式得 \(1-(1-\hat p)^k\)。它**系统性偏低**。证明只需要一个二阶导数。令 \(g(p)=1-(1-p)^k\)：

[ g’(p)=k(1-p)^{k-1},\qquad g”(p)=-k(k-1)(1-p)^{k-2};0)：

[ \varphi_j=p_ju+\frac{p_1}{u}+(1-p_1-p_j),\qquad \frac{d\varphi_j}{du}=p_j-\frac{p_1}{u^{2}},\qquad \frac{d^{2}\varphi_j}{du^{2}}=\frac{2p_1}{u^{3}};>;0 . ]一阶条件 (p_ju=p_1/u) 给出 (u^{2}=p_1/p_j)，二阶导恒正说明它是唯一极小点，于是

[ \boxed{;\lambda^{}=\ln u^{}=\tfrac12\ln!\big(p_1/p_j\big).;} ]代回并合并：

[ \varphi_j(\lambda^{*})=p_j\sqrt{\tfrac{p_1}{p_j}}+p_1\sqrt{\tfrac{p_j}{p_1}}+1-p_1-p_j =2\sqrt{p_1p_j}+1-p_1-p_j =1-\big(\sqrt{p_1}-\sqrt{p_j}\big)^{2}=:\rho_j, ][ \Longrightarrow\qquad \Pr\big[X_j\ge X_1\big]\ \le\ \rho_j^{,k}. ](\rho_j) 还有一个精确身份：它就是真分布 (P=(p_1,\dots,p_m)) 与「把标签 1 和 (j) 对调后」的分布 (P^{(1\leftrightarrow j)}) 之间的 Bhattacharyya 系数：

[ \sum_{a}\sqrt{P(a),P^{(1\leftrightarrow j)}(a)}=\sqrt{p_1p_j}+\sqrt{p_jp_1}+!!\sum_{a\ne 1,j}!!p_a=2\sqrt{p_1p_j}+1-p_1-p_j=\rho_j. ]那个 (\tfrac12) 是怎么来的。(\varphi_j) 是 (u) 与 (1/u) 的加权和，这种形式的最小值必然落在「两支相等」的地方（(p_ju=p_1/u)）；一阶条件解出的是 (u^{2})，取对数时那个平方就变成了 (\tfrac12)。同样的结构解释了为什么最优指数长成几何平均 (2\sqrt{p_1p_j}) 而不是算术平均。 Bhattacharyya 那一行的含义。「投票分不分得清 1 和 (j)」被化归成「这两个假设有多难区分」——(\rho_j\to1) 当且仅当 (p_j\to p_1)，此时界变得平凡。**还要记住一个符号条件：(\lambda^{*}\ge0\iff p_1\ge p_j)。**它看起来像技术细节，其实是下一步整条结论的开关。 数值锚点。(p_1=0.5,\ p_j=0.2)：(\rho_j=1-(\sqrt{0.5}-\sqrt{0.2})^{2}=0.93246)，(D_j=-\ln\rho_j\approx0.06992)。作为对照，把 (Z_t\in[-1,1])（区间宽度为 2）代进 Hoeffding 得指数 (\frac{2(p_1-p_j)^{2}}{2^{2}}=\frac{(p_1-p_j)^{2}}{2}=0.045)，Chernoff 紧约 1.55 倍。区间宽度必须取 2；若误按宽度 1 写成 ((p_1-p_j)^{2}/4=0.0225)，会把 Hoeffding 低估一半、从而把 Chernoff 的优势夸大成三倍以上。

    **对所有错误答案取 union bound，并把前提写死。**第 (11) 步的包含关系加上第 (12) 步的逐项界，直接给出

[ \boxed{;\Pr\big[\text{多数投票出错}\big]\ \le\ \sum_{j\ne 1}\Big[1-\big(\sqrt{p_1}-\sqrt{p_j}\big)^{2}\Big]^{k};=;\sum_{j=2}^{m}\rho_j^{,k};} ]成立前提：唯一众数（unique mode），即 (p_1>p_j) 对每一个 (j\ne1) 都成立。只有这样才有 (\rho_jp_1) 时第 (12) 步的最优 (\lambda^{*}=\tfrac12\ln(p_1/p_j)X_j\big]\ \le\ \rho_j^{,k},\qquad \rho_j=1-\big(\sqrt{p_1}-\sqrt{p_j}\big)^{2}p_2) 时加算力让你越来越对，(p_10; \qquad \lim_{k\to\infty}\Pr\big[\operatorname{majority@}k\ \text{对}\big]=\mathbf 1\Big[p_1>\max_{j\ne1}p_j\Big]. ]pass@k 没有上界：只要模型有任何非零概率答对，采样够多就一定能捞到那一次。majority@k 有结构性天花板：如果模型的众数答案是错的（(p_1p_j\ \forall j\ne1) 时给出指数衰减；否则界平凡失效，且投票会指数地收敛到错误答案。此外 union bound 本身是松的（各 ({X_j\ge X_1}) 事件之间负相关，因为票数总和固定为 (k)），所以 (\sum_j\rho_j^k) 是一个可能相当保守的上界，不宜反过来当成错误率的估计。

• **A6 · 难度分桶用了 oracle。**第 (15) 步 Snell 的分桶依赖 2048 次采样估出的真实 pass@1，部署时不可得；论文用 verifier 打分的 “model-predicted difficulty” 替代，性能有损失，且这部分估计成本没有计入预算。

• L1 · 「无偏」不等于「准」。无偏是对重复整个生成实验取期望的性质。单次评测里 (c) 本身有二项方差，(n) 小时估计量抖动很大。报告 pass@k 时不给 (n)，等于没给误差条。

• L2 · 不同 (k) 之间数学上不可比。(\operatorname{pass@}1) 与 (\operatorname{pass@}10) 不是同一个量的两个测量值，而是两个不同的量。把它们放进同一张表的同一列是错误的。

• **L3 · verifier 是硬天花板。**第 (14) 步的 (k\to\infty\to1) 只在有 oracle verifier 时可兑现。代码（单元测试）、形式化证明（Lean）自带验证器；GSM8K / MATH 用的「比对标准答案」在部署时根本不存在。Brown 论文把这单列为 “precision problem”：从一万个候选里挑出对的那个，本身就是未解决的难题。

• L4 · majority@k 的饱和在唯一众数被违反时是结构性的（第 (13)–(14) 步），加算力无法修复，反而加速收敛到错误答案。需要说明的是，「模型在某类题上系统性地把众数放在错答案上」这件事的覆盖面有多大，现有公开证据不足以判定：它在有对抗性干扰项的多选题、以及有常见误解陷阱的数学题上被反复观察到，但缺少跨 benchmark 的系统统计。Snell 也观察到 best-of-N 在最难的题上收益极小。

• L5 · 「14 倍预训练」被过度引用。Snell 的对照实验条件是：FLOPs 对齐、MATH 数据集、PaLM 2-S*、且需要专门微调出修订与验证能力。论文本身明说最难的题上 test-time compute 收益很小、还是得靠预训练。脱离这组条件复述这个数字就是错的。

• **L6 · Gemini 侧定量数据薄弱。**Gemini 2.5 技术报告给出了 thinking budget 与分数的单调关系曲线，但 3.x 只有模型卡、没有技术报告；Deep Think 的并行度、是否使用 PRM / verifier、thinking 与最终回答的算力配比，官方全部未披露。

    pass@k 必须用组合数估计量 \(1-\binom{n-c}{k}/\binom{n}{k}\)；\(1-(1-p)^k\) 只是固定采样分布下的理论量，\(1-(1-c/n)^k\) 因为 \(g''p_j\ \forall j\ne1\) 下有效**，否则投票会以同样的指数速度收敛到错误答案。**两条曲线的形状差 = verifier 的价值。**

  图 6.27　五个任务上覆盖率随采样数的增长，版式是「左一大 + 右 2×2」共五个面板。左侧大面板 SWE-bench Lite：横轴只跨 1→约 250（约 2.4 个数量级，不是四个），蓝线由约 16% 升到标注的 56%，先后越过 24.67% 的 GPT-4o 单次基线与 43% 的单次 SOTA。右侧 2×2 是 MiniF2F-MATH、CodeContests、MATH (Oracle Verifier)、GSM8K (Oracle Verifier)，横轴均跨 1→10⁴ 四个数量级。**⚠️ 读法必须分两类看，不能一句「始终没有走平」带过：**在远未饱和的任务上（CodeContests 升到 0.22 / 0.38、MiniF2F-MATH 升到约 0.5、SWE-bench Lite 升到 56%）曲线到图的右端仍在稳定上升，这才是第 (9)–(10) 步「幂律、无上界」的经验形态；但 MATH 与 GSM8K 这两个带 Oracle Verifier 的面板早在 10³ 之前就贴到 0.97–0.99 走平了——那是覆盖率触到 100% 天花板的饱和，不能当作无上界的证据。来源：Brown, Juravsky, Ehrlich, Clark, Le, Ré, Mirhoseini，Large Language Monkeys，2024，^[13][arXiv:2407.21787] 图 2

  图 6.28　覆盖率的指数化幂律拟合，共 8 个面板（2 行 4 列），覆盖 5 个模型（Llama-3-8B / 70B-Instruct、Pythia-70M / 12B、Gemma-2B）× 3 个任务（MATH with Oracle Verifier、CodeContests、MiniF2F-MATH）。图上把拟合式印为 (c=\exp(a,k^{-b}))，并在每个面板标题里给出该面板拟合出的 ((a,b))，例如 Llama-3-8B-Instruct 在 MATH 上是 (a=−0.58, b=−0.43)、在 CodeContests 上是 (a=−1.69, b=−0.11)。读法的要点是蓝色实测线与橙色拟合线在全部 8 个面板上都贴合得很紧——经验幂律成立的范围相当宽。⚠️ 第 (10) 步把这里的指数与难度分布形状参数联系起来时请注意换记号：正文用的 (A,B)（(\log c\approx A k^{B})）与图上印的 (a,b) 不是同一套符号，图上的 (a) 是拟合系数、不是难度分布的形状参数；对应关系是正文的 (B) ↔ 图上的 (-b)。来源：Brown et al.，Large Language Monkeys，2024，^[13][arXiv:2407.21787] 图 5

  它到底在说什么。这一节其实是两种认识论的对照，而不是两个技术选项的对照。pass@k 假设真理的判据在模型之外（verifier），采样只是搜索，所以它能超越模型自身的置信度排序；majority@k 假设真理就是模型自己的众数，采样只是降噪，所以它最多榨干模型、永远无法超过它。幂律慢但无穷，指数快但有顶。

第 (12)–(13) 步那个 Bhattacharyya 形式的指数把这件事说得更锋利：投票的收敛速率 (-\ln\big[1-(\sqrt{p_1}-\sqrt{p_j})^2\big]) 度量的是**「正确答案」与「某个错误答案」这两个假设有多难区分**，而不是「正确答案有多正确」。**它是一个纯粹的可辨识性量，里面没有任何关于真值的信息。**所以只要模型把众数放错了地方，这个指数就原封不动地反过来为错误答案服务。

由此可以推出一个我认为被严重低估的判断：**test-time compute 的真正瓶颈从来不是「想多久」，而是「谁来判对错」。**这解释了为什么 2024 年之后所有严肃的推理工作都在做验证器——PRM、RLVR、形式化证明、代码执行反馈；也解释了为什么数学和代码率先突破——它们碰巧自带 oracle verifier。第 (14) 步那个 (p_1=0.30T_p)、batch 已满、draft 串行开销放回去，真实数字会明显更低。任何把这个数写成「投机解码能提速 2.8 倍」的表述都是错的。

    **最优 \(\gamma\) 的一阶条件与「往哪个方向优化」。**令 \(L=-\ln\alpha>0\)，对 \(\log S_{\text{ideal}}\) 求导得

[ \frac{\alpha^{\gamma+1}L}{1-\alpha^{\gamma+1}}=\frac{c}{\gamma c+1}. ]左端随 (\gamma) 指数衰减，右端只以 (1/\gamma) 衰减，故至多一个交点且即极大值点。存在使加速的 (\gamma) 的近似条件是 (\alpha>c)。数值上（(c=0.05)）：

[ \begin{aligned} \alpha=0.6&:\ \gamma^{}=4,\ S\approx1.92\times,\ \text{天花板}\ 2.50\times\ (\text{达成率}\ 77%)\ \alpha=0.8&:\ \gamma^{}=8,\ S\approx3.09\times,\ \text{天花板}\ 5.00\times\ (62%)\ \alpha=0.9&:\ \gamma^{*}=13,\ S\approx4.67\times,\ \text{天花板}\ 10.00\times\ (47%) \end{aligned} ]「达成率」这一列揭示了一个不对称性：(\alpha) 越高，实际加速离天花板越远。因为天花板要求 (\gamma\to\infty)，而 (\gamma) 每加 1，分母的 (\gamma c+1) 线性变大、分子只以几何速率逼近 1。推论：把草稿模型做得更准，边际收益递减；把草稿模型做得更便宜，边际收益递增。这个不对称直接决定了工业界的演进方向——从「独立小 Transformer」转向 Medusa（目标模型上挂多头）^[14][Medusa]、EAGLE（在特征层而非 token 层投机）^[15][EAGLE]、prompt lookup（零成本 n-gram 复制），本质都是把 (c) 往 0 压，而不是把 (\alpha) 往 1 推。

• **A1 · 位置间 iid。**第 (8) 步假设各位置接受事件独立、接受率恒为 (\alpha)。真实序列里接受率随前缀剧烈波动（句首与实体名难猜，虚词与代码缩进易猜）；原论文明说这只是简化。

• **A2 · 并行验证不增加墙钟。**第 (9) 步的理想式要求 (T_v(\gamma)\approx T_p)，即系统处于访存受限区、算力有富余。

• **A3 · 生成足够长。**忽略首尾边界；至少要跑一次 (M_p)，加速比被总生成长度上界卡住。

• **A4 · 同一套采样语义。**草稿与目标必须用同样的 temperature / top-k / top-p。否则 (p,q) 不是同一采样语义下的分布，(\alpha) 会莫名塌陷。

• **L1 · (\alpha) 随温度显著漂移。**原论文 Table 3：T5-XXL(EnDe) + T5-small，(T=0) 时 (\alpha=0.75)，(T=1) 时降到 (0.62)；CNN/DM 上 (0.65\to0.53)。分布越尖锐 (\alpha) 越高——低温的代码与翻译收益最好，高温的创意写作收益最差。

• L2 · 大 batch 时收益骤减。A2 的前提是访存受限。batch 增大后目标模型本身已算术密集（权重读取被摊薄），此时并行验证 (\gamma+1) 个位置是真实的额外算力开销。原论文给出总算力放大倍数 (\frac{(1-\alpha)(\gamma\hat c+\gamma+1)}{1-\alpha^{\gamma+1}})：(\alpha=0.9,\gamma=10) 时算力 ×1.60 换 6.86× 加速（划算）；(\alpha=0.6,\gamma=2) 时算力 ×1.53 只换 1.96×（勉强）。在大 batch 服务场景，这个「算力税」直接等价于吞吐损失。

• L3 · 本质是访存视角。目标模型权重与 KV cache 的 HBM 读取次数按 (\mathbb E[K]) 倍减少——投机解码是「一次访存摊到多个 token」，收益上限由硬件的带宽/算力比（roofline ridge point）决定，而不是由算法决定。

• L4 · 与 beam search 不兼容（原论文只在附录给了一个带惩罚的近似方案）。

• L5 · lenience 会破坏无损性。引入松弛参数 (l) 可把 (\alpha) 从 0.62 拉到 0.84、加速从 2.5× 到 5×，但输出分布不再严格等于 (p)，只保证任一 token 的采样概率不超过真值的 (1/l) 倍，且对多样性无下界保证。一旦开 lenience，第 (5) 步的定理就作废了，必须重新评测。

• **L6 · 固定 (\gamma) 是次优的。**理想做法是预测当前位置好不好猜、动态调 (\gamma)。原论文估算：若有完美的 (\gamma) 预言机，期望产出可达 (1/(1-\alpha)) 而非被截断的 (\mathbb E[K])，加速可再高约 60%。生产系统至今只部分兑现（典型做法是用草稿模型自身置信度做早停）。

• **L7 · 树形投机把 L2 放大。**Medusa / SpecInfer / EAGLE 把线性草稿改成树形，有效 (\alpha) 上升，但分母里的成本项随候选数增长，而且验证位置从 (\gamma+1) 个变成几十个后，A2 在真实 batch 下率先失效。树形投机只在极低 batch（本地部署、单用户）场景划算。

    \(\mathbb E[K]=\frac{1-\alpha^{\gamma+1}}{1-\alpha}\)，一般加速比 \(S=\frac{\mathbb E[K]T_p}{\gamma T_q+T_v(\gamma)+T_{\rm overhead}}\)，理想式 \(S_{\rm ideal}=\frac{1-\alpha^{\gamma+1}}{(1-\alpha)(\gamma c+1)}\)。接受率 \(\alpha=1-\mathrm{TV}(p,q)\)。修改版拒绝采样使输出分布**严格等于目标模型**（第 (5) 步），与草稿模型质量无关。\(\alpha=0.8,\gamma=4,c=0.05\) 给出 \(\mathbb E[K]=3.3616\)、\(S_{\rm ideal}\approx2.8013\)——**这是理想上界，不是保证**。

  图 6.35　投机解码的逐轮示意：草稿提议 → 目标模型一次前向并行校验 → 接受前缀 + 在首个拒绝处从残差分布重采。图中每一行是一轮，被接受的 token 数就是第 (8) 步的随机变量 (A)。来源：Leviathan, Kalman, Matias（Google Research，ICML 2023 oral），2022，^[16][arXiv:2211.17192] 图 1

  **它到底在说什么。**投机解码是我见过的「用系统瓶颈的结构换算法收益」最干净的例子。它的深刻之处不在采样技巧，而在于先识别出：**LLM 解码的成本函数不是 FLOPs，而是串行的 HBM 往返次数。**一旦看清这点，「多算 (\gamma) 倍但只串行一次」就是纯赚。

更值得玩味的是第 (6) 步的 (\alpha=1-\mathrm{TV}(p,q))。它把「草稿模型有多好」这个含糊的工程问题，化归成一个纯粹的信息论量——而且这个量与草稿模型的绝对能力无关，只与它和目标模型的重合度有关。这也带来一个结构性推论：投机解码与蒸馏（B9）是天然互补的。蒸馏的目标恰恰是最小化 student 与 teacher 的分布距离，所以一个蒸馏出来的小模型，本身就是它 teacher 的最优草稿模型——不需要为投机解码额外训练任何东西。原论文在 Discussion 里点到了这个方向（“standard distillation with soft targets from (M_p)”），但留作了 future work。

**事实层。**投机解码是 **Google 自家发明的，而且是两个团队几乎同期独立发明的**：Leviathan / Kalman / Matias 的 arXiv:2211.17192 出自 **Google Research**（实验在 TPU-v4 上对 T5-XXL 与 LaMDA 137B 做的）；三个月后 Chen, Borgeaud, Irving, Lespiau, Sifre, Jumper 的 arXiv:2302.01318 出自 **DeepMind**，在 Chinchilla 70B 上独立报告 2–2.5×。[@src-2a5906b299][DeepMind 版] 同一家公司两个实验室在同一季度独立发明同一算法——这本身就是「访存瓶颈」在 Google 内部共识之深的硬证据。

可验证的生产落地在 Gemma 一侧。2026 年 Google 官方为 Gemma 4 家族发布了 Multi-Token Prediction（MTP）drafter，官方博客明确把它追溯到 2022 年那篇自家论文；其中一个关键设计是草稿器与目标模型共享 KV cache（cross-model KV sharing），因此草稿器完全不必重算上下文、也不占额外 KV 显存——这在 B8 的记号里就是把 (c) 压得更低。

推测 **Gemini 本体是否使用投机解码，Google 从未在任何技术报告或模型卡中确认。可以确定的只有三条：技术由 Google 发明、Gemma 已明确使用、TPU 推理栈已有成熟实现。「Gemini Flash 的低延迟来自投机解码」是外部推断，不能写成事实。**还有一层值得注意的技术张力：Gemini 是 MoE，而 MoE 上验证多个 token 会激活更多专家（不同 token 路由不同），削弱了「验证 (\gamma) 个几乎免费」这个前提——所以即便用了，形态也未必与稠密模型上的经典配方相同。

两个最常被误用的点：

• (\alpha) 不是「这对模型的一个固定常数」。它随 prompt、随位置、随 temperature、随 top-p 剧烈变化（L1 给出的实测：同一对模型上 (T=0\to1) 让 (\alpha) 从 0.75 掉到 0.62）。把某篇论文报告的 (\alpha) 搬到自己的场景直接代入 (S_{\text{ideal}})，得到的数字没有意义。正确做法是在目标流量分布上实测 (\alpha) 的分布，而不是取一个点估计。

• (T_v(\gamma)\ne T_p)。「目标模型并行验证 (\gamma+1) 个位置」在 FLOPs 上确实可以一次算完，但延迟不等于一个 decode step：注意力要算 (\gamma+1) 个 query 对全部 KV、logits 要算 (\gamma+1) 份、采样与 host 同步也变多。理想式把 (T_v) 按成 (T_p)，等于免费送了一整个 (\gamma)。这就是为什么本节坚持先写一般式 (S=\frac{\mathbb E[K]T_p}{\gamma T_q+T_v(\gamma)+T_{\rm overhead}}) 再写理想式——报告加速比时不声明 (T_v) 的处理方式，等于没有报告。 还有一条常被忽略：(\mathbb E[K]\le 1/(1-\alpha)) 是硬天花板，与 (\gamma) 无关。(\alpha=0.8) 时无论 (\gamma) 取多大，期望产出都不会超过 5 个 token/轮。看到宣称远超 (1/(1-\alpha)) 的加速数字，要么 (\alpha) 被低估了，要么开了 lenience（L5，已不再无损），要么口径换成了吞吐而非单请求延迟。

  B9 · 蒸馏的 KL 目标、温度的 (1/T^{2}) 梯度尺度与 on-policy 蒸馏（GKD）

  一句话。软标签把 teacher 的整条条件分布而不是一个 one-hot 交给 student，其收益等于消除了标签抽样的全部方差；温度 (T) 让梯度按 (1/T^{2}) 缩水，所以损失里必须乘回 (T^{2})；而真正决定长文本蒸馏成败的不是散度方向，是数据从谁的分布里来。

    B9
    从 Hinton 的温度软化到 GKD 的 on-policy 蒸馏
    Hinton, Vinyals, Dean, 2015 · arXiv:1503.02531 ／ Agarwal et al.（Google DeepMind），2023 · arXiv:2306.13649
  
  
  
  
      符号表

| | z_s, z_t | student / teacher 的 logits (z_s,z_t) | (\mathbb R^{K})，(K) 为类别数或词表大小

| | T | 蒸馏温度 (T) | (\ge1)，Hinton 实验常用 2–20

| | sigma | softmax 算子 (\sigma(\cdot)) | (\mathbb R^{K}\to) 概率单纯形

| | lambda | 软标签项在复合损失中的权重 (\lambda) | ([0,1])

| | z-bar | logits 的均值 (\bar z=\tfrac1K\sum_i z_i) | 标量

| | p_T, p_S | teacher / student 的 token 级条件分布 (p_T,\ p_S^{\theta}) | 概率单纯形

| | beta | 广义 JSD 的插值系数 (\beta) | ((0,1))

| | lambda_on | GKD 中 student 自采样数据所占比例 (\lambda_{\text{on}}) | ([0,1])

| | L_y | 序列 (y) 的长度 (L_y) | 正整数

逐步推导 · 共 12 步（点击展开）
**起点：Hinton–Vinyals–Dean 的复合目标。**硬标签交叉熵 + 温度软化后的 KL：

[ L=(1-\lambda),H\big(y,\sigma(z_s)\big);+;\lambda,T^{2},\mathrm{KL}\Big(\sigma(z_t/T)\ \Big|\ \sigma(z_s/T)\Big). ]要问的问题只有一个：那个 (T^{2}) 是从哪来的？不写会怎样？

这三位作者值得一提：Hinton、Oriol Vinyals（现 Gemini 联合技术负责人）、Jeff Dean（Google 首席科学家）。一篇 2015 年的短文与今天的 Gemini 有直接的人事连线。

    **先算软标签项对 student 的 softmax 输入的梯度。**记 \(u=z_s/T,\ v=z_t/T,\ s=\sigma(u),\ t=\sigma(v)\)。展开 \(\mathrm{KL}(t\|s)=\sum_i t_i\log t_i-\sum_i t_i\log s_i\)，只有第二项含 \(u\)。用 softmax 的对数导数 \(\partial\log s_i/\partial u_j=\delta_{ij}-s_j\)：

[ \frac{\partial,\mathrm{KL}(t|s)}{\partial u_j}=-\sum_i t_i(\delta_{ij}-s_j)=-t_j+s_j\underbrace{\textstyle\sum_i t_i}_{=1}=s_j-t_j. ]这是交叉熵梯度的经典形式「预测减目标」。注意此处的 (s,t) 都是温度软化后的分布。

    **链式法则再乘一层 \(1/T\)。**因为 \(u_j=z_{s,j}/T\)，故 \(\partial u_j/\partial z_{s,j}=1/T\)：

[ \frac{\partial,\mathrm{KL}}{\partial z_{s,j}}=\frac{1}{T}\Big(\sigma(z_s/T)_j-\sigma(z_t/T)_j\Big). ]表面上只有一个 (1/T)。真正的第二个 (1/T) 藏在括号内部——括号里那个差本身也随 (T) 增大而变小，因为高温把两个分布都推向均匀。下一步把它揪出来。

    **高温一阶展开。**当 \(T\gg\max_i|z_i|\) 时 \(z_i/T\to0\)，用 \(e^{x}\approx1+x\)：

[ \sigma(z/T)_i=\frac{e^{z_i/T}}{\sum_k e^{z_k/T}}\approx\frac{1+z_i/T}{K+\frac1T\sum_k z_k}=\frac{1+z_i/T}{K\big(1+\bar z/T\big)}, ]再对分母用 (1/(1+\epsilon)\approx1-\epsilon)：

[ \sigma(z/T)_i\approx\frac1K\Big(1+\frac{z_i}{T}\Big)\Big(1-\frac{\bar z}{T}\Big)\approx\frac1K+\frac{z_i-\bar z}{KT}+O(T^{-2}). ]关键结构：零阶项是与 logits 无关的常数 (1/K)（均匀分布），一阶项正比于中心化 logit ((z_i-\bar z)) 且带一个 (1/T)。

    **代回第 (3) 步，常数项精确抵消，\(1/T^{2}\) 现形。**

[ \frac{\partial,\mathrm{KL}}{\partial z_{s,i}} \approx\frac1T\left[\Big(\frac1K+\frac{z_{s,i}-\bar z_s}{KT}\Big)-\Big(\frac1K+\frac{z_{t,i}-\bar z_t}{KT}\Big)\right] =\boxed{\ \frac{1}{KT^{2}}\Big[(z_{s,i}-\bar z_s)-(z_{t,i}-\bar z_t)\Big]\ } ]两个 (1/K) 相减为零，剩下的两项各带一个 (1/T)，与外层的 (1/T) 相乘得到 (1/T^{2})。**这就是 (T^{2}) 因子的全部来历。**若不乘 (T^{2})：把 (T) 从 1 调到 10，软标签项的梯度缩小 100 倍，被硬标签项完全淹没，(\lambda) 的调参含义会随 (T) 漂移——你以为在调权重，其实在调尺度。乘上 (T^{2}) 后梯度变为 (\tfrac1K[(z_{s,i}-\bar z_s)-(z_{t,i}-\bar z_t)])，与 (T) 无关，两项量级可比。

    **顺带得到一个漂亮的等价：高温 KD 就是中心化 logit 的最小二乘。**考察 \(J=\tfrac{1}{2K}\sum_j\big[(z_{s,j}-\bar z_s)-(z_{t,j}-\bar z_t)\big]^2\)。记 \(a_j=z_{s,j}-\bar z_s,\ b_j=z_{t,j}-\bar z_t\)，注意 \(\partial a_j/\partial z_{s,i}=\delta_{ij}-\tfrac1K\) 且 \(\sum_j a_j=\sum_j b_j=0\)：

[ \frac{\partial J}{\partial z_{s,i}}=\frac1K\sum_j(a_j-b_j)\Big(\delta_{ij}-\frac1K\Big) =\frac{a_i-b_i}{K}-\frac{1}{K^{2}}\underbrace{\textstyle\sum_j(a_j-b_j)}_{=0}=\frac{a_i-b_i}{K}. ]与第 (5) 步乘上 (T^{2}) 后逐项相同。所以 (T\to\infty) 的 KD 等价于对中心化 logits 做 L2 回归。这解释了为什么高温蒸馏对 teacher 的相对 logit 结构（而非绝对置信度）敏感——所谓 dark knowledge 正是这套相对结构。

    **「dark knowledge」的严格版本：方差缩减恒等式。**one-hot 标签每 token 至多携带 \(\log_2 K\) bit（词表 262k 时约 18 bit），而 teacher 的软标签是一个 \(K\) 维实向量。更精确的论证是：硬标签梯度 \(g_{\text{hard}}=\sigma(z_s)-y\)（\(y\sim p_T\) 是一次抽样），软标签梯度 \(g_{\text{soft}}=\sigma(z_s)-p_T\)。两者**期望相同**（\(\mathbb E[y\mid x]=p_T\)），但

[ \mathbb E\big[|g_{\text{hard}}|^{2}\big]-\mathbb E\big[|g_{\text{soft}}|^{2}\big]=\operatorname{tr}\operatorname{Cov}(y\mid x)=1-\sum_i p_T(i)^{2}. ]**省下来的正是标签抽样的全部方差。**teacher 分布越接近均匀（高熵位置，例如「the ___ of」之后），(1-\sum p^2\to1-1/K\approx1)，缩减最大；teacher 极度自信时软硬标签几乎等价、缩减为零。推论：蒸馏在高熵位置贡献最大、在确定性位置为零——这预测了它对语言建模（处处高熵）的收益远大于对分类任务。

    **序列级 KD 与它的病。**Kim & Rush (2016) 的 SeqKD 不做 token 级分布匹配，而是让 teacher 生成完整序列、student 做普通最大似然：

[ L_{\text{SeqKD}}(\theta)=-\mathbb E_{x},\mathbb E_{y\sim p_T(\cdot\mid x)}\big[\log p_S^{\theta}(y\mid x)\big], ]它就是「拿 teacher 的输出当 SFT 数据」。实现简单，但每条序列只提供 one-hot 级别的信息——第 (7) 步的方差红利被浪费了大半。

今天所有「用大模型造数据训小模型」的做法都是它的后代。它的流行程度与它在信息效率上的浪费程度成正比。

    **真正的病灶：训练与推理的前缀分布不一致（exposure bias）。**定义 student 在**自己的滚动分布**下的期望误差

[ J(\theta)=\mathbb E_{x},\mathbb E_{y\sim p_S^{\theta}(\cdot\mid x)}\left[\frac{1}{L_y}\sum_{n=1}^{L_y}\mathcal D\Big(p_T(\cdot\mid y_{0) 而 (Q(x)\to0)，该项 (\to+\infty)。优化器绝不敢把 teacher 支撑集上任何一点压到 0 ⟹ mass-covering。容量不足时只能在多个模态之间摊平，生成上表现为泛泛而谈、模棱两可。

• 反向 (\mathrm{KL}(Q|P)=\sum Q\log\frac QP)：只惩罚 (Q>0) 而 (P\approx0) 的地方；(Q(x)=0) 处 (0\log0=0) 不受任何惩罚 ⟹ mode-seeking，输出更锐利但多样性下降、长尾能力可能丢失。 一个极易混淆的点必须澄清：**「on-policy」与「正/反向 KL」是两个独立的旋钮。**前者说外层期望对谁取，后者说内层散度怎么算。GKD 的贡献恰恰是把它们解耦，然后实测发现：数据分布这个旋钮比散度方向更重要——纯 on-policy + 正向 KL 通常已经打败离线 + 反向 KL。直觉上是对的：反向 KL 只是在「让 student 别去 teacher 没有的地方」，而 on-policy 是在「让 student 恰好在自己会去的地方接受纠正」，后者直接命中第 (9) 步那个 (L^{2}\to L) 的机制。

    **能力上界：把最优交叉熵拆成两项。**

[ \min_\theta\ \mathbb E_x\big[H\big(p_T(\cdot\mid x),,p_S^{\theta}(\cdot\mid x)\big)\big] =\underbrace{\mathbb E_x\big[H(p_T(\cdot\mid x))\big]}{\text{(a) teacher 自身条件熵，不可压缩}} +\underbrace{\min\theta\mathbb E_x\big[\mathrm{KL}(p_T|p_S^{\theta})\big]}_{\text{(b) student 逼近误差}\ \ge0}. ](a) 是 teacher 自己的不确定性，蒸馏永远无法低于它；(b) 由 student 容量决定。这给出「Flash 能逼近 Pro」的理论边界：只要 student 容量足以表达 teacher 的条件分布族，(b) 可趋零、分布指标可任意接近。反过来也说明 student 在分布意义上不可能超过 teacher——除非引入 teacher 之外的信息源（RL 的环境奖励、verifier、检索）。这条不等式就是下方失效边界 ④ 的形式化。

• A1 · 高温展开的适用范围。第 (4)–(6) 步要求 (T\gg\max_i|z_i-\bar z|)。实际 LLM logits 幅度可达 ±20，所以 (T=2) 时展开根本不成立，此时 KD 并不退化为 logit 匹配、仍在做真正的分布匹配。「乘 (T^{2}) 补偿」是高温渐近的产物，中温下只是一个经验上够用的近似。

• **A2 · teacher 校准良好。**第 (7) 步要求 (p_T\approx\mathbb E[y\mid x])。现代 LLM 普遍过度自信，此时方差缩减的估计是高估的。

• **A3 · student 家族可实现。**第 (12) 步的 (b)(\to0) 假设 realizable；实际是 misspecified 的，逼近误差有正下界。

• A4 · GKD 不对采样反传（第 (10) 步），因此它不是 (L_{\mathrm{GKD}}) 的严格梯度。

• L1 · 纯蒸馏不会主动偏离 teacher 分布，但这不是一条能力上界定理。如果目标严格是最小化对 teacher 的 KL，那么这个目标本身不提供任何「超过 teacher」的动机——它的最优点就是 teacher 自己。 不能据此推出「student 的能力上界是 teacher 分布的支撑集」：普通 softmax teacher 的序列支撑几乎是全支撑，support 论证是空的； 而经验上 student 在特定任务上超过 teacher 确有发生（更强的归纳偏置、更干净的训练分布、正则化效应都可能带来）。 稳妥的表述是：要系统性地超过 teacher，需要引入 KL 之外的信号（RL、verifier、新数据），而不是「蒸馏在数学上封死了上限」。

• **L2 · 偏差与幻觉被继承甚至放大。**teacher 的系统性错误在软标签里是「高置信度的错」，student 学它比学 one-hot 还快。

• L3 · 能力向高频模式塌缩。mode-seeking 会主动丢弃低概率模态；配合 Gemma 3 公开的实现——每 token 按 teacher 概率只采样 256 个 logit、其余置零后重归一化——长尾 token 的信息在训练信号里被直接截断。这是工程与理论合流的多样性损失来源。

• L4 · on-policy 蒸馏昂贵：每步都要 student 生成、teacher 打分，吞吐显著低于离线 KD。

• L5 · 「teacher 越大越好」是错的。Gemma 3 的消融显示：小 teacher 在短训练窗口内是更好的正则化器，大 teacher 只在长训练下才占优。机制上这是两个竞争成分：第 (7) 步的方差缩减（与 teacher 强弱无关，弱 teacher 的软标签甚至更平滑、正则更强）对上第 (12) 步的信息上界（由 teacher 能力决定）。短训练下前者主导、长训练下后者主导——「用多大的 teacher」实际上是「你打算训多久」的函数。

• L6 · 蒸馏传不了「过程」，只能传「结果分布」。teacher 若靠长链推理得到某个 token 分布，student 学到的只是那个分布本身，而不是产生它的计算路径。这是小模型在多步组合推理上系统性落后的机制性解释——它可以模仿 teacher 在每一步的输出，却没有 teacher 那么多层来实际执行这些步骤。这也预测了：蒸馏 + CoT 数据比纯蒸馏有效得多，因为它把「深度」换成了「长度」，而长度是小模型也负担得起的。

    软标签的收益 = 消除标签抽样方差 \(1-\sum_i p_T(i)^2\)（第 (7) 步），在高熵位置最大。温度使梯度按 \(1/T^{2}\) 缩水（第 (5) 步），故损失须乘 \(T^{2}\) 回补；\(T\to\infty\) 时 KD 等价于中心化 logit 的 L2 匹配。GKD 把「数据分布」与「散度方向」解耦，实测**前者更重要**。能力上界为 teacher 条件熵 + student 逼近误差——**分布意义上不可能超过 teacher**。

  图 6.36　⚠️ 这张图不是「设计空间」示意图，它是一张单面板折线性能图（本章上一版把图 6.36 与图 6.37 的图注恰好写反了，已按图对调）。横轴是 student 规模（T5-small 77M / T5-Base 250M / T5-Large 800M），纵轴是 XSum 摘要的 ROUGE-2。两条 GKD 实线（Mixed JSD(0.9) 与 On-policy Reverse KL）在三个规模上都明显高于 Supervised KD、ImitKD、On-policy KD 三条虚线基线与 Supervised Fine-Tuning：T5-small 上约 14.0–14.4 对基线的 10.1–11.3，T5-Large 上约 20.0–20.2 对基线的 18.1–18.4。图中另画了两条灰色参考线——上方 Teacher: Fine-tuned T5-XL (~3B params) 约 22，中部 PaLM (540B params) 约 14.5：GKD 在最小的 T5-small（77M）上就已经追平 PaLM 540B 那条线（Mixed 版几乎压在线上、On-policy 版略低），从 T5-Base 起才明确越过它。第 (10)–(11) 步把「数据从谁的分布来」与「用什么散度」拆成两个正交旋钮，本图是这两个旋钮同时拧对之后的端到端收益，而不是旋钮本身的示意。来源：Agarwal, Vieillard, Zhou, Stanczyk, Ramos, Geist, Bachem（Google DeepMind，ICLR 2024），2023，^[17][arXiv:2306.13649] 图 1

  图 6.37　⚠️ 这张图不是基线对比图，它是散度的概念示意图（与图 6.36 的图注恰好互换，已按图对调）。三个面板画的都是概率密度曲线，横纵轴均无刻度、无数值、无轴标签；底部共用图例：黑实线 = 目标分布 (P)，红虚线 = (\arg\min_Q \mathrm{KL}(P\Vert Q))（正向 KL），蓝点线 = (\arg\min_Q \mathrm{KL}(Q\Vert P))（反向 KL）。左面板 (P) 单峰，两种近似完全重合；中面板 (P) 是两个紧邻的峰，两种近似仍然都贴得住；右面板才是要看的那一格——(P) 变成两个明显分离的峰时，正向 KL 摊平成一条覆盖两峰及其间空隙的宽曲线（mode-covering，宁可把概率放到 (P) 几乎没有质量的地方），反向 KL 则整个收缩到其中一个峰上（mode-seeking，宁可漏掉另一个峰）。这正是第 (10)–(11) 步「用什么散度」那个旋钮的图形化。（论文另外证明 GKD 可以与 RLHF 叠加、二者共用同一套 on-policy 采样基础设施，这一点在正文而不在本图上。）来源：Agarwal et al.（Google DeepMind），2023，^[17][arXiv:2306.13649] 图 2

  它到底在说什么。蒸馏的本质是把监督信号从「一个样本」升级为「一个分布」。one-hot 是对条件分布的一次蒙特卡洛抽样，软标签就是这个分布本身；第 (7) 步的方差恒等式把这件事量化得毫无歧义——省下来的正是标签抽样的全部方差。

而 (T^{2}) 这个因子，是我认为深度学习里最典型的一类「看起来像 hack、其实是量纲守恒」的设计。它不是经验调出来的魔法数，而是第 (5) 步那个 (1/T^{2}) 的精确补偿。不写它，你调 (T) 的时候实际上在同时调学习率——两个本应正交的超参被耦合在一起，调参就变成了玄学。凡是这种「补一个因子让梯度尺度与超参解耦」的设计，都值得单独推一遍，因为它往往标志着作者真的理解了自己在优化什么。

**这是整条 Google 技术线上证据最硬的一节**——因为有白纸黑字的官方原文。

• 确证 · Gemini 1.5 Flash 是从 1.5 Pro 在线蒸馏的。Gemini 1.5 技术报告原文：Flash「is also online distilled from the much larger Gemini 1.5 Pro model」。^[5][arXiv:2403.05530] 但请注意「online」的准确含义要小于「on-policy GKD」：online 只说明 teacher 在训练时动态给出目标（而不是预先离线缓存软标签）， 它并不说明 student 生成的 prefix 被用作训练分布——而后者才是 GKD 的定义性特征。 1.5 报告确实引用了 GKD 那篇（同为 Google DeepMind），但没有说明采用了它的哪一档 (\lambda_{\rm on})， 所以「Gemini 1.5 Flash 用的是 on-policy 蒸馏」这一步属未披露，本节不作此断言。 同理，Gemma 与 Gemini 在质量上接近，也不足以识别 Gemma 的具体 teacher 是哪个模型。

• 确证 · Gemma 2 用蒸馏替代**了 next-token prediction。**2B 与 9B 完全用蒸馏训练，token 量做到 Chinchilla 最优的 50 倍以上。消融里 2B 模型在 500B token 上，from-scratch 三项均分 60.3 → 蒸馏 67.7；困惑度在 200M/400M/1B 三档分别 23→21、19→17、17→15，收益不随规模衰减。^[18][Gemma 2]

• 确证 · Gemma 3 公开了实现细节：每 token 按 teacher 概率采样 256 个 logit，其余置零后重归一化再算交叉熵。^[19][Gemma 3] 报告还给出 Google 唯一一次把开源小模型与 Gemini 生产模型直接对标的表述：Gemma3-27B-IT 与 Gemini-1.5-Pro 相当——这等于隐含承认了 Gemma 的 teacher 就在 Gemini 家族里。

• 未确证 **Gemini 2.x / 3.x 的 Flash 是否仍从对应的 Pro 蒸馏，官方没有重复过这个说法。**2.5 与 3.x 的报告 / 模型卡都没写。Gemini 3 Pro 模型卡强调它是「trained from scratch rather than fine-tuned from Gemini 2.5」，但那说的是 Pro 与上代 Pro 的关系，不是 Flash 与 Pro 的关系。蒸馏配方（(\lambda_{\text{on}})、散度选择、参数比）完全未公开。 **为什么 Google 越来越不愿意谈「从 Pro 蒸 Flash」？**我的判断有两层。商业层：如果 Flash 只是 Pro 的蒸馏版，客户会问「那我为什么要买贵的 Pro」；而事实上后一代 Flash 在部分 agentic / coding 基准上已经超过上一代 Pro，一个「蒸馏版」打败上代旗舰会让整个产品分层叙事变得混乱。技术层：随着 thinking 成为主要能力来源，「蒸馏」这个词已不足以描述实际发生的事——现代小模型训练是「预训练 + 教师分布蒸馏 + on-policy RL + 推理轨迹蒸馏」的混合体。一个可验证的推论：如果 Flash 纯粹是 Pro 的蒸馏，它在任何基准上都不应该超过同代 Pro；一旦出现跨代反超，就说明「蒸馏」更可能是初始化与数据来源，而不是全部训练过程。

  这是作者判断，不是官方结论

蒸馏的收益来自两个可以分开量化的机制：(a) 软标签的方差缩减（第 (7) 步）——teacher 分布是 (\mathbb E[y\mid x]) 的低方差估计，每个样本携带的信息远多于 one-hot，这解释了样本效率的提升；(b) 函数类匹配——student 只需拟合 teacher 已经找到的那个函数，不必在整个假设空间里搜索，这解释了优化难度的降低。

边界就是第 (12) 步那条不等式。Flash 能逼近 Pro，是因为 Pro 的多数输出其实落在一个低复杂度的子流形上；但在连 Pro 也要靠长 thinking 才做得对的题上，Flash 无论怎么蒸都追不上——除非引入 RL / verifier，这正是为什么 Flash 系列也要有自己的 thinking 模式。

2026 年的新证据换了一个角度：Gemini 3.6 Flash 相对 3.5 Flash 的进步，被官方描述为「更好的能力 + 少 17% 的输出 token」。这不是蒸馏出了更强的能力，而是蒸馏出了更短的推理路径。结合 E8 的经济学：「蒸馏简洁性」可能比「蒸馏能力」更有商业价值——因为 thinking token 是按输出 token 计费的真金白银。

第 (12) 步的分解 \(\min_\theta \mathbb E_x[H(p_T,p_S^\theta)]=\mathbb E_x[H(p_T)]+\min_\theta\mathbb E_x[\mathrm{KL}(p_T\|p_S^\theta)]\) 是一条**硬约束**：第一项是 teacher 自身的条件熵，蒸馏永远无法低于它；第二项非负。合起来意味着——**在分布意义上，student 不可能超过 teacher。**

三条常被忽略的推论：

• **能力上界与失败模式一起被继承。**整个 Flash / Flash-Lite / Nano / Gemma 矩阵的上界都被 teacher 锁定，而且 L2 说明 teacher 的系统性错误会以「高置信度的错」形式传下去——Flash 的幻觉模式与 Pro 高度同构，不是巧合，是数学后果。

• **「student 超过 teacher」的报告，一定是因为引入了 teacher 之外的信息源。**常见的三种：RL 的环境奖励、verifier 的外部判据、检索的外部知识。看到这类结论时，第一个要问的问题是「多出来的信息从哪来」，而不是「蒸馏为什么这么神」。

• **这条边界正是 RLVR 存在的理由。**Gemma 3 的后训练在蒸馏之外还挂了 BOND / WARM / WARP 三套 RL 方法，不是锦上添花——它是在给蒸馏的天花板开一个口子。B11 讲的就是这个口子怎么开、以及它自己的天花板在哪。

  组 5 · RL 与搜索

  这一组回答 DeepMind 那三十年积累在 LLM 时代兑现成了什么。B10 从 Hoeffding 不等式一路推到 PUCT，落点是 AlphaZero 的真正内核——搜索是一个 policy improvement operator；然后必须诚实地说清，这个内核在 LLM 上为什么做不了原样移植。B11 走完 RLHF 的整条链：Bradley-Terry → KL 正则的闭式最优解 → DPO 的 (\log Z) 抵消 → PPO / GRPO / RLVR，其中 (\log Z) 抵消那一步是全章最漂亮的一步。

  两节共享同一个枢纽：奖励从哪来。B10 说搜索的强度受制于 value 的可靠性，B11 说策略优化的强度受制于奖励的可靠性——它们是同一个问题在两个方向上的投影。

  B10 · 从 UCB1 到 PUCT，以及 MuZero 的三网络联合损失

  一句话。把「置信上界」从老虎机搬到树上得到 UCT，再用神经网络先验替换掉均匀探索得到 PUCT；于是搜索的访问数分布恰好是KL 正则策略优化的解——搜索本身就成了一个 policy improvement operator，而网络的任务是把它摊销下来。

    B10
    Hoeffding → UCB1 → UCT → PUCT → 搜索即策略提升 → MuZero 的价值等价
    Auer et al., 2002 ／ Kocsis & Szepesvári, 2006 ／ Rosin, 2011 ／ Silver et al., Nature 2017 & Science 2018 ／ Schrittwieser et al., Nature 2020 · arXiv:1911.08265 ／ Grill et al., ICML 2020 · arXiv:2007.12509 ／ Beirami et al., 2024 · arXiv:2401.01879
  
  
  
  
      符号表

| | (\bar X_j) | 臂 (j) 的样本均值回报 | ([0,1])

| | (n,\ n_j) | 总拉动次数 / 臂 (j) 被拉的次数 | 正整数

| | (\Delta_j) | 次优臂间隙 (\Delta_j=\mu^{*}-\mu_j) | ((0,1])

| | (N(s,a)) | 状态 (s) 下动作 (a) 的访问数 | 非负整数

| | (Q(s,a)) | 该边的平均回报（MuZero 中归一化到 ([0,1])） | ([0,1])

| | (P(s,a)) | 策略网络给出的先验 | 动作空间上的概率分布

| | (c_{\text{puct}}) | 探索系数；MuZero 用 (c_1=1.25,\ c_2=19652) 组合出它 | 正实数

| | (\tau) | 访问数 → 策略的温度 | (\gt0)；AlphaZero 前 30 手取 1，之后 (\to0)

| | (h_\theta,g_\theta,f_\theta) | MuZero 的 representation / dynamics / prediction 网络 | —

| | (s^{k},r^{k},v^{k},\mathbf p^{k}) | 隐空间展开第 (k) 步的状态 / 奖励 / 价值 / 策略 | —

| | (K) | 隐空间展开步数（MuZero 取 5） | 正整数

| | (\pi_{\mathrm{bo}n}) | best-of-(n) 采样诱导出的输出分布 | 输出空间上的分布

| | (\varepsilon_n) | 被选中输出在基础策略下的概率质量 | ([0,1])

逐步推导 · 共 13 步（点击展开）
**起点：Hoeffding 不等式。**设 \(X_1,\dots,X_{n_j}\) iid 取值于 \([0,1]\)、均值 \(\mu_j\)、样本均值 \(\bar X_j\)，则

[ \Pr\big[|\bar X_j-\mu_j|\ge t\big];\le;2\exp\big(-2n_j t^{2}\big). ]这是全部内容的地基：有界随机变量的样本均值以指数速度集中在真值附近，速度由样本数 (n_j) 和偏离量 (t) 的平方共同决定。注意 (t^2) 与 (n_j) 在指数里是乘积关系——这个乘积结构直接决定了下一步 (t) 的形状。

    **为什么置信半径恰好是 \(\sqrt{2\ln n/n_j}\)。**我们希望「在整个 \(n\) 轮内、对所有臂、所有可能的 \(n_j\)，置信区间都成立」。把右端设为 \(2n^{-4}\)：

[ 2\exp(-2n_jt^{2})=2n^{-4}\ \Longrightarrow\ 2n_jt^{2}=4\ln n\ \Longrightarrow\ \boxed{,t=\sqrt{\frac{2\ln n}{n_j}},}. ]于是 UCB1：

[ a_t=\operatorname*{arg,max}_{j}\left[\bar X_j+\sqrt{\frac{2\ln n}{n_j}}\right]. ](n^{-4}) 不是随便挑的——指数 4 是为了让下一步的三重 union bound（对轮数、臂、已拉次数各求和）收敛而选的最小方便值。这是「先想清楚要 union 多少项，再反推每项要多小」的典型套路：UCB1 的 (\sqrt{2\ln n}) 里那个 (\ln n)，本质上是 union bound 的代价。

    **Union bound 给出 \(O(\log n)\) regret。**坏事件「某臂在某时刻置信区间失效」的总概率：对每轮 \(t\le n\)、每臂 \(j\le K\)、每个已拉次数 \(s\le t\) 各贡献 \(2t^{-4}\)：

[ \sum_{t=1}^{n}\sum_{j=1}^{K}\sum_{s=1}^{t}2t^{-4};\le;2K\sum_{t\ge1}t\cdot t^{-4}=2K\sum_{t\ge1}t^{-3};\lt;2K\cdot1.21=O(K). ]即期望中只有常数次「置信失效」的拉动。在好事件下，次优臂 (j) 还能被选中要求

[ \mu_j+2\sqrt{\frac{2\ln n}{n_j}}\ \ge\ \mu^{*} \ \Longrightarrow\ 2\sqrt{\frac{2\ln n}{n_j}}\ge\Delta_j \ \Longrightarrow\ n_j\le\frac{8\ln n}{\Delta_j^{2}}, ]于是 (R_n=\sum_j\Delta_j,\mathbb E[n_j]\le\sum_{j:\Delta_j\gt0}\frac{8\ln n}{\Delta_j}+O(K)=O(K\log n))。

这就是 UCB1 的全部内容：Hoeffding 给半径，union bound 保证半径几乎总是对的，间隙 (\Delta_j) 把「被拉了多少次」翻译成 regret。注意 (K)（臂数）以线性方式进入 regret——这一点在下一步会致命。

    **UCT：把树的每个内部节点当成一个独立老虎机。**Kocsis & Szepesvári (2006) 用 UCB1 选子节点、叶子处 rollout、回传更新 \(\bar X\)。**代价是第 (1) 步的 iid 假设被破坏**——子树的回报分布随着子树内部策略的改进而**漂移**，不是独立同分布。

原作者为此证明了漂移老虎机（drifting bandit）版本的收敛界，但收敛常数远差于静态情形。UCT 在实践中好用，与它在理论上有保证，是两件相关但不等价的事。

    **PUCT：用神经网络先验替换掉均匀探索。**Rosin (2011) 的 PUCB 引入 "predictor"，AlphaGo / AlphaZero 采用的形式是

[ \boxed{;a_t=\operatorname*{arg,max}{a}\left[,Q(s,a)+c{\text{puct}},P(s,a),\frac{\sqrt{\sum_b N(s,b)}}{1+N(s,a)}\right];} ]三个部件为什么长成这样，逐个拆：

• 为什么乘 (P(s,a))：第 (3) 步的 regret 里那个 (K) 在围棋（(b\approx250)）和国际象棋（(b\approx35)）里是致命的。先验把「哪些臂值得试」的信息注入，使低先验动作的探索预算按 (P) 比例缩小；(K) 因子被换成了对先验质量的依赖。这就是神经网络与搜索的接口。

• 为什么分母是 (1+N(s,a)) 而不是 (\sqrt{N})：UCB1 对未访问的臂给出 (+\infty) 的界，这强制「每臂先拉一次」。围棋 250 个合法点、每步只有 800–1600 次模拟，光初始化就吃掉 15%–31% 的预算，剩下的深度根本不够。改成 (1+N) 后未访问动作的探索项是有限的 (c_{\text{puct}}P(s,a)\sqrt{\sum_b N})——低先验动作可以一次都不被访问。这是让 MCTS 在高 branching factor 下可用的关键工程决策。

• 为什么是 (\sqrt{\sum_b N}) 而不是 (\sqrt{\ln\sum_b N})：(n=800) 时 (\sqrt n=28.3) 而 (\sqrt{2\ln n}=3.66)，比值 7.7×；(n=1600) 时 10.4×。在极小模拟预算下对数项几乎不增长，探索会过早坍缩到一两个子节点；(\sqrt n) 让探索项随预算持续增长，保证加算力真能换来更宽的搜索。 代价是理论 regret 界不再是 (O(\log n))——AlphaGo 团队用渐近最优性换掉了小预算下的可用性，这是纯粹的工程选择，而不是理论改进。诚实地说清这一点很重要。

    **PUCT 的不动点：访问数分布有闭式。**在同一节点上，若所有被访问动作的「\(Q\) + 探索项」相等（记为 \(\lambda\)），且 \(N(s,a)\gg1\)：

[ Q(s,a)+c,P(s,a)\frac{\sqrt n}{N(s,a)}=\lambda \ \Longrightarrow\ N(s,a)=\frac{c\sqrt n,P(s,a)}{\lambda-Q(s,a)}. ]对 (a) 求和得 (n=c\sqrt n\sum_a\frac{P(a)}{\lambda-Q(a)})，即 (\sqrt n=c\sum_a\frac{P(a)}{\lambda-Q(a)})，(\lambda) 由此隐式确定。于是归一化访问分布

[ \boxed{;\pi_{\text{MCTS}}(a)=\frac{N(s,a)}{n}\ \propto\ \frac{P(a)}{\lambda-Q(a)}.;} ]**这个形式极其重要：它正是 KL 正则化策略优化的解形式。**Grill et al. (2020) 证明 AlphaZero 的搜索近似求解 (\bar\pi=\arg\max_{y}\big[y^{\top}Q-\lambda_N,\mathrm{KL}(P|y)\big])，其中 (\lambda_N=\frac{c\sqrt n}{n+|A|})。^[20][Grill et al.] 也就是说：MCTS 不是一个启发式，它在解一个明确写得出来的优化问题。

    **「搜索是 policy improvement operator」——AlphaZero 的真正内核。**训练目标

[ l=(z-v)^{2}-\pi^{\top}\log p+c|\theta|^{2}, \qquad \pi(a)\propto N(s,a)^{1/\tau}. ]把前三步串起来读，每个分量的身份就清楚了：

• 由第 (6) 步，(\pi_{\text{MCTS}}) 是对先验 (P=p_\theta) 做了一次 KL 正则的策略提升——它在 (Q) 上比 (P) 更好，但被 (\lambda_N\mathrm{KL}) 拴在 (P) 附近，而 (\lambda_N\propto1/\sqrt n) 随模拟数增加而减弱（算力越多、越敢偏离先验）。

• (-\pi^{\top}\log p) 把网络策略拉向这个提升后的策略——Policy Improvement 的投影步。

• ((z-v)^{2}) 用自对弈实际结局回归价值——Policy Evaluation。

• (\tau) 控制锐化：(\tau=1) 是访问数正比（保留探索、供训练多样性），(\tau\to0) 是 argmax（对弈时最强）。 [ \boxed{;\text{AlphaZero}=\text{广义策略迭代（GPI）},\ \text{只不过改进算子不是梯度步，而是一次前向搜索。};} ]这是全节最深的一点：**搜索被当作一个可微目标的生成器，而不是推理时的额外装饰。**网络负责摊销（amortize）搜索的结果，搜索负责持续产出比网络更好的目标——两者互为脚手架，构成一个自举飞轮。这条思路可以脱离棋盘：只要你能构造一个「比当前策略更好但更贵」的过程，你就能用它生成训练目标，让便宜的网络去追。

    **飞轮为什么不会自锁：根节点的 Dirichlet 噪声。**GPI 有一个致命风险——若先验 \(P\) 从一开始就把某动作压到接近 0，探索项 \(cP\sqrt n/(1+N)\) 也随之接近 0，该动作**永远不会被访问**、\(Q\) 永远不会被修正、网络永远不知道自己错了。AlphaGo Zero / AlphaZero 的解法是只在**根节点**给先验掺噪声：

[ P(s_{\text{root}},a)=(1-\varepsilon),p_\theta(a\mid s_{\text{root}})+\varepsilon,\eta_a,\qquad (\eta_a)_{a}\sim\mathrm{Dir}(\zeta),\ \varepsilon=0.25, ]其中 (\zeta) 与该游戏的典型合法动作数成反比（围棋 0.03、国际象棋 0.3、将棋 0.15）。

噪声只加在根节点、不加在内部节点——内部节点的目标是尽可能准确地评估，探索的责任由自对弈的大量根节点分摊。这是一个小细节，却是整个自举循环不塌缩的必要条件，也是「搜索能纠正网络」而非「网络能锁死搜索」的关键。

    **best-of-\(n\) + verifier 就是深度为 1 的搜索——但那个流传很广的 KL 等式其实只是上界。**把第 (6) 步的框架退化到只有根节点、每个「动作」是一整条完整回答，就得到 LLM 上最常见的 test-time compute 形式。它与 KL 正则策略优化的联系可以定量写出来，不过必须分两半讲。

**先看等号在什么条件下成立。**假设奖励 \(r\) 在参考策略 \(\pi_\theta\) 下的分布**连续无原子**（因而 \(n\) 次采样几乎必然互不平局，排序唯一）。用概率积分变换令 \(u=F(r(y))\sim\mathrm{Unif}(0,1)\)，\(n\) 个 iid 样本的最大值密度为 \(nu^{n-1}\)，即似然比 \(\mathrm d\pi_{\mathrm{bo}n}/\mathrm d\pi_\theta=nu^{n-1}\)。于是

\[ \begin{aligned}
\mathrm{KL}\big(\pi_{\mathrm{bo}n}\,\|\,\pi_\theta\big)
&=\int_0^1 nu^{n-1}\log\big(nu^{n-1}\big)\,\mathrm du\\
&=\log n+(n-1)\,n\int_0^1 u^{n-1}\log u\,\mathrm du\\
&=\log n+(n-1)\,n\cdot\Big(-\tfrac{1}{n^{2}}\Big)\ =\ \log n-\frac{n-1}{n},
\end{aligned} \]
其中 \(\int_0^1u^{n-1}\log u\,\mathrm du=-1/n^{2}\)（分部积分即得）。

**再看它为什么一般只能写成不等号。**LLM 的输出空间是**离散**的：同一条回答会被重复采到，奖励也会打平，此时 best-of-\(n\) 的质量函数是 \(\pi_{\mathrm{bo}n}(y)=F(y)^{n}-F(y^{-})^{n}\)（\(F\) 按奖励序累积），而不是上面那个连续密度。Beirami 等（2024）证明流传的等式**不成立**，正确的陈述是

\[ \boxed{\;\mathrm{KL}\big(\pi_{\mathrm{bo}n}\,\|\,\pi_\theta\big)\ \le\ \log n-\frac{n-1}{n}\;} \]
\[ (n=4\to\le0.64,\ \ 16\to\le1.83,\ \ 64\to\le3.17,\ \ 1024\to\le5.93\ \text{nats}) \]
他们还给出松紧判据：记被选中输出在基础策略下的概率质量为 \(\varepsilon_n\)，则 \(n\varepsilon_n\ll1\) 时上界很紧，\(n\varepsilon_n\gg1\) 时差距可以很大甚至无界。[@src-977b3ee88c][Beirami et al., 2024] **一个可以直接执行的自检**：若 \(n\) 次采样里经常出现**重复回答**，说明 \(\varepsilon_n\) 不小、这个公式正在高估你花掉的 KL 预算。

**采样数以指数代价换取至多线性的 KL 位移。**对照第 (6) 步的 \(\lambda_N=c\sqrt n/(n+|A|)\)：树搜索的正则强度随模拟数**衰减**，best-of-\(n\) 的有效正则上限随 \(\log n\) **放松**——两者是同一条曲线上的不同参数化。**把等号改成不等号不是文字游戏。**reward-model 过优化的经验曲线常以 \(\sqrt{\mathrm{KL}}\) 为横轴，若直接代入这个公式，best-of-\(n\) 的点会被系统性**右移**，看起来比实际更不划算；反过来，若拿它当「我只允许偏离 \(\lambda\) 个 nat」的预算约束，实际偏离会小于预算、约束偏保守。两个方向都不是无害的近似。至于树搜索与 best-of-\(n\) 的真正差别，仍然在于：**前者能把预算花在序列内部的分支点上（中途可以纠错），后者只能整条丢弃重来。**这就是「搜索深度」在 LLM 上的真实含义。

    **MuZero 的三网络。**

[ \begin{aligned} s^{0}&=h_\theta(o_1,\dots,o_t) &&\text{representation：把观测历史压成隐状态}\ r^{k},,s^{k}&=g_\theta(s^{k-1},a^{k}) &&\text{dynamics：隐状态 + 动作} \to \text{即时奖励 + 新隐状态}\ \mathbf p^{k},,v^{k}&=f_\theta(s^{k}) &&\text{prediction：从隐状态读出策略先验与价值} \end{aligned} ]搜索完全在 (g,f) 构成的隐空间里进行，从头到尾不碰真实环境。

这是 AlphaZero 到 MuZero 的关键一跃：AlphaZero 需要一份给定的、精确的环境规则来做树展开（棋类天然有），MuZero 把规则本身也学出来——于是它可以打 Atari 这种没有显式规则的环境。

    **\(K\) 步联合损失：每一步都对齐真实轨迹上 \(k\) 步之后的量。**

[ \boxed{;L_t(\theta)=\sum_{k=0}^{K}\Big[,l^{r}\big(u_{t+k},,r_t^{k}\big)+l^{v}\big(z_{t+k},,v_t^{k}\big)+l^{p}\big(\pi_{t+k},,\mathbf p_t^{k}\big)\Big]+c|\theta|^{2};} ]其中价值目标 (z_t=u_{t+1}+\gamma u_{t+2}+\dots+\gamma^{n-1}u_{t+n}+\gamma^{n}\nu_{t+n})（(n) 步自举到搜索价值 (\nu)）；棋类中 (l^{r}\equiv0)、(l^{v}=(z-v)^{2})，一般 MDP 中三项都用类别化交叉熵。MuZero 取 (K=5)。（(k=0) 对应尚未施加任何动力学步，该处没有奖励可预测，实现中这一项不生效。）

三项分别对应「模型预测的即时奖励要对」「价值要对」「策略先验要对」。梯度通过展开的 (K) 步 BPTT 一路传回 (h) 和 (g)——所以 dynamics 网络是被「它的下游预测准不准」训练出来的，而不是被「它像不像真实状态转移」训练出来的。这直接引出下一步。

    **没有重建损失——value equivalence。**传统 model-based RL 要求 \(g\) 能预测下一**观测**（重建 / 像素级损失）。MuZero **完全没有这一项**：\(s^{k}\) 不需要还原任何东西，只需要让 \(f\) 从它读出正确的 policy / value / reward。也就是说隐状态只需在「**对规划有用**」这个意义上与真实状态等价（Grimm et al. 的 value equivalence principle）。

后果是深刻的：模型可以自由丢弃与决策无关的一切（画面背景、噪声纹理、无关物体），把全部容量押在决策相关的维度上。这是 MuZero 与 Dreamer / World Models 这类重建式世界模型最本质的分野。代价见 L3：隐状态没有语义，你无法审计模型「以为」世界是什么样。^[21][Value Equivalence]

    **MuZero 的 \(c_{\text{puct}}\) 是随访问数变化的。**

[ c_{\text{puct}}(s)=c_1+\log!\left(\frac{\sum_b N(s,b)+c_2+1}{c_2}\right),\qquad c_1=1.25,\ c_2=19652. ]代入数值看它在干什么：(\sum_bN=800\to1.290)；(1600\to1.328)；(10^{4}\to1.661)；(19652\to1.943)；(10^{5}\to3.056)；(10^{6}\to5.199)。

(c_2) 是一个阈值：在棋类常用的几百到几千次模拟下 (c_{\text{puct}}\approx c_1=1.25)，完全退化为 AlphaZero；只有模拟数远超 (c_2\approx2\times10^{4}) 时探索才被对数式加强。这是为超大搜索预算预留的、平时不激活的安全阀。此外 MuZero 因为 (Q) 无界（一般 MDP 有中间奖励），必须先做树内 min-max 归一化 (\overline Q=\frac{Q-\min_{\text{tree}}Q}{\max_{\text{tree}}Q-\min_{\text{tree}}Q}) 才能与 ([0,1]) 尺度的先验项相加——这个补丁本身就说明 PUCT 对 (Q) 的尺度有多敏感（见 L2）。

• A1 · Hoeffding 要求回报有界且 iid。树搜索中两者都不严格成立：回报随子树策略改进而漂移（第 (4) 步），一般 MDP 的 (Q) 也未必有界（第 (13) 步的归一化就是补丁）。

• A2 · 不动点推导要求 (N(s,a)\gg1) 且所有动作都被访问（第 (6) 步）。小模拟预算下这是很粗糙的近似——而小预算恰恰是 LLM 场景的常态。

• **A3 · GPI 论证依赖自对弈的对称性与确定性环境模型。**换成随机环境或非零和博弈，价值目标 (z) 的无偏性就没了。

• **A4 · MuZero 假设隐状态对 value/policy/reward 充分。**在部分可观测且长期依赖的任务中这是强假设。

• A5 · 第 (9) 步的 KL 等号需要三个条件同时成立：奖励在参考策略下的分布连续无原子（无平局）；选择规则等价于对奖励序取最大值（并列时的处理不改变分布）；输出空间上的排序可由奖励唯一诱导。LLM 的离散输出空间不满足第一条，因此只剩上界。

• L1 · 在 LLM 上做真 MCTS 的代价极高，而且四个困难是叠加的。 (a) 分支因子：状态是整个 token 前缀，树永不合并（不同路径到达语义相同的状态仍是不同节点），有效分支因子等于词表大小（现代大模型的词表普遍在 (10^{5}) 量级，例如 Gemma 是 256,128 条；Gemini 的词表大小官方未披露），比围棋的 250 大三个数量级。即便退化到「以句子或推理步为动作」，分支因子仍在数十到数百。 (b) 无终局奖励：围棋有胜负、Atari 有分数，开放域文本没有——只有数学、代码、形式化证明这类可验证领域才有。 (c) value 网络训不动：AlphaZero 的 (v) 靠自对弈胜负标签自举，LLM 既没有对手也没有胜负；用 RM 打分代替则把 B11 的过优化问题整个继承过来，搜索会精准地找到 RM 的漏洞——搜索越强，reward hacking 越狠，这是一个反直觉但被反复观测到的现象。 (d) 回退成本：树搜索要频繁跳回祖先节点，物理上意味着 KV cache 的分叉管理或重算；即便有 PagedAttention 这类机制，内存与调度复杂度也远高于线性解码。 四者之中 (c) 通常才是拦路虎——前三个更接近工程问题，(c) 是「奖励从哪来」的根本问题。

• L2 · PUCT 放弃了 (O(\log n)) regret 保证，且 (c_{\text{puct}}) 的取值高度依赖 (Q) 的尺度（MuZero 不得不加 min-max 归一化正说明这点脆弱）。

• L3 · value equivalence 的代价是不可解释：隐状态没有语义，无法审计模型「以为」世界是什么样。对安全评估而言这是一个真实的负债。

• L4 · 策略提升的强度受 (\lambda_N\propto c\sqrt n/(n+|A|)) 支配，模拟数少时提升幅度极其有限——「加一点搜索」往往不如「把网络训好」。这条对 LLM 尤其吃紧，因为 LLM 上一次「展开」的成本是一整次完整前向，而不是一次盘面评估。

• L5 · 第 (9) 步给的是上界，不要当作已花掉的 KL 来用。差距由 (n\varepsilon_n) 支配：采样重复率高时（短回答、低温度、强模式坍缩）差距可能相当大。要拿准确值需要另行估计——Beirami 等提出了一个经验上更紧的估计量。凡是拿 (\log n-\frac{n-1}{n}) 去和 RLHF / GRPO 的实测 KL 做跨方法比较的图表，都应先说明这一点。

    UCB1 的 \(\sqrt{2\ln n/n_j}\) 来自 Hoeffding + union bound；PUCT 用先验 \(P(s,a)\) 换掉 \(K\) 因子、用 \(1+N\) 换掉「每臂先拉一次」、用 \(\sqrt{n}\) 换掉 \(\sqrt{\ln n}\) 以适配小预算。其不动点 \(\pi_{\text{MCTS}}\propto P/(\lambda-Q)\) 恰是 KL 正则策略优化的解，于是**搜索 = policy improvement operator**，AlphaZero = 用搜索当改进算子的广义策略迭代。退化到深度 1 就是 best-of-\(n\)，其 KL **上界**为 \(\log n-\frac{n-1}{n}\)（连续无平局时取等）。MuZero 的三网络在**价值等价**意义下学动力学、**不重建观测**，联合损失对 \(K=5\) 步的 reward / value / policy 同时对齐。

  图 6.38　MCTS 的四步：selection（按 (Q+u(P,N)) 选边）→ expansion（策略网络给先验 (P)）→ evaluation（价值网络 + rollout）→ backup（回传更新 (N,Q)）。第 (5)–(6) 步分析的就是 selection 这一步的形状；第 (8) 步的 Dirichlet 噪声只作用在这棵树的根节点上。来源：Silver et al.，Mastering the game of Go with deep neural networks and tree search，Nature 529，2016，^[22][Nature 2016] 图 3

  图 6.39　MuZero 的三联图：A 规划（在学到的隐状态空间里做 MCTS——树的节点是抽象隐状态而非真实棋盘）／B 交互（按访问数分布采样动作、存进真实轨迹）／C 训练（把模型展开 (K) 步，对 reward / value / policy 三项同时回归，梯度经 BPTT 传回 (h) 与 (g)）。图 C 里没有任何重建观测的分支——这就是第 (12) 步 value equivalence 的视觉证据。来源：Schrittwieser et al.，Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model，Nature 588，2020，^[23][arXiv:1911.08265] 图 1

  它到底在说什么。AlphaZero 最被低估的贡献，不是「搜索让棋力变强」，而是第 (7) 步那个视角转换：把搜索当作一个策略提升算子，然后用网络去摊销它。一旦这样看，棋盘就不再是必需品——你需要的只是三样东西：一个比当前策略更好但更贵的过程、一个能把它的输出当成训练目标的投影步、以及一个防止飞轮自锁的探索注入（第 (8) 步）。

从这个角度看，「test-time compute」和「AlphaZero 的搜索」不是两件事，是同一件事的两个深度：RLHF 的 best-of-(n)、推理时的 self-consistency、verifier 重排序，本质都是深度为 1 的退化情形（第 (9) 步给出了它们与 KL 正则策略优化的定量对应）。第 (9) 步那个 (\mathrm{KL}\le\log n-\frac{n-1}{n}) 尤其值得记住：**它把「采多少样」这个工程参数，翻译成了「你最多允许策略偏离多远」这个理论量。**注意是「最多」——等号只在奖励分布连续无平局时成立，离散输出空间下真实偏离更小（L5）。而这个「更小」本身有信息量：它说明采样重复越多，你花的钱越多、买到的分布位移越少。

**图 6.40**　四种范式：IO → CoT（线性）→ CoT-SC（多条并投票，即 majority@k）→ ToT（树状，带分支与状态评估）。请注意 ToT 与真 MCTS 的差距：**它有分支和评估，但评估者是 LM 自己，没有可靠 value 网络，也没有终局奖励**——正是 L1(b)(c) 描述的处境。来源：Yao et al.（Princeton + Google DeepMind），2023，[@src-ba7b8013ee][arXiv:2305.10601] 图 1


这是作者判断，不是官方结论

我的判断是：转化成了三样东西，而且只有第三样是真正的「搜索」。

• **(1) 训练信号。**AlphaZero 的「搜索是 policy improvement operator」在 LLM 上的对应物，是「用采样 + 验证生成比策略本身更好的目标，再蒸馏回策略」。这就是 RLVR 与 self-consistency 蒸馏的本质。不是把 MCTS 搬进 LLM，而是把那个元算法搬了过来。

• **(2) 评测文化。**DeepMind 传统里「打比赛拿分」的执念，直接产生了 IMO / IPhO / IChO / Codeforces 这一整套非 benchmark 的硬评测。这类评测有一个共同点——它们自带裁判。

• (3) 真正的搜索只剩下 AlphaProof 这条线。它有 Lean 编译器提供边际成本极低、可重复、确定性的形式化证明检查，因而能反复调用出终局奖励——这同时解除了 L1 的 (b) 与 (c) 两条最硬的约束。（注意措辞：是「边际成本低、结果确定」，不是零成本、零噪声——形式化本身、公理库选择与 Lean 版本差异都会引入实际代价。）2024 年 IMO 银牌（需人工形式化、耗时数天）到 2025 年金牌（纯自然语言、限时内完成），这条线的进展是可追溯的。^[24][DeepMind, 2024] 分水岭不是算法，是有没有一个便宜可靠的 verifier。这也解释了为什么 Google 在数学与代码上的推理进展远快于开放域写作——不是模型不同，是奖励结构不同。

  这一节在 Gemini 身上的对应物，必须分成三层来写，混层就是编造。

• 事实层 · AlphaZero 循环被原样用在了可验证的数学上。AlphaProof 采用 AlphaZero 式的训练循环，把形式化数学问题交给 Lean 验证器提供 ground-truth 奖励；配合 AlphaGeometry 2，2024 年在 IMO 上达到银牌线（需人工把题目形式化、耗时数天）。^[24][DeepMind, 2024-07] 2025 年 Deep Think 以纯自然语言在限时内达到 IMO 金牌标准。请注意这两件事的机制不同：前者是真搜索 + 真验证器，后者官方只说了 parallel thinking。

• **官方描述层 · Deep Think 的措辞。**官方原话是使用「parallel thinking techniques」，让模型「同时生成多个想法并同时考量，甚至在过程中修订或合并不同想法」，并配有「novel reinforcement learning techniques」鼓励模型利用这些扩展推理路径。^[25][DeepMind Deep Think] 就这些，没有更多。

• 结构对应层（这一条是最有价值的）。第 (7) 步的 GPI 骨架在 LLM 上并没有以 MCTS 的形式移植，而是以元算法的形式移植了：「用额外算力生成比当前策略更好的目标 → 再把它蒸馏 / RL 回策略」。B11 的 RLVR、B7 的 self-consistency 蒸馏、Deep Think 的「生成多个假设 → 评估 → 合并」，在结构上都可以读成这个元算法的实例，区别在深度（第 (9) 步）与奖励来源。但「结构上相似」只是一种读法，不是实现层面的证据。

• 推测 Deep Think 内部是否有树、有无 value 网络、是否复用了 AlphaZero 的代码路径——全部是外部推断，Google 从未确认。详见下方失效边界 ⑤。

  这是本章最容易出错、也最容易被以讹传讹的一点，必须写死：

**Gemini Deep Think 的并行思考机制，官方从未披露实现细节。**公开材料里唯一的措辞是「parallel thinking techniques」——同时生成多个想法、同时考量、可修订或合并；以及「novel reinforcement learning techniques」鼓励模型利用这些扩展推理路径。^[25][DeepMind Deep Think] 官方从未说过它是 MCTS、树搜索、PUCT，也没说过使用了 value 网络 / PRM。

外界推测它更接近并行采样 + 内部裁决而非带回溯的树搜索——但这只是推测，证据不足，本材料一律标注为推测。把 B10 的 PUCT 公式直接安到 Deep Think 头上，是把「Google 有这个传统」错当成「Google 在这个产品里用了它」。

L1 也已经说明了在 LLM 上做真 MCTS 的代价为什么极高：状态不可廉价回退（KV cache 分叉代价高）、branching factor 是词表大小、value 网络缺 ground truth、每次「展开」是一次完整前向而不是一次廉价的盘面评估。一个组织有能力做某事，不等于它在某个产品里做了这件事；在这个具体案例里，这些困难至少说明「照搬 PUCT」不是一个默认选项。但也仅止于此——「代价高」推不出「一定没做」，这一步不要替 Google 走完。

可以确证的只有两件事：Deep Think 面向的是数学与竞赛编程这类可验证任务（与 E6 的判断一致）；以及 thinking 本身是 RL 训出来的推理时算力（Gemini 2.5 技术报告原话）。

### B11 · Bradley-Terry → KL 正则闭式解 → DPO 的 \(\log Z\) 抵消 → PPO / GRPO / RLVR

**一句话。**带 KL 正则的奖励最大化有**闭式解**——参考策略被奖励指数重加权后的吉布斯分布；把它反解成奖励代进 Bradley-Terry 的配对差，配分函数就消掉了，这就是 DPO。PPO / GRPO / RLVR 都是**闭式解算不出来时**的采样近似，而近似的代价正是本节两处最容易写错的地方。



    B11
    从成对偏好到可验证奖励
    Rafailov et al., 2023 · arXiv:2305.18290 ／ Schulman et al., 2017 · arXiv:1707.06347 ／ Shao et al., 2024 · arXiv:2402.03300




      符号表

| | (x,\ y) | prompt 与整条回答（回答当作一个动作） | token 序列

| | (y_w\succ y_l) | 标注者判定 (y_w) 胜过 (y_l) | 成对偏好样本

| | (r,\ r_\phi) | 潜在标量奖励／学出来的奖励模型 | (\mathbb R)

| | (\pi_{\rm ref}) | 参考策略，实践中取 SFT 模型 | 固定不动

| | (\pi_\theta,\ \pi_{\theta_{\rm old}}) | 当前策略／采样时的旧策略 | 参数化分布

| | (\beta) | KL 正则强度（DPO 中兼作隐式奖励尺度） | (>0)，典型 (0.01\sim0.5)

| | (Z(x)) | 配分函数 (\sum_y\pi_{\rm ref}(y|x)e^{r(x,y)/\beta}) | 与 (y) 无关

| | (\rho_t) | 重要性比 (\pi_\theta/\pi_{\theta_{\rm old}}) | (>0)，理想在 1 附近

| | (\epsilon,\ A_t) | PPO 裁剪半径（典型 (0.2)）／优势估计 | (\mathbb R)

| | (G,\ R_i) | 组内采样数（典型 (8\sim64)）／第 (i) 条回答的整段奖励 | RLVR 中 (R_i\in{0,1})

| | (\varepsilon,\ \delta) | std 归一化的保护项（不是裁剪半径 (\epsilon)）／TRPO 信赖域半径 | (10^{-4})／(10^{-2}) 量级

逐步推导 · 共 15 步（点击展开）

      **Bradley-Terry 成对比较模型**（Bradley & Terry, 1952）：每个对象一个标量「实力」，胜负概率由实力差的 logistic 给出。搬到语言上，实力就是奖励；取极大似然即得奖励模型目标：

      \[ \Pr(y_w\succ y_l\mid x)=\frac{e^{r(x,y_w)}}{e^{r(x,y_w)}+e^{r(x,y_l)}}=\sigma\big(r(x,y_w)-r(x,y_l)\big), \]
      \[ \mathcal L_R=-\,\mathbb E_{(x,y_w,y_l)\sim\mathcal D}\Big[\log\sigma\big(r_\phi(x,y_w)-r_\phi(x,y_l)\big)\Big],\qquad \sigma(z)=\tfrac{1}{1+e^{-z}}. \]
      一个二分类交叉熵，只不过 logit 是两个回答的奖励之差。BT 的两个前提先摆出来：偏好可传递、存在**单一标量**解释全部比较。真实标注两条都常被违反。



      **BT 只识别到「相差一个与 \(x\) 有关的常数」。**对任意 \(c(x)\)，令 \(r'=r+c(x)\)：

      \[ \sigma\big(r'(x,y_w)-r'(x,y_l)\big)=\sigma\big(r(x,y_w)+c(x)-r(x,y_l)-c(x)\big)=\sigma\big(r(x,y_w)-r(x,y_l)\big). \]
      \(r\) 与 \(r+c(x)\) 在**任何**偏好数据上似然逐点相同，这个自由度从成对比较里**原理上就取不出来**——BT 识别的是等价类而非函数（奖励模型的绝对分值因此跨 prompt 不可比）。记住这一条：步 (6) 里被消掉的 \(\beta\log Z(x)\) **正好就是它**，抵消不是巧合。



      **KL 正则的奖励最大化。**直接最大化 \(\mathbb E[r]\) 会把策略推进奖励模型的外插区。目标对 \(x\) 可分离，固定一个 \(x\) 逐点求解：

      \[ J(\pi)=\mathbb E_{y\sim\pi}[r(x,y)]-\beta\,\mathrm{KL}\big(\pi(\cdot|x)\|\pi_{\rm ref}(\cdot|x)\big) =\sum_y\pi(y|x)\left[r(x,y)-\beta\log\frac{\pi(y|x)}{\pi_{\rm ref}(y|x)}\right]. \]
      关键是**在全部分布上**优化（\(\pi\) 只需非负、归一），不限制在任何参数族里。这既是能拿到闭式解的原因，也是后面所有麻烦的来源：真实的 \(\pi_\theta\) 是神经网络，一般表示不出这个解。



      **配方（本节最漂亮的一步）。**两边除以 \(\beta\)，把奖励塞进对数：

      \[ \frac{J(\pi)}{\beta}=\sum_y\pi\left[\frac{r}{\beta}-\log\frac{\pi}{\pi_{\rm ref}}\right]=-\sum_y\pi\,\log\frac{\pi}{\pi_{\rm ref}\,e^{r/\beta}} . \]
      分母还不是分布，归一化它：定义 \(Z(x)=\sum_y\pi_{\rm ref}e^{r/\beta}\)、\(\pi^\star=\frac1{Z(x)}\pi_{\rm ref}e^{r/\beta}\)，则 \(\pi_{\rm ref}e^{r/\beta}=Z(x)\pi^\star\)，
      \[ \frac{J(\pi)}{\beta}=-\sum_y\pi\,\log\frac{\pi}{Z(x)\pi^\star} =-\sum_y\pi\,\log\frac{\pi}{\pi^\star}+\log Z(x)\underbrace{\sum_y\pi}_{=1} =-\,\mathrm{KL}(\pi\|\pi^\star)+\log Z(x). \]
      \(\pi^\star\) 非负且求和为 1，确实是分布，所以第一项是货真价实的 KL；第二项**完全不含 \(\pi\)**。没用拉格朗日乘子、没做变分求导，只是配方。



      **读出最优解。**由 \(\mathrm{KL}\ge0\)、等号当且仅当两分布相同：

      \[ J(\pi)=-\beta\,\mathrm{KL}(\pi\|\pi^\star)+\beta\log Z(x)\ \le\ \beta\log Z(x), \]
      \[ \boxed{\ \pi^\star(y|x)=\frac{1}{Z(x)}\pi_{\rm ref}(y|x)\exp\!\Big(\frac{r(x,y)}{\beta}\Big),\qquad \max_\pi J=\beta\log Z(x).\ } \]
      三件事。**其一**，最优策略是参考策略的**指数重加权**。**其二**，\(\beta\log Z=\beta\log\mathbb E_{\pi_{\rm ref}}[e^{r/\beta}]\) 是该 prompt 的**软最大值**：\(\beta\to0\) 收敛到 \(\max_yr\)、\(\pi^\star\) 塌成 argmax；\(\beta\to\infty\) 退回 \(\pi_{\rm ref}\)。**其三**，\(\pi_{\rm ref}=0\) 处 \(\pi^\star\) 必为 0——**KL 正则原理上发现不了参考策略概率为零的回答，只能重排已有的概率质量**。这是「对齐不创造能力」的数学版本。



      **反解出奖励，\(\log Z\) 在配对差里抵消。**对闭式解取对数整理得 \(r(x,y)=\beta\log\frac{\pi^\star(y|x)}{\pi_{\rm ref}(y|x)}+\beta\log Z(x)\)，代进 BT：

      \[ \begin{aligned} \Pr(y_w\succ y_l|x)&=\sigma\Big(\beta\log\tfrac{\pi^\star(y_w|x)}{\pi_{\rm ref}(y_w|x)}+\beta\log Z(x)-\beta\log\tfrac{\pi^\star(y_l|x)}{\pi_{\rm ref}(y_l|x)}-\beta\log Z(x)\Big)\\[2pt] &=\sigma\Big(\beta\log\tfrac{\pi^\star(y_w|x)}{\pi_{\rm ref}(y_w|x)}-\beta\log\tfrac{\pi^\star(y_l|x)}{\pi_{\rm ref}(y_l|x)}\Big). \end{aligned} \]
      两个回答共享同一个 \(x\)，\(\beta\log Z(x)\) 是**同一个数**，逐项消掉。把 \(\pi^\star\) 换成待训的 \(\pi_\theta\) 做极大似然：
      \[ \mathcal L_{\rm DPO}=-\,\mathbb E\left[\log\sigma\!\left(\beta\log\frac{\pi_\theta(y_w|x)}{\pi_{\rm ref}(y_w|x)}-\beta\log\frac{\pi_\theta(y_l|x)}{\pi_{\rm ref}(y_l|x)}\right)\right]. \]
      观念转换在反解那一步：**任何奖励函数都可以被一个策略参数化**，奖励模型与策略是同一样东西的两种写法，差一个 \(\beta\log Z(x)\)。而 \(Z(x)\) 要对**全部可能回答**求和，本是最难算的一项，在差里免费消失——这就是 DPO 全部的魔法。回看步 (2)：它就是 BT 本就识别不出的 \(c(x)\)，抵消是必然而非运气。



      **DPO 的前提，以及一句必须写清的话。**推导要求：（i）偏好确由单一潜在 \(r\) 经 BT 生成；（ii）\(\pi_{\rm ref}\) 固定，且与定义 KL 目标时用的是同一个；（iii）在全分布空间优化——第三条实践中一定不成立。更要紧的是：

      \[ \arg\max_\pi\big\{\mathbb E_\pi[r]-\beta\mathrm{KL}(\pi\|\pi_{\rm ref})\big\}\ \text{与}\ \arg\min_\theta\mathcal L_{\rm DPO}\ \text{同解}\ \not\Longrightarrow\ \text{优化轨迹相同}. \]
      差别的确切位置可以指出来。RLHF 目标里的 KL 是 \(\mathbb E_{y\sim\pi_\theta}[\log\frac{\pi_\theta}{\pi_{\rm ref}}]\)，期望取在**当前策略**下，是**分布级**约束；DPO 损失里 \(\pi_{\rm ref}\) 只出现在 \((y_w,y_l)\) 这**两个点**上，数据没覆盖处不受任何约束。梯度也印证：权重 \(\sigma(\hat r_\theta(y_l)-\hat r_\theta(y_w))\) 乘的是 \(\nabla\log\pi_\theta(y_w)-\nabla\log\pi_\theta(y_l)\)（\(\hat r_\theta=\beta\log\frac{\pi_\theta}{\pi_{\rm ref}}\)），只要求**差值**变大——两个对数概率**同时下降**也满足，只要 \(y_l\) 掉得更快；长公共前缀的偏好对上这正是实测发生的事，文献称 likelihood displacement[@src-1cfa5d9541][Pal 2024][@src-97e240a47b][Razin 2024]。**「最优解等价」是关于不动点的陈述，它对沿途经过哪里一言不发。**



      **PPO-Clip 的目标与它真正做的事。**回到需要在线采样的路线：

      \[ \mathcal L^{\rm CLIP}=\mathbb E_t\Big[\min\big(\rho_tA_t,\ \operatorname{clip}(\rho_t,1-\epsilon,1+\epsilon)A_t\big)\Big],\qquad \rho_t=\frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{\rm old}}(a_t|s_t)}. \]
      逐情形展开（\(A_t\) 的符号会翻转 \(\min\) 的作用方向）：
      \[ A_t>0:\ \mathcal L_t=A_t\min(\rho_t,1+\epsilon);\qquad A_t0\) 且 \(\rho_t>1+\epsilon\) 时目标是常数 \(A_t(1+\epsilon)\)，该样本梯度为 **0**；\(A_t0\) 的样本在下方一侧完全不受限，\(A_t1.5d_{\rm targ}\) 则 \(\beta\leftarrow2\beta\)；**（iii）测量 + early stopping**——每轮估一次 observed KL，超 target 就终止本轮更新，GRPO 更把 KL 作为独立损失项加回并用 k3 无偏估计 \(\hat D=\frac{\pi_{\rm ref}}{\pi_\theta}-\log\frac{\pi_{\rm ref}}{\pi_\theta}-1\)。
      本质差别一句话：**TRPO 检查并回退，PPO 只是撤掉激励**——一个是可行性投影，一个是软性劝阻。（TRPO 自己也有水分：定理用 \(\max_s\) KL、算法放宽成 \(\mathbb E_s\) KL，但它至少**有一个可被违反的量在被检查**。）另外注意第 (ii) 条：**PPO 论文自己就写了 KL-penalty 变体**——若 clip 已给出 KL 上界，它没有理由存在。结论：**observed KL 必须被测量，不能被假设。**



      **GRPO 的优势估计，以及必须分两层看的原因。**同一 prompt 采 \(G\) 条，组内奖励 \(\{R_i\}\)：

      \[ \hat A_i=\frac{R_i-\operatorname{mean}(R)}{\operatorname{std}(R)+\varepsilon},\qquad \operatorname{mean}(R)=\frac1G\sum_{j=1}^GR_j. \]
      **(a) 先只看 mean-centering。**令 \(S=\sum_jR_j\)，把 RLOO 的 leave-one-out 基线整理一下：
      \[ A_i^{\rm LOO}=R_i-\frac{1}{G-1}\sum_{j\ne i}R_j=\frac{(G-1)R_i-S+R_i}{G-1}=\frac{G}{G-1}\Big(R_i-\frac{S}{G}\Big), \]
      \[ \boxed{\ A_i^{\rm MC}=R_i-\operatorname{mean}(R)=\frac{G-1}{G}\,A_i^{\rm LOO}.\ } \]
      \(\frac{G-1}{G}\) 是**逐样本恒等式**，不是期望意义的近似：对任意一组实现值精确成立（\(G=8\) 时 \(0.875\)，\(G=64\) 时 \(0.984\)）。既然是**全局标量**，方向完全不变、可被学习率吸收——**在这一层上「只差一个常数因子」成立**。



      **(a·续) 无偏性到底归谁。**基线不引入偏置的条件是它与被评分的动作**独立**。RLOO 的 \(b_i=\frac1{G-1}\sum_{j\ne i}R_j\) 不含 \(R_i\)，且 \(y_j\) 之间条件独立；而 sample mean **把 \(R_i\) 自己算了进去**，这一项拆不开：

      \[ \mathbb E\big[b_i\nabla\log\pi_\theta(y_i)\big]=\mathbb E[b_i]\underbrace{\mathbb E\big[\nabla\log\pi_\theta(y_i)\big]}_{=0}=0 \ \Longrightarrow\ \mathbb E\big[\hat g^{\rm LOO}\big]=g\triangleq\nabla_\theta\mathbb E_{y\sim\pi_\theta}[R], \]
      \[ \mathbb E\big[\operatorname{mean}(R)\nabla\log\pi_\theta(y_i)\big]=\tfrac1G\underbrace{\mathbb E\big[R_i\nabla\log\pi_\theta(y_i)\big]}_{=g}+\tfrac1G\sum_{j\ne i}\mathbb E[R_j]\cdot0=\tfrac1Gg \ \Longrightarrow\ \mathbb E\big[\hat g^{\rm MC}\big]=\tfrac{G-1}{G}g. \]
      与步 (12) 的逐样本恒等式完全一致。**所以严格说：sample-mean 版有偏、LOO 版才无偏**[@src-da2f97cef0][RLOO]；但 sample-mean 的偏置**恰好是纯尺度**，方向不偏。这个「有偏但只偏在尺度上」的刻画，比笼统说「GRPO 无偏」或「GRPO 有偏」都更有用。（\(K=3\) 离散策略穷举验算：\(G=2\ldots6\) 时 \(\mathbb E[\hat g^{\rm MC}]/g\) 逐分量等于 \(0.5,0.667,0.75,0.8,0.833\)；LOO 版残差 \(0\)、\(Z(x)=\mathbb E_{\pi_{\rm ref}}[e^{r/\beta}]40%** 迭代数、**>35%** 墙钟时间；相对 Shampoo 两项各改善约 **20%**。注意这里的"1/2 次幂 Shampoo"与第 (3) 步的 1/4 次幂是**不同的算法变体**——实践中指数常被当成一个可调超参 \(p\)（Anil 等的分布式 Shampoo 就是这么做的），第 (4) 步的 \(-1/4\) 是理论最自然的那个取值，不是唯一被使用的取值。

    最后接上 Nested Learning，它把优化器与架构统一。**先声明归属：Nested Learning 与 HOPE 出自 Google Research（Behrouz–Mirrokni 等，NeurIPS 2025），与 Google DeepMind 的 Gemini 生产线没有任何公开关联，与 B15 的 Titans / Atlas / MIRAS 属于同一条平行研究线。**其核心主张是：**模型不是一个静态架构，而是一组嵌套的优化问题，每一层有自己的更新频率 \(f_\ell\)** —— 预训练是频率最低的一层，优化器动量是中间频率，in-context learning 是频率最高的一层。论文指出**优化器本身就是一种联想记忆**：把动量写成

\[ m_t=\eta_tm_{t-1}-\theta_t\,g_t , \]
与 B15 第 (4) 步的 \(S_t=\eta_tS_{t-1}-\theta_t\nabla\ell\) **逐符号相同**。由此推出 deep momentum GD —— 既然动量是记忆，就把它换成一个更强的记忆：

\[ \mathcal{M}^{(m)}_t=\mathcal{M}^{(m)}_{t-1}-\theta_t\nabla_{\mathcal{M}^{(m)}}\big\lVert\mathcal{M}^{(m)}_{t-1}(k_t)-g_t\big\rVert^2 . \]
也就是说，Adam 的一阶矩就是一个"键为时间步、值为梯度"的线性联想记忆，写入规则是 Hebbian 外积的退化版（键恒为 1）。**连续记忆系统（CMS）**进一步把"长期/短期"二分换成一个频率谱：一串 MLP 块，第 \(\ell\) 个每 \(C^{(\ell)}\) 步更新一次；标准 Transformer 的 MLP 块是其特例（只有一块，且频率为零 —— 预训练后不再更新）。**HOPE** = 自指版 Titans + CMS。**再强调一次：这是 Google Research 的工作，截至 2026-07-25 没有公开证据表明它进入了 Gemini 的任何版本。**

• A1　Shampoo 的 Loewner 界（第 4 步）无条件成立，只要求每个 (G_s) 的秩 (\le r)；它不需要”梯度真的具有 Kronecker 结构”这个假设。需要那个假设的是界的紧度：(r) 越大、上界离 (H_t) 越远，Shampoo 相对 full-matrix AdaGrad 的损失就越大。

• A2　Muon 的推导（第 6 步）依赖三条前提：损失的一阶线性化、把信赖域取成谱范数球（这是建模选择）、以及 (M) 满秩才能保证 (\mathrm{msign}) 是唯一最优解。实践中小奇异值会被 Newton–Schulz 放大到 1 附近，这既是特性（均衡各方向）也是风险（放大噪声）。

• A3　第 (8) 步的等价用了 (\Sigma) 可逆且 (\epsilon\to0)；有零奇异值时要在伪逆意义下理解，(\epsilon\gt0) 时它退化为软阈值 (\sigma\mapsto\sigma/\sqrt{\sigma^2+\epsilon})。

• A4　Newton–Schulz 迭代（第 7 步）要求先把矩阵归一化进收敛域，且五次多项式的不动点不是精确的 1，只是 1 附近的一个带。

• A5　SOAP 的实验规模是 360M / 660M，结论外推到百 B 规模需谨慎。

• L1　内存与算力开销。Shampoo 要存 (m^2+n^2) 并周期性做特征分解（(O(m^3+n^3))）；对 (m=n=8192) 是每次约 (10^{12}) FLOPs。Muon 便宜得多（5 次 matmul）但仍是每步额外 (5\times 2mn\min(m,n)) 量级。

• L2　分布式实现困难。预条件子是逐参数矩阵的，与张量并行的分片方式冲突。

• L3　(\epsilon) 与 (r) 都是要调的，而理论不告诉你怎么调。第 (4) 步说明了 (\epsilon) 必须为正（否则秩亏时负幂无定义）、(r) 决定允许的学习率尺度，但引理只给出”(r) 是秩上界”这一条约束，实际训练中梯度的有效秩随层、随训练阶段变化。这就是为什么各家实现都要额外挂 grafting（借另一个优化器的步长）之类的补丁 —— 理论定住了方向，没定住尺度。

• L4　Muon 不适用于所有参数。它要求参数是”有意义的矩阵”。embedding（行是独立 token，正交化会混淆语义）、LayerNorm 增益（一维）、bias、输出头都必须回退到 Adam。实践中是 Muon + Adam 混用，这增加了调参面。

• L5　大规模公开验证仍少。截至 2026-07，Muon 最大规模的公开案例是 Kimi K2（Moonshot AI）：1T 总参数 / 32B 激活的 MoE，用 MuonClip（Muon + QK-Clip：监控每个注意力头的最大 logit，超过阈值 (\tau=100) 时按 (\gamma=\min(1,\tau/S_{\max})) 缩放 (W_q,W_k)）在 15.5T token 上训练，报告 zero loss spike。这是很强的证据，但它同时说明朴素 Muon 在这个规模上需要额外的稳定化手段；至于”没有 QK-Clip 就一定会炸”这个更强的说法，公开材料只报告了带 QK-Clip 的成功配置，现有证据不足以判定无 Clip 版本的失败率。

• L6　Nested Learning / HOPE（Google Research）的实验规模远小于前沿模型，且”自指”架构的训练稳定性未在大规模上验证。

    Shampoo 的关键引理是 \(\epsilon I_{mn}+\frac1r\sum_sg_sg_s^\top\preceq L_t^{1/2}\otimes R_t^{1/2}\)（\(g=\overline{\mathrm{vec}}\) 行主序；\(L_0=\epsilon I_m,R_0=\epsilon I_n\)；\(r\) 是梯度秩的上界）。**rank 因子 \(1/r\) 与两处 \(\epsilon I\) 都不能省**：前者来自把 \(r\) 项 SVD 之和拆开时的 Cauchy–Schwarz，后者是秩亏时负幂能否定义的前提。对两边取 \(-1/2\) 次幂、把指数平摊到左右两侧即得 \(-1/4\)，同时给出 \(L^{-1/4}\otimes R^{-1/4}\preceq\sqrt r\,(r\epsilon I+H_t)^{-1/2}\)；那个 \(\sqrt r\) 被学习率 \(\eta=D/\sqrt{2r}\) 吸收并留在 regret \(\sqrt{2r}D\operatorname{Tr}(L_T^{1/4})\operatorname{Tr}(R_T^{1/4})\) 里。\(-1/4\) 的动机（两侧各 \(-1/4\) 合成 full-matrix AdaGrad 的 \(-1/2\)、且给出 \(O(1/\sqrt t)\) 的步长衰减）在补上这两个部件后**仍然成立**。Muon 是谱范数球上（对动量矩阵、在一阶线性化下）的最速下降，也是 \(\epsilon\to0\) 满秩极限下无累积的 Shampoo；\(\epsilon\gt0\) 时该恒等式退化为软阈值 \(\sigma\mapsto\sigma/\sqrt{\sigma^2+\epsilon}\)。SOAP 是在 Shampoo 特征基里跑 Adam。三者共享同一个哲学转变：**从"参数是一堆独立的数"到"参数是有几何结构的对象"。**

  这一节与 Gemini 的关系必须写得极其克制，因为它是最容易被过度联想的地方。

  已知的公开事实只有三条：Shampoo 出自 Google（Gupta–Koren–Singer, 2018）；Google 曾用 Shampoo 拿下 MLPerf BERT 训练记录；PaLM 用的是 Adafactor（不带因子分解的变体）。而 Gemini 技术报告在优化器这一项上完全沉默 —— 从 1.0 到 2.5 的所有公开材料都没有说明使用了哪个优化器，3.x 则连技术报告都没有。

  因此：**「Gemini 3 用 Muon」「Gemini 用 Shampoo」这类说法全部是推测，本章不作此类断言。**SOAP 出自 Harvard；Nested Learning 与 HOPE 出自 Google Research（Behrouz–Mirrokni 等，NeurIPS 2025），与 Gemini 无公开关联 —— 这一点与 B15 的 Titans / Atlas / MIRAS 完全一样，属于同一条平行研究线，不得写成 Gemini 的技术组成部分。

  另外提醒一条容易被忽略的边界：优化器的收益在历史上一直很难在规模上兑现。Adam 统治了十年不是因为它最好，而是因为它在每一个规模上都足够好且从不炸。Muon 在 Kimi K2 上的成功配置包含了 QK-Clip 这个额外的稳定化手段，这至少说明在前沿规模上，二阶 / 矩阵型方法目前仍需要配套的护栏；但这不等于说它们注定脆弱 —— 公开的大规模对照实验太少，现有证据不足以判定这是范式的固有性质还是当前实现的成熟度问题。

  第 (8) 步那个恒等式（Muon = 无累积 Shampoo）是这个领域少有的、把两条独立发展的线索精确接上的时刻。它也解释了为什么 Muon 这么便宜却这么有效：Shampoo 累积历史梯度的二阶统计量，是为了估计一个稳定的曲率；Muon 干脆放弃估计曲率，只做”把当前更新的所有奇异值拉平到 1”这一件事。放弃的是自适应性，换来的是每步只要 5 次 matmul，且天然地把每层的更新范数标准化了。

  把第 (4) 步补全的那两个部件读一遍，会发现它们各自对应一个很实际的判断。rank 因子 (r) 说的是：Kronecker 近似的代价随梯度的有效秩线性变差——大 batch（梯度秩高）时 Shampoo 的理论保证更松，这与”二阶方法在大 batch 区间收益最明显”的经验观察形成了一个值得注意的张力，两者未必矛盾（regret 界松不代表实际表现差），但说明这套理论解释不了它自己最成功的那个场景。阻尼 (\epsilon) 说的则是：秩亏不是边缘情况，而是常态——只要 micro-batch 的 token 数小于层宽，梯度就是低秩的。这两点合起来解释了为什么工程实现里 (\epsilon)、指数 (p)、grafting、预条件更新频率这些”超参”从来不是可选项。

  而 Nested Learning（Google Research）提供了把这一切与 B15 缝起来的框架：如果 Titans 的记忆写入是”内循环的一步优化”，而优化器的动量是”对梯度序列的压缩”，那么架构与优化器就是同一件事在不同时间尺度上的两个切片。这个观点很美 —— 而且下一节（B23）会从第三个方向给出同一个结论：注意力的一次前向，也是一步优化。需要一起记住的是它的证据状态：这条线上的所有工作（Titans / Atlas / MIRAS / HOPE）都出自 Google Research，实验规模在千万到十亿参数量级，与 Gemini 生产线没有公开的直接关联。

  B22 · 压缩即智能：Solomonoff 归纳、MDL，以及”log-loss = 压缩率”是恒等式而非比喻

  **一句话。**训练大语言模型在字面意义上就是训练一个压缩器 —— 这是一个恒等式；但按压缩派自己的记账标准（把参数也算进去），当今最强的模型是最差的压缩器。

    B22
    Kraft、算术编码、Solomonoff 与 MDL
    Solomonoff 1964/1978 ／ Delétang et al., ICLR 2024 · arXiv:2309.10668 ／ Chollet, arXiv:1911.01547
  
  
  
  
      符号表

| | (x_{1:n}) | 长度 (n) 的符号序列 | (\mathcal{X}^n)

| | (\rho,\hat\rho) | 真实 / 模型的编码分布 | 概率

| | (\ell(x)) | 编码 (x) 的比特数 | (\ge 0)

| | (\mathcal{L}) | 交叉熵损失 | bits/token

| | (K(x)) | Kolmogorov 复杂度 | 比特

| | (M(x)) | Solomonoff 通用先验 | 半测度

| | (U) | 通用图灵机 | —

| | (L(H),L(D\mid H)) | MDL 的两部分编码长度 | 比特

| | (S_t) | 第 (t) 步的期望平方预测误差 | (\ge 0)

| | (D) | 待压缩数据集的字节数 | Byte

逐步推导 · 共 11 步（点击展开）
建立"概率 ↔ 码长"的双射。Kraft–McMillan 不等式说：对任意**唯一可解码**的二元码，码长必满足

\[ \sum_{x\in\mathcal{X}}2^{-\ell(x)}\ \le\ 1 . \]
反过来，给定任意满足 \(\sum_xp(x)\le 1\) 的 \(p\)，令 \(\ell(x)=\lceil-\log_2p(x)\rceil\)，则 \(\sum_x2^{-\ell(x)}\le\sum_xp(x)\le 1\)，故存在这样的前缀码。

\[ \boxed{\ p\ \longleftrightarrow\ \ell=-\log_2p\ } \]
前缀码的直观证明：把每个码字看成二叉树上的一个节点，长度 \(\ell\) 的码字"占据"了叶子空间的 \(2^{-\ell}\) 比例，且互不重叠，总和自然不超过 1。**这个双射是整节的地基 —— 从此"概率模型"和"压缩器"是同一个对象的两种叫法。**

    证明算术编码几乎达到这个界。算术编码把 \(x_{1:n}\) 映到 \([0,1)\) 里的一个数：初始 \(I_0=[0,1)\)，第 \(k\) 步把当前区间按条件分布 \(\rho(\cdot\mid x_{\lt k})\) 切分并选中 \(x_k\) 对应的那块。递归下去，最终区间长度是

\[ |I_n|=\prod_{k=1}^{n}\rho(x_k\mid x_{\lt k})=\rho(x_{1:n}) . \]
**关键引理**：任何长度为 \(L\) 的区间必包含一个形如 \([m2^{-j},(m+1)2^{-j})\) 的二进小数区间，只要 \(2^{-j}\le L/2\)，即 \(j\ge\lceil-\log_2L\rceil+1\)。取该区间左端点，其二进制表示只需 \(j\) 位，故

\[ \ell_{\text{AC}}(x_{1:n})\ \le\ \lceil-\log_2\rho(x_{1:n})\rceil+1\ \le\ -\log_2\rho(x_{1:n})+2\ \text{比特} . \]
开销是**常数 2 比特**，不随 \(n\) 增长。这是整个论证能成立的技术核心：如果开销随 \(n\) 增长，下一步的等价就只是渐近的。

    把模型代进去，得到等价定理。用 \(\hat\rho\) 代替未知的 \(\rho\)，实际码长是 \(-\sum_k\log_2\hat\rho(x_k\mid x_{\lt k})+O(1)\)，每 token 平均：

\[ \frac{\ell_{\text{AC}}(x_{1:n})}{n}\ \le\ \underbrace{-\frac1n\sum_{k=1}^{n}\log_2\hat\rho(x_k\mid x_{\lt k})}_{=\ \mathcal{L}\ \text{（交叉熵，bits/token）}}+\frac2n . \]
\[ \boxed{\ \textbf{语言模型的交叉熵损失，就是算术编码下的每 token 比特数（差 }O(1/n)\textbf{）。}\ } \]
**"训练大语言模型 = 训练压缩器"是字面成立的，不是比喻。**最小化 log-loss 与最小化压缩后长度是同一个优化问题。Delétang 等的原话是："current language model training protocols use a maximum-compression objective."

    把它推到理论极限：Solomonoff 归纳。定义通用先验

\[ M(x)=\sum_{p\,:\,U(p)=x*}2^{-|p|} , \]
即所有输出以 \(x\) 为前缀的程序 \(p\)，按 \(2^{-|p|}\) 加权求和 —— 这是**所有可计算预测器的贝叶斯混合**，先验权重是程序长度的指数衰减，即奥卡姆剃刀的形式化。设 \(p^*\) 是输出 \(x\) 的最短程序（\(|p^*|=K(x)\)），它是求和中的一项，故 \(M(x)\ge 2^{-K(x)}\)，即

\[ -\log_2M(x)\ \le\ K(x)+O(1) . \]
更一般地，对任意可计算预测器 \(q\)（程序长度 \(\ell_c(q)\)），\(M(x_{1:n})\ge 2^{-\ell_c(q)}q(x_{1:n})\)，故

\[ -\log_2M(x_{1:n})\ \le\ -\log_2q(x_{1:n})+\ell_c(q) . \]
**\(M\) 的压缩长度不比任何可计算压缩器差，只多一个与序列长度无关的常数。**这就是"压缩最优 = 预测最优"的严格陈述。

    给出收敛定理（Solomonoff 1978）。设 \(\mu\) 是真实的可计算测度，\(S_t\) 是第 \(t\) 步的期望平方预测误差，则

\[ \boxed{\ \sum_{t=1}^{\infty}S_t\ \le\ \frac{\ln 2}{2}\,K(\mu)\ } \]
证明思路两步：先用 Pinsker 型不等式把平方误差和上界为 KL 散度，\(\sum_{t\le n}S_t\le\frac12\sum_{|x|=n}\mu(x)\ln\frac{\mu(x)}{M(x)}\)；再用通用支配性 \(M(x)\ge 2^{-K(\mu)}\mu(x)\) 代入，得 \(\frac12\sum_x\mu(x)\ln 2^{K(\mu)}=\frac{\ln 2}{2}K(\mu)\)。

**震撼之处在于右边是一个常数**，不依赖 \(n\)。所以 \(S_t\to 0\) 且总误差有界 —— Solomonoff 归纳对任何可计算环境都快速收敛。代价是 \(M\) **不可计算**（求和要遍历所有停机程序，停机问题不可判定）。**它是理论上界，不是算法。记住这一点，最后一步会用到。**

    下降到可计算的近似：最小描述长度（MDL）。

\[ \hat H=\operatorname*{arg\,min}_{H\in\mathcal{H}}\big[L(H)+L(D\mid H)\big] , \]
即"模型自身的编码长度 + 用模型编码数据的长度"。与贝叶斯最大后验的对应是直接的，由第 (1) 步的 \(\ell=-\log_2p\)：

\[ L(H)+L(D\mid H)=-\log_2P(H)-\log_2P(D\mid H)=-\log_2P(H\mid D)+\text{const} . \]
**最小化两部分码长 = 最大化后验。**MDL 是 Solomonoff 归纳把"所有程序"限制到一个可计算模型族上的版本。注意 \(L(H)\) 这一项 —— 下一步整个论战都围绕它。

    看实证。DeepMind 的《Language Modeling Is Compression》用三个 1 GB 数据集（enwik9 文本、ImageNet 灰度 patch、LibriSpeech 音频），全部切成 2048 字节的 chunk。**论文摘要的数字是**：Chinchilla 70B 把 ImageNet 压到 **43.4%**、LibriSpeech 压到 **16.4%**，优于 PNG（**58.5%**）与 FLAC（**30.3%**）。

**但这里必须处理一个数字上的不一致，这正是核查的价值所在。**同一份论文的 **Table 1** 给出的 Chinchilla 70B 原始压缩率是 enwik9 **8.3%** / ImageNet **48.0%** / LibriSpeech **21.0%** —— 与摘要不一致（摘要更乐观）。此外摘要引用的基线是**混搭**的：PNG 的 58.5% 来自无分块（\(\infty\) context）设定，FLAC 的 30.3% 来自 2048 分块设定（无分块时 FLAC 是 30.9%，分块 PNG 是 61.7%）—— 摘要为每个基线选了对自己有利的那个数。**严谨引用应以 Table 1 为准，并注明摘要数字。**不论用哪组，定性结论都成立且很强：**一个只在文本上训练的模型，在图像和音频上打败了为这些模态专门设计的无损压缩器。**

    给出最锋利的反驳：adjusted compression rate。上面的数字**都没有把模型参数计入压缩后的输出**。但一个真正的无损压缩器必须自带解码器 —— 按第 (6) 步的两部分编码，你要把模型也发过去。论文用 float16 编码每个参数，于是 Chinchilla 70B 就是 140 GB 的附件。对 1 GB 的数据集：

\[ r_{\text{adj}}=\frac{r_{\text{raw}}\cdot D+|\theta|}{D}\quad\Longrightarrow\quad r_{\text{adj}}^{\text{Chinchilla 70B}}=\frac{0.083\times 10^{9}+140\times 10^{9}}{10^{9}}=\mathbf{14008.3\%} . \]
**它不是压缩器，它是一个需要 140 GB 附件的解压说明书** —— 比原始数据大 140 倍，比 gzip 差 433 倍。按压缩派自己的标准（MDL 两部分编码），当今最强的语言模型是最差的压缩器。这是这场辩论中最实证、最难绕开的一击。

    把这一击量化到底：**数据要多大，Chinchilla 70B 才能在两部分编码下打败 gzip？**令

\[ \frac{0.083D+140\times 10^{9}}{D}\lt 0.323\quad\Longrightarrow\quad 0.24D\gt 140\times 10^{9}\quad\Longrightarrow\quad D\gt 5.83\times 10^{11}\ \text{字节}\approx \mathbf{583\ GB} . \]
需要约 580 GB 的 enwik 类文本才能摊销掉参数成本。**而这个数远小于它的训练集**（1.4T token，约 5–6 TB）。所以在训练集规模上"压缩即智能"是成立的 —— 这恰恰是最有意思的地方：**论证的成败完全取决于你把多大的数据集算作"要压缩的对象"。**（此式为本章基于论文表格数字所推，假设压缩率在数据规模变化时保持 8.3% 不变，实际会变。）论文另给出一个直接相关的发现：adjusted compression rate 对模型规模是 **U 形**的 —— 模型越大原始压缩率越好，但参数成本增长更快，故存在一个最优规模。

    再给出对这一击的**反反驳**：prequential（在线）编码。两部分编码不是唯一的记账方式。prequential 编码让编码器与解码器从**同一个随机初始化**出发，逐块处理：先用当前模型编码下一块，再用这一块更新模型；解码器做完全相同的事，因此**不需要传输任何参数**，只需传输训练脚本（几 KB）：

\[ \ell_{\text{preq}}(x_{1:n})=\sum_{t=1}^{n}-\log_2\hat\rho_{\theta_{t-1}}(x_t\mid x_{\lt t})+\underbrace{|\text{训练脚本}|}_{O(\text{KB})} . \]
注意 \(\theta_{t-1}\) 是只看过 \(x_{\lt t}\) 的模型，所以这个和**恰好就是训练过程中累积的总损失**（学习曲线下的面积）。Blier & Ollivier (2018) 证明过参数化神经网络在这个度量下压缩得非常好 —— 因为参数不需要被传输，只有"学习过程中犯的错"要付费。这个记账方式在哲学上也更贴切：它衡量的是**从零开始理解这批数据需要多少比特**，而不是"携带一个已训练好的模型需要多少比特"。**所以"压缩即智能"的成败，很大程度上取决于你认为智能应该按存量还是按增量计价** —— 两部分编码算存量，prequential 算增量，而人类学习显然更接近后者。

    最后给出**不依赖记账方式**的那条反驳，也是我认为最有分量的一条：Chollet 的 skill-acquisition efficiency。智能应定义为"在给定先验与经验下获取**新**技能的效率"，而不是已掌握技能的多寡。ARC-AGI 的设计动机就是切开这两者：每个任务只给 2–3 个样例，且任务在训练中从未出现。用压缩的语言精确表述：

\[ \text{LLM 优化的是 } K(\text{已见数据}),\qquad \text{ARC 测的是 面对新数据时找到短程序的\textbf{速度}} . \]
前者是**压缩率**，后者是压缩的**计算效率** —— 而由第 (5) 步，Solomonoff 归纳恰好在压缩率上是最优的、在计算效率上是最差的（不可计算）。所以压缩派和 Chollet 争的其实不是"智能是不是压缩"，而是**"智能是压缩的结果还是压缩的过程"**。前者你可以用参数堆出来，后者你不能。一个二十年的旁证：Hutter Prize 的历届获胜者全是 PAQ/CMIX 系的上下文混合算法而非神经网络 —— 因为规则要求**程序 + 数据的总大小**，也就是第 (8) 步的两部分编码。

• A1　算术编码假设无限精度；有限 (B) 位精度额外增加 (O(n2^{-B})) 比特，32/64 位下可忽略。

• A2　Solomonoff 的收敛定理要求真实环境 (\mu) 是可计算测度。

• A3　adjusted rate 用 float16（2 字节/参数）编码模型；论文验证了用 gzip/LZMA2 进一步压缩 float16 权重只能到 92.2% / 89.1%，即权重几乎不可压。

• A4　所有压缩数字都在 2048 字节 chunk 下测（Transformer 上下文限制），这系统性地惩罚了长上下文的经典压缩器。

• L1　论文摘要与 Table 1 的数字不一致（43.4 / 16.4 vs 48.0 / 21.0），引用时必须说明取的是哪一组，且基线是混搭的。

• L2　论文只评估离线两部分编码；prequential 编码给出完全不同的图景，论文承认这一点但因成本没做。

• L3　无损压缩的极限 ≠ 泛化。第 (3) 步的等价是关于训练分布上的 log-loss。一个把训练集完美记住的模型有极低 log-loss 与极好压缩率，但泛化为零。压缩率只在未见数据上测才有意义。

• L4　**有损压缩与抽象层次的缺失。**人类的认知压缩是有损的：我们记住”那次会议很紧张”而不是每一个音节。无损压缩强迫模型给噪声也分配比特 —— 论文的 Random 列显示 Chinchilla 在纯随机数据上”压缩”到 100.8%，即它诚实地承认压不动，但也为此付出 0.8% 的开销。真正的智能可能恰恰在于知道哪些比特可以扔掉，而这在无损框架里无法表达。

• L5　583 GB 那个门槛是本章基于表中数字自推的，不是论文结论。

    定理部分毫无争议：由 Kraft 不等式与算术编码，交叉熵**就是**每 token 比特数，训练大语言模型**就是**在训练压缩器。争议全在第二步 —— 压缩了，然后呢？两部分编码说 Chinchilla 70B 是灾难性的压缩器；prequential 编码说它极好；Chollet 说这两个都答错了题，因为智能是压缩的过程而不是结果。

| | 压缩器 | enwik9 原始压缩率 | ImageNet 原始 | LibriSpeech 原始 | enwik9 调整后 含参数（两部分编码）

| | gzip（无分块） | 32.3% | 70.7% | 36.4% | 32.3%

| | LZMA2 | 23.0% | 57.9% | 29.9% | 23.0%

| | PNG / FLAC（模态专用） | — | 58.5% (无分块) / 61.7% (分块) | 30.3% (分块) / 30.9% (无分块) | —

| | Transformer 3.2M（在 enwik8 上自训练） | 17.0% | — | — | 17.7%

| | Chinchilla 1B | 11.3% | — | — | 211.3%

| | Chinchilla 7B | 10.2% | — | — | 1410.2%

| | Llama 2 (7B) | 8.9% | 53.4% | 23.1% | 1408.9%

| | Chinchilla 70B | 8.3% | 48.0% (摘要作 43.4%) | 21.0% (摘要作 16.4%) | 14008.3%

数据来源：Delétang et al., *Language Modeling Is Compression*, ICLR 2024, arXiv:2309.10668，Table 1 与 Table 2。[@src-5cd0bc035b][LM is Compression] **摘要与 Table 1 的不一致已在表内标出**；PNG/FLAC 两个基线的分块设定不同，摘要为每个基线选取了对自身有利的一档，并排比较时必须说明。

**它到底在说什么。**这一节里有**一个恒等式和一个哲学命题**，它们经常被当成同一件事，但强度差得很远。
恒等式那一半是硬的：由 Kraft 不等式与算术编码的 \(\lceil-\log_2 p(x)\rceil+1\) 位上界，
「最小化交叉熵」与「最小化期望码长」**在字面意义上是同一个优化问题**——
训练语言模型就是训练压缩器，这里没有任何比喻成分。
哲学命题那一半则弱得多：**「好的压缩器就是智能的」需要额外的桥接假设**，
而这个桥接恰恰是 Solomonoff 归纳给不出来的（它不可计算），也是 MDL 只能在给定模型类里给出的。
把这两半分开，本节剩下的全部争论就都清楚了：
**两部分编码**问「把字典也算进去还划算吗」，**prequential 编码**问「在线预测的累计代价是多少」，
**Chollet** 则拒绝这个问法本身，主张要量的是「获取新技能的效率」而不是「压缩已见分布的程度」。
三方用的是三个不同的目标函数，所以他们不可能互相说服——**这不是事实之争，是量什么的分歧。**

**「压缩即智能」在 Google 这里更接近真信仰，判据是它指导了资源分配 —— 如果只是叙事，公司不会为它花十年和数十亿美元。**以下是我的判断。

证据链是这样的：AlphaFold 把蛋白质折叠压缩成一个模型、GNoME 把材料空间压缩、GraphCast / GenCast 把大气动力学压缩成一个神经网络、AlphaEvolve 把算法空间压缩 —— 这些项目的共同结构都是"把一个巨大的搜索空间压缩成一个可查询的简洁模型"，而且**大部分不赚钱**。Demis Hassabis 在诺贝尔奖之后仍然把 AI for Science 放在第一位，这不是营销能解释的。而《Language Modeling Is Compression》这篇论文本身出自 DeepMind —— **一家愿意发表一篇结论对自己产品不利（14008%）的论文的实验室，大概率是真的在意这个问题而不是在讲故事。**

需要标注的是引用纪律：Hassabis"智能是把复杂现象压缩成简洁规律"这个说法在中文材料里流传很广，但**我未能定位到逐字原文，应视为转述而非原话**。他确实反复讲过科学发现的本质是在巨大搜索空间里找到简洁结构（AlphaFold、AlphaGo 的第 37 手都被他这样描述过），但"压缩"这个具体措辞的原始出处未核实。相比之下 Ilya Sutskever 的表述是有录像可查的原话："it is well-known that compression is prediction. Every compressor can be a predictor, and vice versa."[@src-d8da9ce8aa][Simons 2023]

**其一，论文自己承认把模型参数计入后，压缩率优势会大幅缩水。**这就是推导第 (8) 步的 adjusted compression rate：Chinchilla 70B 的参数本身就是 140 GB 的"字典"，在 1 GB 数据集上给出 14008% 的成绩。**任何引用 43.4% / 16.4% 而不提这一条的表述都是选择性引用。**

**其二，Chollet 的 ARC-AGI 就是为了区分「压缩已见分布」和「高效获取新技能」而设计的。**这个反驳比第一条更根本，因为它不依赖记账方式。而 2026 年的数据让这场辩论变得更有意思而不是更清晰：Gemini 3.1 Deep Think 在 ARC-AGI-2 上拿到 **84.6%（13.62 美元/题）**、ARC-AGI-1 上 **96.0%（7.17 美元/题）** —— 这是对 Chollet 反驳的强力回应，说明"获取新技能"确实可以被工程化。**但成本又把问题拉回来了**：如果需要花这么多算力，那到底是"智能"还是"暴力搜索"？值得注意的是 ARC Prize 第一次把"每题美元成本"和分数**并列公布** —— 这意味着评测界已经承认单看分数是无意义的。用第 (11) 步的语言说：他们开始同时测压缩率**和**压缩的计算效率了。

### B23 · Attention 的 Hopfield 视角，与 in-context learning 的隐式梯度下降

**一句话。**softmax attention 可以读成现代 Hopfield 网络的一步能量下降——**前提是键与值绑定成同一组存储模式（tied patterns）**；而在**线性注意力、特定构造的权重、平方损失线性回归**这三个前提下，一层注意力能**精确**实现一步梯度下降。检索与学习因此是同一件事的两种读法。**但这两句都是带条件的结果，不是「ICL 就是梯度下降」这种普适断言。**



    B23
    Hopfield 检索与 ICL 的隐式优化
    Ramsauer et al., ICLR 2021 · arXiv:2008.02217 ／ Krotov & Hopfield, ICLR 2021 · arXiv:2008.06996 ／ Millidge et al., ICML 2022 · arXiv:2202.04557 ／ von Oswald et al., ICML 2023 · arXiv:2212.07677 ／ Agarwal et al., NeurIPS 2024 · arXiv:2404.11018




      符号表

| | (X=[x_1\cdots x_N]) | 存储的模式矩阵（tied 情形下同时充当键与值） | (\mathbb{R}^{d\times N})

| | (K,V) | generic 情形下分开的键矩阵与值矩阵 | (\mathbb{R}^{d\times N})

| | (\xi) | 查询状态 | (\mathbb{R}^{d})

| | (p) | softmax 打分权重 (\mathrm{softmax}(\beta K^\top\xi)) | (N) 维概率单纯形

| | (\beta) | 逆温度 | (\gt 0)

| | (\mathrm{lse}(\beta,z)) | (\beta^{-1}\log\sum_ie^{\beta z_i}) | 标量

| | (M) | 模式的最大范数 (\max_i\lVert x_i\rVert) | (\gt 0)

| | (e_j=(x_j,y_j)) | 第 (j) 个 token（输入与标签拼接） | (\mathbb{R}^{N_x+N_y})

| | (W_K,W_Q,W_V,P) | 键 / 查询 / 值 / 输出投影 | 见构造

| | (W_0,\Delta W) | 隐式线性模型的初值与一步更新 | (\mathbb{R}^{N_y\times N_x})

| | (\eta) | 隐式学习率 | (\gt 0)

逐步推导 · 共 11 步（点击展开）
从经典 Hopfield 的容量说起。经典网络能存 \(d\) 个不相关模式，但对**随机**模式只能存 \(Cd/\log d\) 个（\(C\lt 1/2\) 单模式稳定，\(C\lt 1/4\) 全模式稳定）。

这与 B16 第 (5) 步那条上界是同一件事的两种说法 —— 二次能量函数对应的正是外积记忆，而那条上界同样是**在给定读出算子类之下**成立的。所以"注意力和线性注意力的容量差距"这个问题，早在 1980 年代就被以另一种语言问过。

    换能量函数。经典能量对应交互函数 \(F(x)=x^2\)；Krotov–Hopfield 用 \(F(x)=x^n\) 得到正比于 \(d^{n-1}\) 的容量；Demircigil 等用 \(F(x)=\exp(x)\) 得到 \(2^{d/2}\) 容量（二元模式）。Ramsauer 等把它推广到**连续**状态：

\[ E=-\,\mathrm{lse}\big(\beta,\ X^\top\xi\big)+\tfrac12\xi^\top\xi+\beta^{-1}\log N+\tfrac12M^2 . \]
第一项是"吸引到最相似的模式"，第二项防止 \(\xi\) 发散（连续状态没有二元的范数约束），后两项是常数。**关键的换法是把多项式交互换成指数交互** —— 这一个改动就把容量从多项式推到指数。

    证明一步更新恰是 softmax attention（**tied 情形**）。用凹凸过程（CCCP）最小化 \(E\)：把 \(-\mathrm{lse}\) 视为凹部分、\(\tfrac12\xi^\top\xi\) 视为凸部分，CCCP 的更新是

\[ \nabla_\xi\big(\tfrac12\xi^\top\xi\big)\big|_{\xi^{\text{new}}}=-\nabla_\xi\big(-\mathrm{lse}\big)\big|_{\xi^{\text{old}}} . \]
而 \(\nabla_\xi\,\mathrm{lse}(\beta,X^\top\xi)=X\,\mathrm{softmax}(\beta X^\top\xi)\)，故

\[ \xi^{\text{new}}=X\,\mathrm{softmax}\big(\beta X^\top\xi\big) . \]
把 \(\xi\to Q\)、\(X\to K\)（打分）与 \(V\)（取值）、\(\beta=1/\sqrt d\)，形式上就是 \(\mathrm{softmax}(QK^\top/\sqrt d)V\)。**但请注意这一步偷偷做了什么：它把打分用的 \(X\) 与取值用的 \(X\) 分别改名成了 \(K\) 与 \(V\)。下一步专门处理这个偷换。**

容量方面 Ramsauer 证明：对球面上的随机模式，容量正比于 \(c^{(d-1)/4}\)（\(c=1.37\) 或 \(3.15\)，取决于取回概率的设定），即**指数于 \(d\)** —— 远超经典 Hopfield 的 \(d/\log d\)，也远超 B16 里线性注意力那条 \(m\) 的上界。差别的来源正是 softmax 的指数交互：它让"最相似的那个"在指数尺度上压倒其余。**这就是 B16 那条约束的另一面：softmax 不是可有可无的非线性，它是打分分辨力的来源。**

    **★把适用条件写死：上一步那个标量能量对应的是 tied key/value。**回看不动点 \(\xi^{\text{new}}=X\,\mathrm{softmax}(\beta X^\top\xi)\)——**同一个 \(X\) 出现了两次**：一次用来**打分**（\(X^\top\xi\)），一次用来**取值**（左乘 \(X\)）。这正是「键与值绑定为同一组存储模式」，记作 \(K=V=X\)。而真实注意力层是 \(K=W_KR,\ V=W_VR\)，一般 \(W_K\ne W_V\)，更新变成

\[ \xi\ \longmapsto\ F(\xi)=V\,\mathrm{softmax}\big(\beta K^\top\xi\big),\qquad K\ne V . \]
**这个 generic 映射一般*不是*上面那个标量能量的梯度步 / CCCP 步。**一个干净的必要条件检验：若存在标量 \(E\) 使 \(F=-\nabla E\)，则雅可比 \(J_F\) 必须处处对称。算出来是

\[ J_F(\xi)=\beta\,V\,S(p)\,K^\top,\qquad p=\mathrm{softmax}\big(\beta K^\top\xi\big),\quad S(p)=\mathrm{diag}(p)-pp^\top\ \ (\text{对称}) . \]
取 \(p\) 趋于均匀分布，\(S\to\frac1N I-\frac1{N^2}\mathbf 1\mathbf 1^\top\)，对称性要求退化为

\[ \tfrac1N\,VK^\top-\tfrac1{N^2}(V\mathbf 1)(K\mathbf 1)^\top\quad\text{对称} . \]
\(V=K\) 时它自动成立（\(KSK^\top\) 对称）；一般 \(V\ne K\) 时不成立。**所以「注意力层就是 Hopfield 能量下降」这句话，在 untied 的真实注意力层上不能直接用。**

**正确的读法是：能量确定的是打分权重 \(p\)，值矩阵 \(V\) 是加在 \(p\) 之上的一个线性解码器，整个落在能量之外。**Hopfield 步给出 \(Kp\)，注意力输出给出 \(Vp\)——两者共享的是 \(p\)，而不是同一个能量面上的同一步。要给 generic \(K\ne V\)（异联想 / heteroassociative）也配上能量，需要**广义构造**：Krotov–Hopfield 的双层拉格朗日形式（feature 神经元与 memory 神经元各配一个拉格朗日量），或 Universal Hopfield Networks 把联想记忆拆成 similarity → separation → projection 三段、并在 projection 段显式允许用与 similarity 段不同的矩阵。[@src-095a653853][Krotov & Hopfield] [@src-91ba338ca4][Universal Hopfield Networks] **这些构造是存在的，但它们不是本节展示的那个标量能量。**

这一步最容易被跳过，也最容易被夸大。「Transformer 的注意力就是 Hopfield 网络」流传极广，但它成立的强度取决于你允许 \(K\) 与 \(V\) 差多远：**tied 情形下是等式，generic 情形下只是「共享同一个 softmax 打分」的类比。**这个区别不是学究气——它决定了 Ramsauer 的指数容量结论能搬多少过来：**「打分能分辨多少个存储模式」这一半可以搬；「取值端能输出什么」那一半由 \(V\) 决定，与该能量无关。**

    转到第二个视角。目标是证明一层**线性**自注意力（LSA）的前向可以精确实现线性回归的一步梯度下降。设回归损失与其梯度步：

\[ L(W)=\frac{1}{2N}\sum_{i=1}^{N}\lVert Wx_i-y_i\rVert^2,\qquad \Delta W=-\eta\nabla_WL=-\frac{\eta}{N}\sum_{i=1}^{N}(Wx_i-y_i)x_i^\top . \]
注意这里要跨越的鸿沟：梯度下降改的是**权重**，而注意力层能改的只有**token**。下一步是全部构造的枢纽。**也请记住这里已经限定了任务类型：平方损失下的线性回归。**

    做关键的重写：把"更新权重"改写成"更新数据"。

\[ L(W+\Delta W)=\frac{1}{2N}\sum_i\lVert(W+\Delta W)x_i-y_i\rVert^2=\frac{1}{2N}\sum_i\lVert Wx_i-(y_i-\Delta y_i)\rVert^2,\quad \Delta y_i:=\Delta Wx_i . \]
**一步梯度下降的效果，等价于保持权重不变而把所有标签 \(y_i\) 改成 \(y_i-\Delta y_i\)。**鸿沟就此被填平 —— 注意力能做的正是"修改 token"。

    给出构造。token 取 \(e_j=(x_j,y_j)\in\mathbb{R}^{N_x+N_y}\)，线性自注意力（去掉 softmax）为

\[ e_j\ \leftarrow\ e_j+P\,W_V\Big(\sum_{i=1}^{N}e_ie_i^\top\Big)W_K^\top W_Q\,e_j , \]
取分块矩阵

\[ W_K=W_Q=\begin{pmatrix}I_x&0\\0&0\end{pmatrix},\qquad W_V=\begin{pmatrix}0&0\\W_0&-I_y\end{pmatrix},\qquad P=\frac{\eta}{N}I . \]
\(W_K=W_Q\) 的形状让打分只看 \(x\) 分量；\(W_V\) 的形状让"值"恰好是当前模型的**残差** \(W_0x_i-y_i\)；\(P\) 提供学习率。三块拼图各就各位。**请注意这是一个被人手写出来的特解，不是训练自然产生的权重**——「训练会不会找到它」是另一个问题，第 (9) 步才回答。

    验算。先算三个部件：\(W_Qe_j=(x_j,0)\)，\(W_Ke_i=(x_i,0)\)，故 \((W_Ke_i)^\top(W_Qe_j)=x_i^\top x_j\)；而 \(W_Ve_i=(0,\ W_0x_i-y_i)\)。代入：

\[ e_j\leftarrow\begin{pmatrix}x_j\\y_j\end{pmatrix}+\frac{\eta}{N}\sum_{i=1}^{N}\begin{pmatrix}0\\W_0x_i-y_i\end{pmatrix}\big(x_i^\top x_j\big)=\begin{pmatrix}x_j\\ y_j+\frac{\eta}{N}\sum_i(W_0x_i-y_i)x_i^\top x_j\end{pmatrix} . \]
而由第 (5) 步，\(\frac{\eta}{N}\sum_i(W_0x_i-y_i)x_i^\top x_j=-\Delta Wx_j=-\Delta y_j\)。所以

\[ e_j\ \leftarrow\ (x_j,\ y_j-\Delta y_j) . \]
**这正是第 (6) 步的"数据更新"形式。**\(x\) 分量不变（\(W_V\) 左上块为 0），\(y\) 分量被减去 \(\Delta y_j\)。对测试 token \(e_{N+1}=(x_{\text{test}},-W_0x_{\text{test}})\)，输出取负即得 \(\hat y=(W_0+\Delta W)x_{\text{test}}\) —— 一步梯度下降之后的预测。构造完毕。

    补三个必要的细节。**构造不唯一**：只有乘积 \(W_K^\top W_Q\) 与 \(PW_V\) 需要匹配，任意缩放 \(PW_V\cdot s\) 与 \(W_K^\top W_Q/s\) 给出等价结果（这也是论文比对训练权重时必须先做尺度校正的原因）。**多层 = 多步**：\(K\) 层堆叠给出 \(K\) 步梯度下降。**实证匹配**：论文训练一个真正的单层 LSA 去解线性回归，发现优化找到的权重在尺度校正后与手工构造**几乎完全重合**，且损失、余弦相似度、分布外表现全都对齐。

"存在一个构造"和"训练真的会找到它"是两回事，第三条把它们连起来了 —— 这是这篇论文最强的部分，也是它比一般"表达力"结果更有分量的原因。**但要记住这个实证是在 \(N=10\) 量级的玩具线性回归上做的**（见 L1）：它证明的是「在这个任务类里，梯度下降解就是训练的吸引子」，而不是「大模型在做 ICL 时在跑梯度下降」。

    把三种竞争解释的**可区分预测**列出来。这比争论谁对更有用：

隐式梯度下降预测"随 shots 增加呈学习曲线形状、持续缓慢改善、无早期饱和、对预训练未见的新任务有效、不能被压成单个向量"；诱导头（induction head）预测"少数几个 shots 后迅速饱和、只对复制型任务有效"；任务向量预测"极少 shots 即饱和、对库里没有的任务无效、能被压成单向量"。**而实测的 many-shot 曲线要到数百至数千 shots 才见顶**，这与第一种更相容。**注意「相容」不等于「证实」**：曲线形状是一个相当弱的判据，多种机制的混合也可以产生同样的形状（见 L5）。

    用 Gemini 的长上下文把它推到极限。《Many-Shot In-Context Learning》（Google DeepMind, NeurIPS 2024）用 Gemini 1.5 Pro 的 1M 上下文做到**最多 8192 shots**（占满数十万 token）。主要发现：从 few-shot 到 many-shot 在 MATH、GSM8K、GPQA、XSum、BBH、低资源翻译、规划等任务上都有显著提升，且**峰值往往要到数十万 token 才出现**；many-shot 能**覆盖预训练偏见**（few-shot 做不到），效果可与监督微调相当；并提出 Reinforced ICL（用模型自己生成的推理链替代人工标注）与 Unsupervised ICL。一个方法学警告：**next-token prediction loss 不是下游 ICL 表现的可靠指标**。

"要到数十万 token 才见顶"这个曲线形状本身是一个有分量的观察 —— **那不像检索的曲线形状，更像学习曲线的形状。**但它只能**排除**「极少 shots 即饱和」那两种解释，不能**指认**是哪一种学习。

• A1　构造中假设 (W_0) 已知并被硬编码进 (W_V)；实践中它对应”模型的先验解”，小初始化时 (W_0\approx 0)。

• A2　LSA 构造去掉了 softmax。加回 softmax 后只能近似（论文用两个头做一阶近似，需要 (W_{1,KQ}-W_{2,KQ}) 为对角）。

• A3　构造中键值只用 (e_1..e_N)、不含查询 token；论文说明 (W_0\approx 0) 时这个偏离可以忽略。

• A4　Hopfield 的指数容量对球面上的随机模式成立；真实语言的键高度相关，实际容量低得多。

• A5　第 (3) 步把「能量的一步下降」等同于 softmax attention，前提是键与值绑定为同一组模式（(K=V=X)）且 (\beta=1/\sqrt d)。generic (K\ne V) 需要第 (4) 步说的广义构造，不能直接套用这个能量。

• A6　「一层实现一步梯度下降」的完整前提有五条，缺一不可：(i) 线性自注意力，无 softmax；(ii) 权重取第 (7) 步那个特定的分块构造；(iii) 目标是平方损失下的线性回归；(iv) token 按 ((x,y)) 拼接的特定格式给入；(v) (W_0) 被硬编码进 (W_V)。它是一个存在性结果加一个在玩具任务上的实证结果，不是关于一般 ICL 机制的定理。

• L1　**规模鸿沟。**von Oswald 的实验是 (N=10) 的玩具线性回归。从”一层 LSA 能实现一步梯度下降”到”大模型在做 ICL 时在跑梯度下降”是一个巨大的、未被证明的跳跃。后续争议论文指出，在真实模型与非线性任务上，行为与梯度下降的对应会显著变差；von Oswald 自己也只声称”至少在回归问题域内”。因此本节一律不写「ICL 就是梯度下降」，只写「在这一族受限设定下，ICL 可以被精确实现为梯度下降」。

• L2　Hopfield 视角在很大程度上是一个重新表述 —— 就本节展示的形式而言，它没有给出 attention 之外的可验证推论；而且如第 (4) 步所示，它的等式形式还只在 tied key/value 下成立。

• L3　many-shot ICL 的成本极高：8192 shots 意味着每次查询都要 prefill 数十万 token（用组 7 的语言说，这是把工作点推到 roofline 最右端的代价），除非用 context caching，否则经济上不成立。论文自己说明用了 KV caching 来降成本。

• L4　MTOB 的人评由”同一个学过该语言的非母语学习者”打分，他能认出自己的翻译；报告明确要求”scores should be interpreted in context”。

• L5　三种解释很可能同时部分正确，对应不同任务、不同层、不同训练阶段。把其中任何一个当作 ICL 的完整机制都是过度简化；下表的”吻合度”一列应读作相容性，不是判决。

• L6　第 (3) 步的能量–注意力等式只在 tied key/value 下成立，而真实注意力层 (W_K\ne W_V)。因此 Ramsauer 的指数容量结论宜理解为对打分/分辨能力的刻画；把它整体当成”注意力层的记忆容量”是一次外推，需要另行论证。

    **在 tied key/value 前提下**，softmax attention = 现代 Hopfield 网络的一步能量下降（打分侧容量指数于 \(d\)）；generic \(K\ne V\) 时该更新一般不是任何标量能量的梯度步，能量真正确定的只是 softmax 权重 \(p\)，\(V\) 是它之外的线性解码器。**在「线性注意力 + 特定权重构造 + 平方损失线性回归」前提下**，一层自注意力 = 一步梯度下降（有精确构造，且在玩具任务上训练确实会找到它）。两者说的是同一件事：**注意力的一次前向，可以被读成在一个由上下文定义的目标上走一步**——这是一个组织直觉的框架，不是一条已被证明的普适机制。

| | 视角 | 随 shots 增加的曲线形状 | 对预训练未见的新任务 | 能否被压成单个向量 | 与实测的相容性（非判决）

| | 隐式梯度下降 | 类似学习曲线，持续缓慢改善、无饱和 | 应该有效（在学，不是在查） | 不能（(\Delta W) 依赖全部样本） | 与 many-shot 曲线形状最相容

| | 诱导头（induction head） | 少数几个 shots 后迅速饱和 | 只对”复制型”任务有效 | 部分能 | 短 prompt 常规使用的主力

| | 任务向量 | 极少 shots 即饱和 | 无效（库里没有就没有） | 能 | 被 Kalamang 实验排除为完整解释

诱导头的电路机制值得单独一提，因为它与上面的构造形成鲜明对照：**第一层是 previous-token head**，把位置 \(j-1\) 的 token 身份复制到位置 \(j\) 的残差流里（\(W_{QK}\) 只编码相对位置 \(-1\)，与内容无关）；**第二层是 induction head**，查询是"当前 token 是什么"、键是"上一个 token 是什么"，于是匹配到所有前文中「前驱与当前 token 相同」的位置，再把那个位置的**后继**复制出来。整个电路是两个低秩矩阵的组合，**没有任何一步在做优化** —— 它是纯粹的指针追踪。该机制在训练中以一个可见的**相变**出现（损失曲线上的一个小凸起），且与 ICL 能力的涌现时间点重合。[@src-23e5123e7f][Induction Heads]

**Gemini 1.5 的 Kalamang 实验是整个长上下文叙事里最有说服力的一个数据点，而理由恰恰不是它的分数。**

Kalamang 是一种使用者不足 200 人、网上几乎无痕迹的巴布亚语言。给 Gemini 1.5 Pro 一本参考语法书加一份双语词表（MTOB 基准），它能达到与"用同一套材料学习的人类学习者"相当的翻译质量。而在零样本与 5-shot 设定下，三个模型（Gemini 1.5 Pro / GPT-4 Turbo / Claude 2.1）**全部是随机水平**（Gemini 1.5 Pro 人评 0.24 / 0.08 分，满分 6）—— 这确认了模型确实没在预训练里见过它。

它有说服力，是因为它构造了一个**不可能被污染**的对照。在这个干净的设定下，"给它一本语法书，它就学会了"这件事排除了"其实是预训练里见过"这个最常见的替代解释。**但要说准它排除了什么、没排除什么**：它排除的是「任务向量」那种「库里没有就没有」的完整解释（上表第三行），也排除了纯记忆；**它并不能进一步区分「在上下文里做隐式优化」与「在上下文里做某种更强的检索与组合」**——那需要另外的证据，而目前没有。所以正确的措辞是「ICL 确实在上下文里获得了新能力」，而不是「ICL 被证明是梯度下降」。

把它接回组 7：这个能力的价格标签是 \(I_{\text{attn}}=2G/b\)。**「在上下文里学」的经济学，就是 KV cache 的字节数的经济学。**Gemini 的 context caching 定价体系之所以存在，正是因为 many-shot 的那几十万 token 在多次查询间是可复用的 —— 而这一点，恰好是 B15 那类"每序列私有可写记忆"做不到的。

B23 的两个视角回答的是同一个问题的两半：**注意力在算什么？**Hopfield 视角说它在做**检索** —— 一步能量下降，从查询走到最相似的存储模式。梯度下降视角说它在做**学习** —— 一步优化，从先验解走到拟合上下文数据的解。而这两者可以被看成一回事：检索就是在一个由数据定义的能量面上下降一步，学习也是。区别只在于能量面是由"存储的模式"定义的还是由"回归损失"定义的。

**但这个统一必须带上它的条件，否则它就从洞察退化成口号。**第 (4) 步说明：能量那一半只在 tied key/value 下是等式，真实注意力层的 \(V\) 落在能量之外。A6 说明：优化那一半需要线性注意力、特定构造的权重、平方损失的线性回归这一整套前提。**两个视角都是「存在一族设定，使得这个类比是精确的」，而不是「所有注意力层都在做这件事」。**这不是把结论削弱了——恰恰相反，把条件说清楚之后，「哪些条件被违反了会怎样」才成为可研究的问题。

在这个前提下，统一视角有一个值得记住的推论，它把整组公式缝在了一起：**如果把注意力的一层前向读成一步内隐优化，把 Titans 的记忆更新读成一步显式梯度下降（B15），把优化器的动量读成对梯度序列的压缩（B21），那么这三者的差别只是「这步优化发生在哪里、以什么频率」** —— 注意力在激活里做（不改权重，每次前向重来），Titans 在权重里做（改权重，跨 token 累积），优化器在参数上做（跨 batch 累积）。Transformer 的**深度**对应优化步数，**序列长度**对应数据量。Nested Learning 说的正是这件事，只不过它把层级推到了无穷。**这是一个组织直觉的类比框架，它的价值在于提出可比较的问题，而不在于它已被证明。**

而 B16 那条容量约束，在这个视角下也有了新读法：一个固定大小的状态能"学会"的东西，受限于它能表示多少个独立约束。**所以"长上下文该用注意力还是循环"这个工程问题，最终归约成一个认知问题：你要模型在上下文里「学」，还是在上下文里「查」？**Gemini 卖的是后者的精度，而 Kalamang 实验说明它顺带做到了前者 —— 代价写在组 7 的那条斜线上。

**其一，不能写「in-context learning 就是梯度下降」。**成立的是一个受限的存在性结果（A6 的五条前提）加一个玩具任务上的实证（L1）。真实模型、非线性任务上的对应关系在后续工作中显著变差，原作者自己也把结论限定在回归问题域内。可以写的版本是：**「在线性注意力与线性回归这一族设定下，ICL 可以被精确实现为梯度下降；这为理解一般 ICL 提供了一个候选机制，但不是它的完整解释。」**

**其二，不能无条件写「注意力层就是 Hopfield 网络」。**第 (4) 步已经给出反证：generic \(K\ne V\) 时，该更新一般不是任何标量能量的梯度步。可以写的版本是：**「在 tied key/value 下，softmax attention 恰是现代 Hopfield 能量的一步 CCCP 更新；一般情形下两者共享同一个 softmax 打分，而值投影落在能量之外。」**

**其三，不能把 many-shot 曲线形状或 Kalamang 当成机制层面的判决。**曲线形状能排除「极少 shots 即饱和」的解释，Kalamang 能排除「预训练见过」与「纯任务向量」的解释；**两者都不能在剩下的候选机制之间做选择**。上表最后一列因此写作「相容性」而非「吻合度」。

### 交互 6-F · Roofline：把 decode 从访存墙上拉回来要多大 batch

这是本章最该动手拨一遍的一张图。三条折线是三代 TPU 的 roofline
  \(P=\min(P_{\rm peak},\,I\cdot BW)\)，拐点就是脊点 \(I_{\rm ridge}=P_{\rm peak}/BW\)。
  黄点是当前 decode 工作点，它的算术强度只有 \(I=2b/s\)——**只取决于并发数和权重精度，与模型多大无关**。
  把 batch 从 1 拖上去，你会看到点沿着斜坡往右上爬；**要爬到脊点需要的并发数是三位数**，
  而这正是「为什么大模型服务必须堆并发」的全部数学内容。



    TPU 三代 roofline 与 decode 工作点
    拖动并发数与权重精度，看工作点落在哪一侧





    规格取自官方披露：**Ironwood / TPU7x** 4,614 TFLOPS (FP8) · 7,380 GB/s
    （GA 日期以 `REVIEW-03` 终裁的 **2026-03-31** 为准；技术档案里另有 2025-11-06 与 2026-04-22 两说，
    2025-11-06 那篇标题写 GA、正文却写 “coming weeks”，**此处保留分歧记录**）；
    **TPU 8t** 12.6 PFLOPS (FP4) · 6,528 GB/s；**TPU 8i** 10.1 PFLOPS (FP4) · 8,601 GB/s
    （[@src-7fcb28f154]Google Cloud, 2026-04-22；
    **8t/8i 已官宣、截至 2026-07-25 尚未 GA**）。
    工作点用权重项的算术强度 \(I=2b/s\)，忽略 KV cache 读取（那会让强度更低，见 B19 局限）。
    **不同精度的峰值不可直接横比**——Ironwood 那条线是 FP8，第八代两条是 FP4。
    **文字替代**：本图的全部数值在上方 B19 的「历代 TPU 脊点与 decode batch 门槛」对照表里都有，
    脊点 1,930（8t）/ 1,174（8i）与
    基础设施章「TPU 第八代的双 SKU 决策」中的同名论证取值一致。




## 这一章没能回答的问题

把 24 个公式排完之后，剩下的空洞比写进去的东西更值得记住。


  本章上一版在这里写了两句自我批评，**其中一句在 2026 年已经站不住，另一句的措辞把责任归错了地方**。既然本材料要求「更新任何关键数字时回头查有哪些结论建立在它的旧值上」，**那么自谦也要核**——一句过时的「我们没有」和一句过时的「我们有」，错的方式完全一样。

  **① 上一版写「RL 后训练……公开文献里没有一条能用的标度关系」——这句话过强，已改（见下方第 1 条）。**
    到 2026-07 至少有四项工作给出了**局部可操作**的 RL 算力—性能关系。

  **② 上一版写「Chinchilla 与 MoE 接不起来……这是我补不上的一道缝」——判断本身成立，但归因错了，已改（见下方第 2 条）。**
    缝不是本章补不上，**是文献自身尚未收敛**。这两种说法给读者的行动指引完全不同：前者暗示「去查资料就有答案」，后者才是实情。

1. RL 后训练有局部经验规律，但没有可用于前沿规模的统一 law。(C\approx6ND) 描述的是预训练； 2025–2026 的推理模型在 RL 阶段可能烧掉与预训练可比量级的算力 （可核锚点：DeepSeek-R1-Zero 的 RL 约为预训练的 3.75%；o1→o3 与 Grok 3→Grok 4 各自约 10× 跃升）。 而「一条都没有」是错的——至少有四项工作给出了局部可操作的关系： Hilton 等的单智能体 RL 幂律（^[26]arXiv:2301.13442，结构与 Chinchilla 同构，但环境是 Procgen 不是 LLM）； Khatri 等超过 40 万 GPU 小时的系统研究（^[27]arXiv:2510.13786，拟合形式是 sigmoid 而非幂律，并在 8B 上做了 50k→100k GPU 小时的外推验证）； IsoCompute Playbook 的采样算力分配规则（^[28]arXiv:2603.12151）； 以及把预训练损失与 post-RL 性能连起来、能画出算力最优前沿的联合标度律（^[29]arXiv:2607.16097）。 ★缺口的准确形状因此变成：这四项不是同一种 law（一个是幂律、一个是 sigmoid、一个是分配规则、一个是联合前沿）， 且没有任何一项在 ≥100B 激活参数的前沿模型上做过跨模型验证。 所以本章仍然不写 RL 的标度公式——理由从「文献里没有」改成了「文献里有四条互不通约、且都未在前沿规模验证的关系」。

2. **Chinchilla 与 MoE 接不起来——而这道缝是文献自身的，不是本章的。**约束项该填每 token 激活参数是清楚的， 但损失项 (A/N^{\alpha}) 里的 (N) 该填总参数、激活参数、还是某个几何平均，公开文献没有给出统一答案。 ★但必须说清楚「没有统一答案」的确切含义，否则很容易被写成一句更耸动、也更错的话。 常见的错误写法是「三套 MoE 标度律互相矛盾」。它们并不是三个互相矛盾的理论答案，而是三种不同约束下的经验参数化： Clark 等（DeepMind, ICML 2022，^[30]2202.01169）用有效参数量统一，预测 routing 收益随规模递减； Ludziejewski 等（ICML 2024 / 2025，^[31]2402.07871、^[32]2502.05172）以激活参数为主项、把专家数搬进指数； Abnar 等（Apple, ICML 2025，^[33]2501.12370）以总参数为主项、稀疏度以交叉项进入。 Clark 与 Ludziejewski 在「routing 收益随规模如何变化」上方向相反，但这个差异有一个平凡的解释——两者的数据预算设定不同（固定数据 vs compute-optimal 可变数据），并不需要「其中一篇是错的」。 三者各自都能拟合自己的数据，而没有任何一篇在另外两篇的数据上做过交叉验证，最大验证规模分别是几百 B 稠密等效、5B、26B——全都在外推两个数量级。 结论：这是一个开放问题，不是一场理论争论。B5 与 B18 在 MoE 上的那道缝依然在，本章不假装它已经被谁补上了。

3. **Deep Think 的并行思考机制是黑箱。**官方只给了 “parallel thinking” 和 “novel reinforcement learning techniques” 两个短语。B10 能告诉你 MCTS 为什么在 LLM 上做不了，但不能告诉你 Google 实际做了什么。本章对此只标注不推测。

4. 所有 Gemini 侧的对应关系都是「公式 + 公开现象」的匹配，不是内部证据。 roofline 能解释 8i 为什么该那样设计，但不能证明 Google 就是这么想的； B17 能解释 MRCR v2 在 1M 上为什么难，但不能证明 26.3% 就是这个原因造成的—— 而且 Flash 线同口径两个月翻倍这条同厂证据，方向上是削弱 B17 的。 解释力不等于证据。

   单点数据脆弱性登记表

   上面登记的是**「本章答不了的问题」**。这一张登记的是另一类：本章那些已经写成结论、但只靠一组未复现的系数、一个不可观测的参数、一次快照、或一段两三个数量级的外推站着的判断。

   **脆弱不等于错误。**最后一列刻意写成「什么变化会让它需要重估」，而不是「它可能是错的」——前者是可执行的监测项，后者只是免责声明。 对一章公式材料来说这件事尤其重要：公式一旦印在纸上就显得比它的输入更确定，而本章几乎每一条落到 Gemini 的结论，输入端都比公式端软得多。

| | # | 本章的结论 | 它实际建立在什么之上 | 脆在哪 | 什么变化会让它需要重估

| | F1 | B17 的整个机制模型，包括临界规模 (2.6\times10^5) 与「与 128K–1M 区间量级吻合」 | 五个参数无一有公开值，全部为对上量级而选（(d,d_h,\sigma,\rho,\kappa_Q\kappa_K)） | ★本章最脆的一格，而且它自己就能算出自己有多脆：(\kappa_Q\kappa_K) 从 0.02 挪到 0.03，(n_{\rm crit}) 从 (2.6\times10^5) 跳到 (3.7\times10^8)——单个不可观测参数变化 50%，结论跨三个数量级。 本节已自陈「证据强度接近于零」，但它仍然是本章篇幅最大的一节，读者极易把篇幅误读成置信度 | ① Gemini 首次披露注意力结构（若为局部/全局交错，本节把它当 full attention 建模这一步直接作废）；② 出现对 (\kappa_Q\kappa_K) 量级的任何实测；③ 某模型仅靠超长真实文档继续训练就显著抬高 1M 分数（那会让失效边界 ③ 胜出）

| | F2 | MRCR 的三组数：1M 档 26.3%、8 针噪声地板约 15%、Flash 两个月 26.6%→54.0%（B17、表 6.2） | 三份模型卡快照 + 一份开源仓库 README，全部冻结于 2026-07-25 | (a) 模型卡会被静默更新；(b) 15% 是 README 给的估算式（约 (1/\text{针数})）而非实测，本章「真实信号约 11pp」这个说法整体建立在它上面；(c) 「两个月翻倍」依赖两张 Flash 卡针数一致——3.6 Flash 已标 8-needle，若 3.5 Flash 的标注不同，该对比作废 | ① 任一模型卡修订该行；② eval_hub 改变噪声率定义；③ Pro 线在 1M 档首次移动——届时「Pro 线两代未动，更像优先级问题」整段要重写；④ 出现 128K pointwise 值

| | F3 | Chinchilla 的那组系数 (A=406.4,B=410.7,E=1.69)（B5、交互 6-C） | 一篇论文的一次拟合，从未被独立复现；原始 400+ 次训练的三元组至今未公开 | Epoch AI 的复现指出原文报告的置信区间与数据不相容。本章的处置是全程走一般解 (N^\star\propto C^{\beta/(\alpha+\beta)})、不无条件写 (C^{1/2})，因此结构层结论不受影响；但交互图 6-C 的曲线形状仍在用这组数 | ① GDM 公开原始三元组（这一条会一次性终结整个争议）；② 出现第二次独立的大规模 IsoFLOP 复现；③ 本章采用的 (\alpha=0.34,\beta=0.28) 与 Epoch 重拟合的 (\beta=0.3658) 之间的口径差被澄清

| | F4 | 表 6.3 两条新标度律的可用性（data-constrained 的 4-epoch 结论、distillation 的两条件判据） | 验证规模分别是最大 9B 参数 / 900B token 与 143M–12.6B 师生对 | ★要用到本章讨论的万亿参数量级，两者都在外推两到三个数量级。本章已在正文写明「它们比 Chinchilla 更新，但不比 Chinchilla 更可靠」，但表格形式天然让人觉得它们是已确立的结论 | ① 任一 ≥100B 激活参数规模的 multi-epoch 消融公布（若 4-epoch 损失差仍 <1%，外推成立）；② 出现前沿规模的蒸馏对照；③ 任一条在更大规模上被证伪

| | F5 | 「RL 有四条局部 law，但没有可用于前沿规模的统一 law」（章末空洞 1） | 四篇论文，其中三篇可信度 B；且它们分属幂律 / sigmoid / 分配规则 / 联合前沿四种不同形式 | 这一格本轮刚从「一条都没有」改过来——上一版的错误方向是过时的自谦。 新版本的脆弱在另一头：「没有一项在 ≥100B 激活参数上跨模型验证」是一个关于文献覆盖的否定断言，而否定断言会随任何一篇新论文失效 | ① 任一实验室公开 ≥100B 激活参数上的拟合参数；② 任一工作在另外三篇的数据上做交叉验证——届时「四条互不通约」这个说法就要改

| | F6 | 「三套 MoE law 不是互相矛盾的理论答案，而是不同约束下的经验参数化」（章末空洞 2） | 三篇论文的参数化形式对比 + 一个解释（Clark 与 Ludziejewski 的方向差异源自固定数据 vs compute-optimal 可变数据） | 那个解释本身是一个未经检验的调和假说——它听起来合理，但没有任何一篇论文验证过「换成对方的数据设定后方向会反转」。本章用它来避免「三者矛盾」这个更强的错误说法，但不应把它当成已证的和解 | ① 出现同一批数据上同时拟合三式并报告外推误差的工作（这一条同时能终结 F6 与空洞 2）；② Clark 的 (N_{\rm cutoff}\approx900)B 被明确检验

| | F7 | B7 失效边界的收窄版：「验证器便宜」只在挑选环节成立（表 6.4） | 两个 benchmark 的轨迹成本数字（3,000–6,000 条消息 / 6,000 万–1 亿 token；数万美元量级） | 成本数字来自评测方与报道，随模型定价与实现变化很快；「数万美元」尤其是一个会随 token 价格下降而失效的量 | ① 评测方公布新的运行成本；② token 价格大幅下降使「完整轨迹成本」不再是分母大项——那会削弱本节「水位低源于轨迹成本」这个替代解释

| | F8 | roofline 的三个脊点与三个 batch 门槛（B19、交互 6-F） | 官方披露的峰值算力与 HBM 带宽两个数；8t / 8i 已官宣但截至 2026-07-25 尚未 GA | 本章刻意只用算力与带宽、不依赖制程（制程媒体两说、官方无口径），因此比依赖 TCO 的论证稳健；但未 GA 的规格仍可能在量产时调整 | ① 8t / 8i GA 并公布最终规格；② 官方补充片间互联带宽（那会让 B19 缺的第三条 roof 变得可算）

| | F9 | Michelangelo「128K→1M 不衰减」用来动摇「悬崖在 128K 之后」（B17 落到 Gemini） | 一篇 2024 年的论文，测的是 Gemini 1.5、用的是原版 MRCR、画的是累计曲线 | ★三个维度全部与 3.1 Pro 的 8 针 pointwise 不同。本章已写明它只能动摇前提、不能证明衰减在 32K 之前——这个区别在转述中极易丢失 | ① 出现 MRCR v2 的逐 bin 曲线（那会直接给出悬崖位置，同时终结 F1 与 F9）；② Michelangelo 发布覆盖新模型的更新版

| | F10 | 交互 6-B 的两个激活比锚点（GLaM 8.3%、Gemma 4 约 15%） | 两条公开官方数字 | 只有两个点，且都不是 Gemini——本图不含任何 Gemini 参数。它能证伪「(k/E) 是好近似」，不能给出 Gemini 的真实激活比 | ① Gemini 首次披露专家数与 top-k；② Gemma 4 报告修订其激活参数口径（档案内已有 26B vs 25.2B 的自相矛盾，本章回避了总参数）

    表 6.5 · 本章的单点数据脆弱性登记表（**10 条**）。数据冻结于 **2026-07-25**。

      **★本章最深的一处承重点是 F2**：B17 全节、表 6.2、章末空洞 4、以及「Pro 线更像优先级问题」这个本轮新写的判断，**全部压在同一批模型卡快照上**。
      它们看起来是四条独立论证，实际共用三个数字。**其中「Pro 线两代未动」这一条的有效期最短——它会在 Pro 线下一次更新 MRCR 分数的那一天失效。**





  SPEC 要求逐条审计本章的可证伪阈值**有没有锚定在会漂移的快照上**。已知同型失效：**ARC-AGI-3 的 7.78%**（动态 benchmark，四个月后 30.16%）与 **GDPval-AA 的 440 Elo**（动态榜，检验时必须重测榜首）。本章的判据分三类：

  **① 锚定在披露事件上（不漂移，本章质量最好的一类）。**
    「GDM 公开 Chinchilla 原始三元组」「Gemini 披露注意力结构 / 专家数」「8t 8i GA 并公布最终规格」「出现 128K pointwise 值」——
    这些要么发生要么没发生，**含义不随时间改变**。公式章之所以这一类占比高，是因为它的争议大多是「官方没说」而不是「数字在变」。

  **② 锚定在会漂移的快照上（检验时必须重取）。**
    **F2 的三个 MRCR 数**与 **F7 的轨迹成本**。前者是模型卡快照，后者随 token 定价变化。
    **F2 与 ARC-AGI-3 / GDPval-AA 同型**：本章「Pro 线两代未动」这个说法**把一个随时会更新的模型卡数值当成了固定事实**。
    **改法**：检验时重取当日模型卡，**并核对针数标注是否仍一致**（这一条本轮刚吃过一次亏——上一版基于「Flash 未标针数」写的限制，因为模型卡更新而整条作废）。

  **③ ★锚定在否定断言上（这一类是公式章特有的，前几章没有）。**
    **F5 与 F6** 都属于此：「没有任何一项在前沿规模验证过」「没有任何一篇做过交叉验证」。
    **否定断言的失效方式与快照不同——它不会缓慢漂移，而是被任意一篇新论文一次性推翻。**
    它同时还有一个更隐蔽的问题：**它的真假取决于检索的彻底程度，而检索的彻底程度是不可核的。**
    本章的处置是把这类断言的**时间戳与检索范围写进正文**（「截至 2026-07-25 的公开文献」），
    **而不是写成无时间限定的「不存在」**。这也正是本轮更正上一版「RL 一条 law 都没有」时吸取的教训——**那句话在写下的时候可能就已经过时了。**




  主要一手来源
  正文中每条断言都就近给出了可点击的原始链接；下表只汇总本章反复引用的一手材料。
    可信度分级：A 官方一手 / B 权威媒体 /
    C 中文转述 / D 传闻。
  ★混装等级的显示规则：一条脚注若同时装了多个等级的来源，本章同时渲染全部等级的圆点，并按最低的一级来读，
    条目内写明「引用其中哪一部分时以低等级计」。
    只画最高那一级的圆点，等于在视觉层绕过了「可信度只能降不能升」这条纪律。
    本章的脚注绝大多数是单一 A 级的同行评议论文或 arXiv 预印本，需要这样处理的只有 1 条（fn-tpu8：官方规格 A ＋ 制程与代工的媒体报道 B）。




































    ← 总览
    上一章：技术谱系
    下一章：TPU / Pathways / JAX 垂直整合



    Gemini 认知体系全景 · 材料时间边界 2021.01 – 2026.07 · 数据冻结于 2026-07-25



    本章中，正文与推导为可核查的公开内容；**紫色「本质洞察 / 落到 Gemini」**与
    **橙色「批判 / 失效边界」**为作者判断。凡官方未披露的 Gemini 内部参数一律标注为「未公开」，
    外部估算均写明依据。计数口径：一次乘加 = 2 FLOPs。