22,580：从 GPT-2 到 Kimi K3
大模型架构七年进化全解

两万两千五百八十。

这是 GPT-2（2019 年，约 1.24 亿参数）能被装进 Kimi K3（2026 年，2.8 万亿参数）的次数。七年时间，我们把模型做大了 22,580 倍。但故事真的只是"变大"吗？

在这篇工作日志式的长文里，我们会一步一步追溯这些年真正发生的事——你会发现变的东西很多，没变的东西也不少。原文作者沿着"线性注意力 → DeltaNet → Gated DeltaNet → Kimi Delta Attention"这条线性化主线走到了 Kimi K3；本文在完整保留这条主线（含全部代码与推导）的基础上，额外补上了零基础友好的数学学前班、手算示例、参数账本，以及注意力家族（MQA/GQA/MLA）、状态空间模型（Mamba）、MoE 稀疏化、训练与推理优化方法四条支线。读完后，一个几乎不懂 LLM 的人也能搭建起完整的知识地图——而且是真的会算的那种。

01学前班：五块数学积木

LLM 论文里的公式看起来很多，真正反复使用的积木只有五块：向量、点积、矩阵乘法、Softmax、对数。下面每一块都手算一遍——手算过一遍的东西，才是真正学会的东西。

1.1 积木一到五，各手算一遍

积木一：向量不是"一个意思"，而是一组坐标

为什么一个 token 要变成几千个数？因为单个数值很难同时表达"词性、语义、语气、实体、位置"等大量属性。模型给每个 token 一个 \(d\) 维向量；每个维度不一定有能用人话命名的含义，信息通常分布在许多维的组合方向上。

积木二：点积回答"两个方向有多匹配"

两个同维向量逐项相乘再相加，得到一个标量：\(q \cdot k = \sum_j q_j k_j\)。

积木三：矩阵乘法就是"成批点积"

如果 \(A\) 是 \(m \times n\)，\(B\) 是 \(n \times p\)（中间的 \(n\) 必须相同），结果 \(AB\) 是 \(m \times p\)。结果第 \((i,j)\) 项，就是 A 的第 i 行与 B 的第 j 列做点积。

积木四：Softmax 把任意分数变成概率

积木五：对数把"概率很小"变成"惩罚很大"

若正确答案概率是 \(p\)，交叉熵损失是 \(-\log p\)。预测越自信且正确，损失越接近 0；正确答案概率越小，损失越大：

1.2 "预测下一个 token"到底在优化什么

GPT 类模型的训练目标极朴素：给定前面的 token，提高真实下一个 token 的概率。复杂能力并不是另写了一个"理解世界"的损失函数，而是在压缩海量序列规律时逐渐形成的。

先把一句话错开一格

训练时，四个位置可以一起算损失（这就是 GPU 并行训练的由来）；但每个位置只能看自己和左边，不能偷看右边目标。这个约束由第 02 章的"因果掩码"强制执行。

第一行用条件概率链式法则把整段文本的概率拆成每一步；第二行取负对数，把"最大化乘积"变成"最小化求和"，更适合数值计算。

从 token id 到概率：完整流水线

一张总地图：模型每层只做两类混合——注意力类模块在 token 之间搬运信息（跨位置），MLP 类模块在每个 token 内部变换信息（位置内）。本文后面所有的架构创新，都是在替换这两个格子里的东西。

# 省略 batch 维；T=序列长度，d=隐藏维，V=词表大小
X = Embedding[token_ids]              # [T] → [T, d]
for layer in layers:
    X = X + Attention(RMSNorm(X))     # 跨 token 混合
    X = X + MLP(RMSNorm(X))           # 每个 token 内变换
logits = RMSNorm(X) @ W_vocab.T       # [T,d]×[d,V] → [T,V]
prob = softmax(logits, axis=-1)       # 每行成为词表概率
loss = -mean(log(prob[真实下一个token]))

残差连接与归一化：深网络的稳定器

若新分支 \(F\) 暂时没学好，模型至少能沿着 "+x" 的直通路径传递信息与梯度；深层网络因此更容易训练。这就是著名的 Pre-Norm 残差结构。

MLP：两次（或三次）线性变换

原始 GPT-2 使用两层 MLP：先从 \(d\) 扩到 \(d_{ff}\)，过 GELU，再投回 \(d\)。现代模型多用 SwiGLU 三路结构：

\(\odot\) 是逐元素乘法。gate 分支决定哪些扩展维度通过，up 分支提供内容，down 再压回模型宽度。若忽略 bias，三张权重分别含 \(d \times d_{ff}\)、\(d \times d_{ff}\)、\(d_{ff} \times d\) 个参数，总计约 \(3 d d_{ff}\)——这条公式后面会直接解释 Kimi K3 的万亿参数从哪里来（见 11.2 节的完整对账）。

02起点：解剖 GPT-2

要理解后面所有的改进，必须先把基准模型拆到骨头。GPT-2 是一个典型的 decoder-only（仅解码器）架构——今天几乎所有主流大模型（GPT、Llama、Qwen、DeepSeek、Kimi）都属于这个家族。它的完整前向传播用不到 15 行代码就能写完：

def forward(self, idx, pos):        # idx: (b, t) token id；pos: (t,)
    tok_emb = self.transformer.wte(idx)  # (b, t) → (b, t, n_embd)
    pos_emb = self.transformer.wpe(pos)  # (t,) → (t, n_embd)
    x = self.transformer.drop(tok_emb + pos_emb)  # (b, t, n_embd)
    for block in self.transformer.h:
        x = block(x)                     # 12 个 Transformer 块，形状不变 (b, t, n_embd)
    x = self.transformer.ln_f(x)         # 最终 LayerNorm，(b, t, n_embd)
    logits = self.lm_head(x)             # (b,t,n_embd)×(n_embd,V) → (b, t, vocab_size)
    return logits

2.1 从嵌入到输出：一次完整前向

输入文本先被 tokenizer 切成 token 序列（GPT-2 用 BPE，词表约 50,257 个）。每个 token 查表得到一个 768 维向量（token embedding），再加上它所在位置的向量（position embedding）——注意，GPT-2 的位置编码是可学习的绝对位置嵌入，它和 token 嵌入一样是一张待训练的查找表。这一点后来被彻底改变（见 3.2 节）。

嵌入相加后，数据依次流过 12 个结构完全相同的 Transformer 块。每个块放大看是这样的：

class Block(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.ln_1 = LayerNorm(config.n_embd, bias=config.bias)
        self.attn = CausalSelfAttention(config)
        self.ln_2 = LayerNorm(config.n_embd, bias=config.bias)
        self.mlp = MLP(config)

    def forward(self, x):               # x: (b, t, n_embd)
        x = x + self.attn(self.ln_1(x))   # 注意力子层 + 残差连接 → (b, t, n_embd)
        x = x + self.mlp(self.ln_2(x))    # MLP 子层（内部升至 4×n_embd 再降回）→ (b, t, n_embd)
        return x                      # (b, t, n_embd)

2.2 手算一次因果注意力

每个块的核心是因果自注意力（Causal Self-Attention）。它的代码同样短得惊人：

B, T, C = x.size()  # batch、序列长度、嵌入维度；x: (B, T, C)

# 一次线性投影同时算出 q, k, v，再拆成多头
q, k, v = self.c_attn(x).split(self.n_embd, dim=2)  # (B,T,C)→(B,T,3C)，拆成三份各 (B, T, C)
k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)  # (B, nh, T, hs)
q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)  # (B, nh, T, hs)
v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)  # (B, nh, T, hs)，hs = C/nh 为头维

# 注意力分数：每个 query 与所有 key 的点积，除以 √d_head
att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))  # (B,nh,T,hs)×(B,nh,hs,T) → (B, nh, T, T)
att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))  # 因果掩码，(B, nh, T, T)
att = F.softmax(att, dim=-1)  # (B, nh, T, T)，每行和为 1
y = att @ v          # (B,nh,T,T)×(B,nh,T,hs) → (B, nh, T, hs)
y = y.transpose(1, 2).contiguous().view(B, T, C)  # 拼回头部 → (B, T, C)
y = self.resid_dropout(self.c_proj(y))  # 输出投影 → (B, T, C)
return y

浓缩成公式就是：

与其背公式，不如真正手算一次。设投影后已得到三枚 token 的 Q/K/V（二维单头），我们只求第 3 个 token 的输出，即取 \(q_3 = [0,1]\) 与三个 key 分别点积：

因果掩码：训练时也不能偷看未来

对第 \(t\) 行，只允许看 \(1 \dots t\)。未来位置的分数加 \(-\infty\)，经过 Softmax 后权重变成 0：

这使训练能并行计算全部位置，同时保持与逐 token 生成相同的信息约束。并行的是矩阵运算，不是让早期位置看到未来——这是"自回归生成"的数学保证，也是 decoder-only 与 BERT 类 encoder 的分水岭。

多头不是重复算同一件事

每颗头有不同投影矩阵，因而可以学习不同匹配子空间（语法、指代、位置邻近等）。若总隐藏维 \(d = h \cdot d_h\)，拼接后仍回到 d 维，再经 \(W_O\) 混合各头。头的数量与组织方式将在第 03 章成为主角。

二次复杂度从哪里出现

\(QK^\top\) 生成 \(T \times T\) 分数矩阵：T 个 query 每个都和 T 个 key 比较，每次点积成本约 d，所以粗略计算量为 \(O(T^2 d)\)，注意力权重显式存储为 \(O(T^2)\)。这张表感受一下"二次"的恐怖：

2.3 KV Cache：第一个工程妥协

最后一个 Transformer 块输出隐藏状态矩阵后，语言模型头（LM head）把它映射成词表大小的 logits。自回归解码时，每一步只需要最后一个位置的 logits 来采样下一个 token。

这就暴露了 decoder-only 生成的一个天然低效：模型为每一个输入位置都计算了完整表示，但每个解码步只消费最后一个位置的 logits。如果不做任何缓存，生成下一个 token 时所有这些计算都会被原样重做一遍。

KV Cache 来自一个朴素观察：把新生成的 token 接回输入后，之前所有 token 的 key 和 value 投影一字不差——因为因果掩码保证历史 token 的表示不受未来影响。那么把它们的 K、V 向量存下来，下一步只需为新 token 计算 QKV，再让它与缓存中全部历史 K、V 做注意力即可。计算量从每步 \(O(N^2)\) 降到 \(O(N)\)。

这块存储就是 KV Cache。它保留之前 \(N-1\) 个 token 的 K/V 向量，大小为 \(2 \times N \times n_{layer} \times n_{head} \times d_{head} \times 2\) 字节（FP16），随序列长度线性增长，很快就会大到把推理变成显存带宽瓶颈而非计算瓶颈。请记住这句话——后面从 GQA 到 MLA 到线性注意力，几乎整条演化线都是在跟"KV Cache 太大"这件事作斗争。

从 MQA/GQA（少存几份）到 MLA（压缩每份的大小）再到线性注意力（干脆不存列表），七年来的架构创新，全都是在这张表的两端之间找平衡点。

2.4 参数账本：124M 怎么算出来

"参数"就是训练时会更新、推理时要读取的数字。看清每张权重矩阵的形状，参数量不再是厂商给出的神秘总数，而是一笔可以复核的加法账。Dense Transformer 一共四本账：

GPT-2 的配置：约 5 万词表、12 个块、12 个头、768 维嵌入：

vocab_size: int = 50304  # GPT-2 词表 50257，向上对齐到 64 的倍数以利计算
n_layer: int = 12
n_head: int = 12
n_embd: int = 768

合计约 1.24 亿参数。而 Kimi K3 有 2.8 万亿参数——一个 K3 里大约装着 22,580 个 GPT-2。

03补课 I：注意力的家族演化

原文的主线从"线性注意力"直接开讲，但在那之前，工业界其实先走了另一条路：不改注意力的数学，只改它的存储与工程实现。这条支线孕育了 GQA、RoPE、RMSNorm、FlashAttention 等今天所有主流模型的标配，必须补上。

3.1 MHA → MQA → GQA → MLA：一场针对 KV Cache 的围剿

GPT-2 用的是多头注意力（MHA, Multi-Head Attention）：12 个头，每个头有自己独立的 Q、K、V。问题在于 KV Cache——每个头都要为每个历史 token 存一份 K 和 V。12 层 × 12 头 × 2（K和V）× 64 维 × 每 token，长序列下显存爆炸。

演化链条清晰得像教科书：

• MQA（Multi-Query Attention, Shazeer 2019）：所有 query 头共享同一份 K 和 V。KV Cache 直接除以头数（12 倍压缩），解码吞吐大幅提升，但质量有可感知的损失。
• GQA（Grouped-Query Attention, 2023，Llama 2 推广）：折中方案——把 Q 头分成若干组，每组共享一份 K/V。Llama 2 70B 用 \(h=64\) 个 Q 头配 \(g=8\) 组 KV，缓存压缩 8 倍，质量几乎无损。GQA 此后成为 2023–2024 年开源模型的默认配置（Llama、Qwen、Mistral）。
• MLA（Multi-head Latent Attention, DeepSeek-V2, 2024）：换了个思路——不共享 K/V，而是把所有头的 K/V 联合低秩压缩成一个小的潜向量（latent vector）存起来，用时再解压。压缩率比 GQA 更高，质量反而更好。这是 DeepSeek-V2/V3 与 Kimi 系模型的核心技术，第 10.2 节会详细拆解。

3.2 位置编码：RoPE 的胜利

GPT-2 用可学习绝对位置嵌入，有两个硬伤：训练时见过的最长序列就是能力上限，且位置信息与内容信息纠缠在一起。演化路径：

• 正弦位置编码（2017 原始 Transformer）：固定公式生成，无需学习，可外推性稍好，但依然脆弱。
• RoPE（Rotary Position Embedding，苏剑林 2021）：把位置编码成对 Q/K 向量的二维子空间旋转——位置 \(m\) 的 query 旋转 \(m\theta\) 角。Llama 全系、Qwen、DeepSeek、Kimi 全部使用 RoPE，是近年少数"零争议"的技术共识。
• 长度外推补丁：RoPE 直接外推到训练未见的长度会失效，于是有了位置插值（Position Interpolation）、NTK-aware 缩放、YaRN 等一系列"续长"技术，让 4K 训练的模型能用到 128K 甚至更长。
• ALiBi（2022）：不给词嵌入加位置，而是直接给注意力分数加一个与距离成正比的惩罚项，外推性极佳（Bloom 采用）。
• NoPE / 因果位置涌现：另一个有趣发现是，decoder-only 模型即使不加任何位置编码也能学到一定位置感；而第 04 章要讲的线性注意力/RNN 类架构，位置感天然内建于递归结构中。

3.3 归一化与激活：安静的地基

这些改动不性感，但每一个都省下了真金白银：

3.4 FlashAttention：不改数学，改世界

2022 年 Tri Dao 的 FlashAttention 可能是对工业界影响最大的单篇论文。它没有改变注意力的任何数学定义，输出与标准实现逐位等价——它改的是计算在 GPU 上的组织方式。

关键洞察：标准实现的瓶颈不是 FLOPs，而是显存读写（IO）。朴素实现把 \(N \times N\) 的注意力分数矩阵完整物化到 HBM（高带宽显存），再读出来做 softmax、再写回、再读出乘 V——序列 8K 时这块中间矩阵就有数 GB。GPU 的 SRAM（片上缓存）快一个数量级但极小（每 SM 约 200KB）。FlashAttention 的做法：

1. 分块（Tiling）：把 Q/K/V 切成能塞进 SRAM 的小块；
2. 在线 softmax（Online Softmax）：边扫 K/V 块边维护运行中的最大值与归一化因子，一遍扫描完成精确 softmax，永不物化 \(N \times N\) 矩阵；
3. 重计算：反向传播不存注意力矩阵，用到时重新算一遍——多花 FLOPs 省 IO，反而更快。

后续 FlashAttention-2（更好的并行划分）与 FlashAttention-3（针对 Hopper GPU 的异步流水线）继续压榨硬件。记住一个连锁反应：FlashAttention 让"全长注意力"在工程上变得便宜，一度压制了线性注意力的生存空间——直到长序列 + 高并发解码场景下 KV Cache 的带宽瓶颈再次把线性化路线请回牌桌。这正是第 04 章的历史背景。

04线性注意力：把 RNN 请回来

现在回到原文主线。第一条试图从数学上掀掉 \(O(N^2)\) 桌子的路线，是 2020 年的线性注意力（Linear Attention）。

Softmax 注意力在 \(q \cdot k\) 点积之后施加非线性（指数函数），这把每个 query 和每个 key 牢牢耦合在一起——你必须先算出完整的 \(N \times N\) 分数矩阵才能归一化。线性注意力换了个顺序：先对 q 和 k 各自施加一个特征映射（如 ELU+1），再让它们相乘：

这个调换的魔力在于结合律：\(\phi(q)\cdot(\phi(k)^\top v)\) 可以先算 \(\phi(k)^\top v\)——而所有历史 token 的 \(\phi(k_j)^\top v_j\) 可以累加成一个固定大小的 \(D \times D\) 矩阵 \(S\)。于是整件事变成了一个 RNN：每来一个 token，就往状态 \(S\) 里加一点东西；读出时只需一次 \(q \cdot S\) 矩阵向量乘。因果版本可以写成递推：

def forward(self, x, mask=None, cache=None):
    # x: (b, t, d)
    b, t, d = x.shape
    d_head = d // self.num_heads          # 头维 dh = d/h
    qkv = self.qkv_proj(x)                # (b,t,d) → (b, t, 3d)
    q = qkv[:, :, :d].view(b,t,h,d_head).transpose(1,2)      # (b, h, t, dh)
    k = qkv[:, :, d:2*d].view(b,t,h,d_head).transpose(1,2)   # (b, h, t, dh)
    v = qkv[:, :, 2*d:].view(b,t,h,d_head).transpose(1,2)    # (b, h, t, dh)

    k = F.elu(k) + 1          # 特征映射：保证非负，(b, h, t, dh)
    k = k.transpose(-1,-2)    # (b, h, dh, t)
    q = F.elu(q) + 1          # (b, h, t, dh)

    S, z = cache if cache is not None else (0.0, 0.0)  # S: (b,h,dh,dh)；z: (b,h,dh,1)
    S = S + k @ v             # (b,h,dh,t)×(b,h,t,dh) → (b,h,dh,dh)，固定 D×D 不随序列增长
    z = z + k                 # (b,h,dh,1)，归一化项累加

    o = q @ S                 # (b,h,t,dh)×(b,h,dh,dh) → (b,h,t,dh)，一次矩阵向量乘读出
    denom = q @ z             # (b,h,t,1)
    o_scaled = o / denom      # (b,h,t,dh)
    ...
    cache = (S, z)            # 形状恒定，不随 t 增长
    return o_proj, cache      # o_proj: (b, t, d)

代价是什么？表达力。把注意力拆解为三步看最清楚：

1. 让 qk 分数非负——softmax 用指数函数，线性注意力用 ELU+1；
2. 除以分数总和归一化；
3. 对 value 做加权平均。

三步都还在，但第一步的"非负化"函数从指数换成了 ELU+1——这是对 softmax 核的一个低表达力近似。指数函数能制造尖锐的、赢者通吃的注意力分布（精准检索单个 token），ELU+1 造出来的分布则更平、更模糊。实际精度损失取决于架构和任务，但在需要"从长上下文中精确捞出某个细节"的任务上，朴素线性注意力的劣势是实打实的。

05DeltaNet：会改错的白板

有限容量的缓存，必然面临覆盖与干扰。线性注意力里，第 \(i-1\) 个 token 的状态没有自己的槽位——它被加进了同一个 \(D \times D\) 矩阵。新 query 再想精确读回某个早期 token 的独立表示，已经做不到了。

这个"加法"既是效率的来源，也是灾难的来源：用累加而非拼接来更新缓存，缓存才不至于 O(N) 膨胀；但也正是累加让信息互相污染。Schlag 等人在《Linear Transformers Are Secretly Fast Weight Programmers》里把问题说得极为透彻：

"当序列长度超过存储容量，模型就进入了'超容量'运行状态。要在此状态下正常工作，模型应该学会与记忆内容动态交互，有选择地决定保留哪些键值关联、删除哪些。纯粹累加的指令不适合这个目的……向有限记忆无休止地添加新关联， inevitably 会触及极限。"

5.1 先理解：一块联想记忆白板

先看单个关联是怎么存取的。写入 \(S = k^\top v\)（外积）；用同一个 key 读出：\(k(k^\top v) = (kk^\top)v = \|k\|^2 v\)。也就是说，读出的正好是 value 乘以 key 的模长平方——只要把 k 归一化到单位长度（或读出后除以模长），就能无损取回 v。

Q 在这里是一个可学习的指针：\(W_q\) 和 \(W_k\) 读取同一条残差流，某个事实的 query 会指向该事实当初被写入的 key 方向。这套机制与老世纪的 Hopfield 网络一脉相承——Transformer 的注意力本来就是一种现代联想记忆。

5.2 Delta 规则：先擦除，再写入

Delta 规则（Widrow-Hoff 规则的现代化身）的更新逻辑：

1. 先用当前 key 去读缓存：\(v_{old} = k_i S\)，看看这个位置现在存着什么；
2. 算出增量（delta）：想存的新值与旧值之差，乘上写入强度 \(\beta\)：\(u_i = \beta_i (v_i - v_{old})\)；
3. 把增量写回：\(S \leftarrow S + k_i^\top u_i\)。

def forward(self, x, mask=None, cache=None):
    # x: (b, t, d)
    b, t, d = x.shape
    ...
    q = F.normalize(F.silu(q), dim=-1)   # (b,h,t,dh)，单位长度
    k = F.normalize(F.silu(k), dim=-1)   # (b,h,t,dh)，归一化：保证读出无损
    beta = torch.sigmoid(self.w_beta(x)).view(b, 1, t, 1)  # (b,1,t,1)，新增：逐 token 写入强度

    S = cache if cache is not None else 0.0   # (b, h, dh, dh)

    v_old = k @ S                        # (b,h,t,dh)×(b,h,dh,dh) → (b,h,t,dh)，读出这个 key 位置上的旧信息
    u = beta * (v - v_old)               # (b,h,t,dh)，delta：只写"真正新"的部分
    S = S + k.transpose(-1, -2) @ u      # (b,h,dh,t)×(b,h,t,dh) → (b,h,dh,dh)，与之前相同的外积写入

    o = q @ S                            # (b,h,t,dh)×(b,h,dh,dh) → (b,h,t,dh)，读出（不再需要归一化分母）
    o = o.transpose(1, 2).contiguous().view(b, t, d)  # (b, t, d)
    return self.o_proj(o), S             # (b,t,d)；cache S: (b,h,dh,dh)

旧信息被定向移除，新信息写在原处——缓存从"只增不减的流水账"变成了"可以修改的白板"。\(\beta\) 由输入决定（sigmoid 门控），模型自己学会每个 token 该用多大力气改写记忆。

06并行化 DeltaNet：分块的魔术

6.1 问题：prefill 阶段的顺序依赖

推理时逐 token 递归很自然，但训练/预填充（prefill）时如果把 T 个 token 挨个过一遍 delta 规则，GPU 只能干瞪眼：

S = torch.zeros(b, h, dh, dh) if cache is None else cache  # (b,h,dh,dh)
outs = []
for i in range(t):                # 纯顺序循环，T 次小矩阵运算
    k_i = k[:, :, i:i+1]          # (b,h,1,dh)
    v_i = v[:, :, i:i+1]          # (b,h,1,dh)
    b_i = beta[:, :, i:i+1]       # (b,1,1,1)，标量写入强度
    v_old = k_i @ S               # (b,h,1,dh)×(b,h,dh,dh) → (b,h,1,dh)
    u_i = b_i * (v_i - v_old)     # (b,h,1,dh)
    S = S + k_i.transpose(-1, -2) @ u_i   # (b,h,dh,1)×(b,h,1,dh) → (b,h,dh,dh)，写入
    outs.append(q[:, :, i:i+1] @ S)       # (b,h,1,dh)
o = torch.cat(outs, dim=2)        # (b,h,t,dh)

这与标准注意力不同：delta 规则在每个 key 上都要先做一次"读出—修正"，第 \(i\) 步依赖第 \(i-1\) 步修正完的状态，通向并行矩阵乘法的路径一点也不显然。其实哪怕没有 delta 修正，朴素的线性注意力 prefill 也同样是顺序的（\(S\) 逐步累加）。

6.2 分块：两种结合顺序的缝合

出路是分块（chunking）。把序列切成若干长度为 C 的块（实践中 C 常取 64 或 128，因为张量核指令在这个粒度上效率最高，如 NVIDIA 的 UMMA）：

• 块内：按 \(q(k^\top v)\) 的顺序算——先算分数再做掩码加权，即"真注意力"模式，块内复杂度 \(O(C^2)\)；
• 块间：按 \((k^\top v)q\) 的顺序走——每块结束把整个块的贡献折叠进状态 \(S\)，下一块用一次矩阵乘法从状态读出，即"递归"模式。

S = torch.zeros(b, h, dh, dh) if cache is None else cache  # (b,h,dh,dh)
outs = []
for i in range(t // C):                       # 只循环 t/C 次，每次是大矩阵乘
    q_c = q[:, :, i*C:(i+1)*C]          # (b,h,C,dh)
    k_c = k[:, :, i*C:(i+1)*C]          # (b,h,C,dh)
    v_c = v[:, :, i*C:(i+1)*C]          # (b,h,C,dh)

    o_prev = q_c @ S                            # (b,h,C,dh)×(b,h,dh,dh) → (b,h,C,dh)，这一块之前所有历史的贡献
    attn = (q_c @ k_c.transpose(-1,-2)).tril()  # (b,h,C,C)，块内掩码注意力
    o_curr = attn @ v_c                         # (b,h,C,C)×(b,h,C,dh) → (b,h,C,dh)
    o = o_prev + o_curr                         # (b,h,C,dh)

    S_new = k_c.transpose(-1,-2) @ v_c          # (b,h,dh,C)×(b,h,C,dh) → (b,h,dh,dh)，整块折叠进状态
    S = S + S_new                               # (b,h,dh,dh)
    outs.append(o)
o = torch.cat(outs, dim=2)              # (b,h,t,dh)

成本的分解非常优雅：固定部分 \(2Ld^2\)（状态维护，与 C 无关）+ 增长部分 \(2LCd\)（对角线上的分数矩阵）。C = L 时退化为标准注意力（第二项变成 \(2L^2d\)，二次）；C = 1 时就是纯线性注意力。中间的 C 用一点点块内计算换取硬件利用率——纯 FLOPs 上 C=1 最便宜，但墙钟时间未必：GPU 只有在工作能映射到大块矩阵乘时才跑得快。

6.3 把 delta 修正塞进分块：WY 重参数化

把同样的分块思路直接套到 delta 规则上会遇到障碍：每个 key 的修正量依赖当时的状态，而分块并行要求块内所有修正一次性算完：

v_old = k_i @ S               # (…,1,dh)×(…,dh,dh) → (…,1,dh)
u_i = b_i * (v_i - v_old)     # (…,1,dh)，每个 u_i 都依赖前面所有修正后的 S

我们需要按顺序经过每一个中间状态，才能算出该减去的量——不做数学重参数化就没法并行。作者们的做法是把递推

展开后发现：\(S_T\) 可以写成初始状态左乘一串 \((I - \beta k k^\top)\) 的乘积，再加上各 \(v k^\top\) 项的加权和——这正是 WY 表示（数值线性代数中 Householder 变换乘积的紧凑形式）。修正量 \(u\) 可以通过对一个 C×C 下三角矩阵做前代法求逆一次性解出。从递推到展开式的完整四步推导见附录 B；这里直接落到代码——分块代码一次算出整块 C 个 delta：

def chunk_delta_rule_forward(Q, K, V, beta, C):
    # Q,K,V: (L, d)；beta: (L,)；C: 块长
    L, d = Q.shape
    # 分块
    Q, K, V = map(lambda x: x.reshape(-1, C, d), [Q, K, V])  # 各 (L/C, C, d)
    beta = beta.reshape(-1, C)            # (L/C, C)
    K_beta = K * beta.unsqueeze(-1)       # (L/C, C, d)
    V_beta = V * beta.unsqueeze(-1)       # (L/C, C, d)

    # 向量化前代法：求下三角矩阵 (I + 严格下三角) 的逆
    T = -(K_beta @ K.t()).tril(-1)        # (L/C, C, C)，严格下三角
    for i in range(1, C):
        T[i, :i] = T[i, :i] + (T[i, :, None] * T[:, :i]).sum(-2)
    T += torch.eye(C)                     # (L/C, C, C)，下三角、对角为 1
    W = T @ K_beta        # (L/C,C,C)×(L/C,C,d) → (L/C, C, d)，修正后的 key
    U = T @ V_beta        # (L/C, C, d)，修正后的 value（含全部 delta）

    # 分块并行主循环
    S = torch.zeros(d, d)                 # (d, d)
    O = torch.empty_like(V)               # (L/C, C, d)
    for i in range(L // C):
        q_i, k_i, w_i = Q[i], K[i], W[i]  # 各 (C, d)
        u_i = U[i] - w_i @ S              # (C,d) − (C,d)×(d,d) → (C, d)，整块的修正量一次算完
        o_inter = q_i @ S                 # (C, d)，历史贡献（递归模式）
        A_i = (q_i @ k_i.t()).tril()      # (C, C)，块内注意力分数
        o_intra = A_i @ u_i               # (C,C)×(C,d) → (C, d)，块内贡献（注意力模式）
        S += k_i.t() @ u_i                # (d,C)×(C,d) → (d, d)，更新状态
        O[i] = o_intra + o_inter          # (C, d)
    return O.reshape(L, d)                # (L, d)

至此我们来到第一个里程碑式的对比——标准多头注意力 Transformer vs DeltaNet Transformer：

07补课 II：状态空间模型与 Mamba

下一章要讲的 Gated DeltaNet 里有一半血统来自 Mamba。所以在讲"遗忘门"之前，必须先认识线性注意力的平行宇宙——状态空间模型（State Space Models, SSM）。

7.1 从控制论到深度学习：SSM 的数学基础

状态空间模型是控制论的老古董：一个连续时间的线性时不变系统

其中 \(x(t)\) 是输入信号（LLM 中是 token 嵌入的一个维度），\(h(t) \in \mathbb{R}^N\) 是隐状态，\(A\) 是状态转移矩阵，\(B\)、\(C\) 是输入/输出投影。要处理离散的 token 序列，需要用零阶保持（Zero-Order Hold）离散化：

离散化后的递推就是一个线性 RNN——每步成本与序列位置无关，这就是 SSM 实现 \(O(L)\) 总复杂度（而非 \(O(L^2)\)）的原因。它和线性注意力的 \(S_t = S_{t-1} + k_t^\top v_t\) 神似并非巧合：两者都是"用一个固定大小的隐状态压缩全部历史"，只是方言不同。

SSM 家族的关键节点：

• S4（Gu et al., 2021）：第一个能在超长序列上打赢 Transformer 的 SSM。核心是用 HiPPO 矩阵初始化 \(A\)（一种数学上最优的"历史压缩基"），并用对角化 + 卷积技巧实现并行训练。但 S4 的转移矩阵是固定的——不随输入变化，如同一台不会根据内容调整的记忆机器。
• Mamba（Gu & Dao, 2023）：让 \(B\)、\(C\) 和离散化步长 \(\Delta\) 全部变成输入的函数——"选择性（selective）"。模型可以按内容决定这一步是认真记还是忽略。代价是失去了卷积并行形式，于是配套发明了硬件感知的并行扫描（parallel scan）算法，在 SRAM 里完成递推。Mamba 在语言建模上第一次以线性时间架构逼平同尺寸 Transformer。
• Mamba-2 / SSD（2024）：揭示了 SSM 与线性注意力的严格对偶——标量门控的 SSM 就是"带遗忘门的线性注意力"。这一洞见统一了两个平行宇宙，也直接铺平了 Gated DeltaNet 的道路（下一章）。

7.2 同一条赛道上的其他选手

08Gated DeltaNet：学会遗忘

回到主线。DeltaNet 给了我们精确修改缓存的能力：每来一个携带新事实的 key，就能读出该位置旧信息并定向替换。但它有一个盲区——

它只能遗忘"有替代品的关联"。换话题时想清空一批旧记忆？想让不重要的事实随时间自然衰减来腾地方？Delta 规则做不到：它的橡皮擦一次只能擦一个 key 对准的那一小块。

反过来，如果我们做的是纯累加线性注意力，加"遗忘"反而简单——只需要一个控制遗忘的标量参数：

S_old = cache                          # (b,h,dh,dh)
S_new = k @ v                          # (b,h,dh,t)×(b,h,t,dh) → (b,h,dh,dh)
# cache = S_old + S_new          # 原来的纯累加
cache = alpha * S_old + S_new    # alpha: (b,1,t,1) 标量门 → (b,h,dh,dh)，先衰减旧状态再全强度写入

这正是 Mamba-2 的贡献：先衰减旧缓存，再全量写入新内容，防止状态无界膨胀。但统一衰减有个明显缺陷——不区分关联的重要性。模型若想忘掉某个特定关联，所有关联都得跟着等比例变旧。而 Delta 规则恰好相反：能定点更新单个事实，却无法让其余事实批量衰减。

Gated Delta 规则 = Mamba 的门控 × Delta 规则的精准。引入参数 \(\alpha_t\)：\(\alpha = 1\) 时退化为纯 Delta 规则；\(\alpha = 0\) 时清空记忆。更新式：

实现沿用第 06 章的 WY 重参数化，数学几乎不变，只多了一个 0 到 1 之间、由数据决定的标量来控制上一状态的衰减。难点仍在工程：分块并行形式里需要处理累积衰减——

09KDA 与 Kimi Linear

到这一阶段，研究者们开始尝试混合架构——在同一个模型里交错使用多种注意力形式，比如 Gated DeltaNet 与 Mamba 混搭，或线性层与全注意力层混搭。2025 年的 Kimi Linear 把这条路推到了一个标志性结论：

9.1 KDA：细粒度门控

Kimi Delta Attention（KDA）对 Gated DeltaNet 的关键改进，是把遗忘从标量升级为逐通道向量：不再用一个 α 统一衰减整个状态矩阵，而是为每个特征通道学习独立的衰减率。

更新规则骨架不变，但代码里多了一次 reshape：

细粒度门控不是简单地"加参数"。它有明确的数学职能：给容量有限的记忆体装上分级回收制度——每个通道独立的衰减率，等价于让模型在特征空间里做软性的记忆分片管理。这正是第 05 章"超容量混叠"问题的工程化解法。

9.2 Kimi Linear 的完整配方

与 DeltaNet Transformer 并排对比，Kimi Linear 引入了三大变化：

1. 混合架构：交错插入 MLA（Multi-head Latent Attention）层——3 层 KDA 配 1 层全注意力；
2. MoE 替换 MLP：前馈网络换成混合专家层；
3. α 投影扩容：通过 alpha 投影给 DeltaNet 机制增加容量（即上面的细粒度门控）。

MLA 和 MoE 的细节放在第 10 章展开。这里先强调原文的一个重要论点：这不是盲目堆料。每一处新增容量都有具体的数学目的——逐通道 α 给的是记忆衰减的精细控制；周期性 MLA 补的是线性状态必然丢失的精确检索；MoE 加的是知识容量而不加每 token 的计算量。

Scaling law 依然有效，但容量必须加在正确的位置、以系统能消化的形式。这条演化线上的每个架构，都是在为前一个系统的某个具体缺陷定向扩容。

10补课 III：MoE 与 MLA 深解

Kimi Linear 和 Kimi K3 的两根支柱——MoE 与 MLA——在原文里只是一笔带过。但它们是 2024–2026 年大模型军备竞赛的主战场（DeepSeek 的崛起几乎全靠这两样），值得各自一节。

10.1 MoE：稀疏化的艺术

回顾第 02 章的参数量分解：GPT-2 里约三分之二的参数在 MLP。MLP 被认为是模型的"知识仓库"（注意力负责路由信息，MLP 负责存储事实）。于是有个诱人的想法：把 MLP 复制很多份，但每个 token 只用其中几份——参数量（知识容量）暴涨，每 token 计算量几乎不变。这就是混合专家（Mixture-of-Experts）。

关键设计点与演化史：

• 起源：Shazeer 等人 2017 年的 Sparsely-Gated MoE（LSTM 时代！），2021 年 Google 的 Switch Transformer（简化为 Top-1 路由）与 GShard 把 MoE 带上万卡规模。
• 负载均衡：路由器容易"嫌贫爱富"——少数专家被疯狂选择、其余饿死，训练崩溃。经典解法是辅助损失（auxiliary load-balancing loss）强制均匀，但它会伤害模型质量；DeepSeek-V3 开创了无辅助损失路线：给每个专家一个动态偏置项，只影响路由选择、不进入梯度，均衡与质量兼得。
• 细粒度 + 共享专家（DeepSeekMoE, 2024）：把专家切得更小、数量更多（提升组合灵活性），并设置若干共享专家处理所有 token 的通用知识，路由专家只学专精知识——缓解知识冗余。Kimi K3 的 898 专家（2 共享 + 896 路由）正是这一思想的超大号版本。
• 开源引爆点：Mixtral 8×7B（2023）证明中型 MoE 也能吊打同档稠密模型；此后 DeepSeek-V3（671B/激活 37B）、Qwen3-MoE、Kimi K2（1T/激活 32B）把 MoE 变成前沿模型默认形态。
• 代价：显存必须装下全部专家（参数不减），训练通信复杂（专家并行 AllToAll），小 batch 推理时专家利用率低。MoE 省的是 FLOPs，不是显存。

10.2 MLA：把 KV Cache 压成精华

第 3.1 节说过 MLA 是 KV Cache 围剿战的最新武器，现在拆开它。GQA 的思路是"让 Q 头共享 K/V"；MLA（DeepSeek-V2, 2024）的思路更激进：把所有头的 K、V 联合低秩压缩成一个潜向量 \(c_t\)，只缓存它，用时再解压出各头的 K/V。

再叠加多头潜注意力对"头间冗余"的利用，MLA 做到了一个反常的结果：缓存比 GQA 小得多，效果却比 MHA 还好。

11Kimi K3：两万倍的终点（暂时）

所有铺垫到此汇合。Kimi K3 的语言骨干就是放大版的 Kimi Linear：包含 23 个四层大循环（macrocycle）——每个大循环里 3 层用 Kimi Delta Attention，第 4 层用 MLA；第 1 层用稠密前馈网络，其余全部换成潜空间 MoE。

相比 Kimi Linear，改动清单初看不起眼：

• 规模大幅增长（至 2.8T 参数）
• 每 12 层一次 Blockwise AttnRes（第 12 章详解）
• MLA 的 query LoRA 与输出门控
• 潜空间 MoE
• SiTU 激活函数
• Gated MLA

分工原则一如既往：KDA 提供恒定状态的递归记忆，周期性 MLA 层保留对上下文的全量 softmax 检索。一张简图统领全模型：

11.1 三个直接的变化：Gated MLA、潜空间 MoE、SiTU

Gated MLA：决定 MLA 检索出的特征有多少能进入残差流——用输入投影出一个门，与注意力输出逐元素相乘。本质是给"精确检索通道"也装上水龙头：检索虽准，但该放多少信息进主干，由上下文决定。

潜空间 MoE：传统 MoE 里，路由器用点积相似度把每个 token 发给若干专家。Kimi K3 共 898 个专家：2 个共享专家处理所有 token，剩余 896 个中由路由器为每个 token 选出 16 个。K3 的进一步创新是让专家在压缩的潜空间中工作：

SiTU 激活：K3 还更换了专家内的激活函数。不再走"升维投影 → SiLU → 与门逐元素乘 → 降维"的老路，而是用 SiTU：

d = x.shape[-1] // 2                              # x: (..., 2d)，前半 gate、后半 up
gate = x[..., :d].to(torch.float32)               # (..., d)
up = x[..., d:].to(torch.float32)                 # (..., d)
situ_a = self.beta * torch.tanh(gate / self.beta) * torch.sigmoid(gate)  # (..., d)
if self.linear_beta is not None:
    up = self.linear_beta * torch.tanh(up / self.linear_beta)            # (..., d)
return (situ_a * up).to(x.dtype)                # (..., d)

注意 tanh 项里有个可学习的 \(\beta\)：门控的饱和区间变成了可学习的，模型可以按层调节激活的"软硬"程度。

剩下的改动：query LoRA、输出门控、AttnRes

MLA 的 query 侧加 LoRA 低秩适配、输出加门控，以及每 12 层一次的 Blockwise Attention Residuals。AttnRes 只带来约 2% 的推理延迟，但换来两个重要收益：对早期表示的选择性检索（缓解残差稀释与隐藏状态数值增长），以及 1.25 倍的计算优势（等效算力下更强）。

最后一点值得停下来体会：AttnRes 和 MLA 从不同方向解决同一个底层限制。KDA 层状态恒定，必然丢弃信息；MLA 从序列维度（token 上下文）做无损检索补位，AttnRes 从深度维度（早期层的表示）做选择性检索补位。一个补横向记忆，一个补纵向记忆。

11.2 账本：1T 怎么变成 2.8T

第 02 章我们算了 GPT-2 的 124M，现在用同一套方法给 K3 对账。先回答一个常见的困惑：K3 的层数并没有比 K2 多几倍，参数怎么从 1T 涨到了 2.8T？答案藏在 MoE 的三项乘积里：

12AttnRes：跨深度的注意力

（原文此节致谢 @chloey3k 的协助。）每次前向，输入穿过一叠层——每层是一个注意力块（KDA 或 MLA）加一个 MLP/MoE 块。传统上，每层的输入都是原始嵌入与之前所有层输出的等权求和：

其中 \(h_i\) 是第 i 层输入，\(h_1\) 是当前 token 的嵌入，\(f_i(h_i)\) 是第 i 层输出。问题在于：没有选择性。不同类型的层收到同一份"大杂烩"状态，哪怕它们想加权不同的历史；且由于递推是纯加法的，越靠后的层越要学出更大的输出才能影响累积残差——这既造成"残差稀释"（早期信息被淹没），也导致隐藏状态数值持续增长、训练不稳。

AttnRes 的做法：不再一视同仁，而是给求和式每一项乘上专门权重：

每个权重 \(\alpha_i\) 由 query-key 点积算出：query 按层学习，key 和 value 来自更早的残差流状态；分数归一化到和为 1，再加权组合。模型因此不必只条件于紧邻的前一层——每层都能用学出来的 query，从整个深度历史中检索对当前计算最有用的表示。这是把"注意力"从序列维度（token 之间）推广到了深度维度（层与层之间）。

在块粒度上应用同一思想：一个"块"是 12 个解码层内注意力与 MLP 输出的逐元素累加，作为单个深度表示存下来，供后续 AttnRes 混合。每层都做残差注意力太贵，只在固定块边界做能以很小代价捕获大部分收益——K3 里每个边界相隔 12 层，23 个四层大循环共产生 8 个 AttnRes 块，并提升了推理速度。

下面这段可能是 block_attn_res 函数里最重要的部分：

V = torch.stack(blocks + [partial_block])       # [N+1, B, T, D] 全部历史块
K = norm(V)                                     # [N+1, B, T, D]，归一化后用于打分
logits = torch.einsum('d, n b t d -> n b t', proj.weight.squeeze(), K)  # [N+1, B, T]，每个历史块一个分数
h = torch.einsum('n b t, n b t d -> b t d', logits.softmax(0), V)        # softmax 沿块维 → 加权和 (B, T, D)
return h                                        # (B, T, D)

四行代码：堆叠所有历史块 → 归一化后用一个学习向量打分 → 在"块"这个维度上做 softmax → 加权混合。注意 softmax 是沿第 0 维（块维度）做的——竞争的对象不是 token，而是深度。

13补课 IV：改变战局的优化方法

架构只是故事的一半。过去七年里，真正让 LLM 从实验室走向亿万用户的，还有一批不改变模型形态、却改变成本曲线和能力上限的方法。按训练、推理、对齐三条线梳理。

13.1 训练侧：把每一度电花在刀刃上

Scaling Laws 与 Chinchilla（2020–2022）

OpenAI 2020 年的 scaling law 论文证明：损失随参数、数据、算力呈平滑幂律下降——能力可以预测，这给了行业"敢烧钱"的底气。但 DeepMind 2022 年的 Chinchilla 纠正了一个广泛错误：此前模型普遍"太大、喂太少"；最优配方是每个参数配约 20 个 token。700 亿的 Chinchilla 吊打 2800 亿的 Gopher。此后 Llama 时代干脆"超量喂食"（小模型吃几万亿 token），因为推理成本才是长期大头。这条思想脉络一直延续到今天：先定推理预算，再倒推训练配方。

优化器：Adam → Muon

AdamW 统治了八年。2024 年 Keller Jordan 的 Muon（用于 NanoGPT 竞速）以"对隐藏层权重矩阵做 Newton-Schulz 正交化更新"的思路，在多项基准上把样本效率提升约 2 倍；Moonshot 将其扩展到大模型训练（Kimi K2 使用带 QK-clip 的 MuonClip），Muon 由此进入一线武器库。embedding 与输出头等仍用 Adam——混合优化器成为新常态。

数值精度与系统

• BF16 混合精度（2020+）：训练标配；FP16 的溢出毛病被 BF16 的大动态范围治好。
• FP8 训练（DeepSeek-V3, 2024）：首次在超大规模上验证 FP8 混合精度可行，配合逐块缩放，训练成本再砍一刀。
• 并行策略：数据/张量/流水/专家/序列并行的组合学（Megatron、ZeRO、FSDP）——万卡集群的有效算力利用率（MFU）从 30% 一路卷到 50%+。
• 数据配方：去重、质量过滤、领域配比、退火（annealing）、合成数据——业内共识是"数据质量与配比的贡献不低于架构"，只是各家秘方极少公开。

13.2 推理侧：吞吐量的战争

训练一次性花钱，推理性命攸关地天天花钱。这一战线的主角：

13.3 对齐与推理：RL 的第二春

RLHF 时代（2022–2023）

InstructGPT/ChatGPT 的三段式——监督微调（SFT）→ 训练奖励模型（RM）→ PPO 强化学习——让模型从"会续写"变成"会听话"，是 LLM 产品化的关键一跃。但 PPO 训练又贵又脆，于是 DPO（2023）用闭式解直接对偏好数据做分类式优化，免去了奖励模型与在线 RL，一度成为开源社区标配。

推理模型时代（2024– ）

OpenAI o1 揭示了新 scaling 维度：测试时算力（test-time compute）——让模型生成长思维链（CoT）再作答，数学/代码能力陡增。DeepSeek-R1（2025）把路径开源化：用 GRPO（组相对策略优化，免去 value 网络）对"可验证奖励"（数学答案对不对、代码过不过测试）直接做大规模 RL，涌现出自我反思与长链推理——RLVR（可验证奖励强化学习）成为后训练的新主菜。此后 Kimi k1.5、Qwen3 等全部跟进，"预训练 scaling + RL scaling + 测试时 scaling"三条曲线并行。

参数高效微调

LoRA（2021）冻结主干、只训低秩旁路矩阵，把微调成本砍掉几个数量级；QLoRA（2023）叠加 4bit 量化，让单卡微调 65B 成为现实。LoRA 的思想还以"MLA query LoRA"等形式回流进主干架构（见第 11 章）——低秩，是贯穿本书的隐藏主题之一。

14全景时间线 2017–2026

15总结：规模之外

至此，从 GPT-2 到 Kimi K3 的旅程走完了。

核心变化从来不是规模本身。每一步架构演进，改变的都是三件事之一：模型存储什么、如何更新这些状态、以及如何检索那些固定大小状态留不住的信息。

Kimi K3 把四种机制缝合为一个系统：恒定状态的递归记忆（KDA）、周期性的 softmax 精确检索（Gated MLA）、稀疏的专家容量（潜空间 MoE）、跨深度的选择性残差访问（AttnRes）。每一份新增的容量都被花在有明确职能的地方。

最后，给几乎零基础起步、一路读到这里的你一张最小知识地图：

• 骨架没变：嵌入 → N × (注意力 + FFN + 残差) → LM head。七年只动了内脏。
• 主线矛盾：KV Cache（无损但无限）vs 固定状态（有界但有损）。全部线性化工作都在逼近"固定状态做出无损检索的效果"，最终答案是混合。
• 记忆三操作：写入（外积）→ 定点修改（Delta 规则）→ 衰减（门控）；KDA 把衰减细化到逐通道。
• 效率三杠杆：MoE（稀疏参数）、MLA（压缩缓存）、FlashAttention/分块/WY（IO 与并行）。
• 能力三曲线：预训练 scaling、RL scaling（GRPO/RLVR）、测试时 scaling。

下一次当你看到"某某新模型发布"时，试着问自己三个问题：它的记忆存在哪？它如何决定遗忘？它的容量加在了什么地方？——答案大概率就藏在这篇文章讲过的某条演化线上。

A附录 A：Softmax 数值稳定性与 Online Softmax 证明

A.1 为什么需要减去最大值

直接计算 \(e^{x_i}\) 的问题是：当 \(x_i\) 较大时，\(e^{x_i}\) 会溢出 FP16/FP32 的表示范围（FP16 在 \(x > 11\) 左右就溢出了）。设 \(m = \max(x_1, \ldots, x_n)\)，数值稳定的 Softmax 为：

为什么等价？分子分母同除 \(e^m\)：

减去 \(m\) 后，最大指数为 \(e^0 = 1\)，不会溢出；最小的指数 \(e^{x_{\min} - m} \approx 0\)，不影响求和。

A.2 Online Softmax 的正确性证明（归纳法）

B附录 B：Delta 规则重参数化推导

DeltaNet 的循环更新：

这个推导还揭示了一个优美的几何画面：每一步 delta 更新，都是让状态矩阵在一个由当前 key 张成的方向上做一次"受控反射"——擦除该方向上的旧投影，写入新值。记忆的编辑，原来是几何变换的复合。