线性注意力与 SSM：两条技术路线的完整推导

线性注意力和 SSM（State Space Model，状态空间模型）是序列建模的两条技术路线，也是后来 KDA/GDN/DeltaNet 一族模型的两个源头：线性注意力贡献了「外积记忆状态 + 结合律」，SSM 贡献了「衰减门 + 递推骨架」。本文把这两条路线的计算过程完整推一遍，每步都有推导、数值验算和工程上的理由。

0. 为什么要固定大小的记忆状态

标准 softmax 注意力在生成文本时，必须把每个历史 token 的 Key 和 Value 都存下来(KV cache)——因为每生成一个新 token，都要和前面所有 token 重新算一遍注意力。序列越长，这笔账越贵：

开销	softmax 注意力(KV cache)	固定状态（线性注意力一族）
解码显存	$O(n \cdot d)$（全部历史的 KV 都得缓存）	$O(d^2)$（一个固定矩阵 S，与 n 无关）
单步解码	$O(n \cdot d)$（扫全部历史）	$O(d^2)$（更新 S + 读出，两次矩阵乘）
预填充	$O(n^2 d)$	$O(n d^2)$
上下文长度翻倍	显存、延迟一起翻倍	完全不变

（单头视角，d 为特征维度。）

几十万 token 的上下文就能把 KV cache 撑到几十 GB。想摆脱这笔账，就得把「全部历史的 KV」压缩成一个固定大小的状态，而且这个状态要会写、会改、会忘——两个源头各给出了一半答案：线性注意力先把固定状态造出来，SSM 教会它怎么遗忘。

---

1. 路线一：线性注意力——两个前提，缺一不可

线性注意力能成立，靠的是两件事：去掉 softmax 的非线性和让 Q/K 先结合掉。更准确地说，这是同一枚硬币的两面——softmax 必须作用在耦合后的 $QK^\top$ 上，它既是非线性的来源，也是耦合的来源；把它换成可分离的 $\phi(q)^\top\phi(k)$，非线性和耦合一起消失，结合律才重新可用。后面 KDA 一族的全部推导都建立在这个前提上，值得把两个条件一个一个讲透。

1.1 前提一：去掉 softmax，结合律才可用

先看没有 softmax 的裸注意力 $\mathrm{Attn}(Q, K, V) = (QK^\top)V$，复杂度账本：

括号化	计算路径	复杂度	主导项
$(QK^\top)V$	先算出 $n \times n$ 矩阵，再乘 V	$O(d\cdot n^2) + O(n\cdot nd) = O(dn^2)$	n（平方）
$Q(K^\top V)$	先算 $K^\top V \in \mathbb{R}^{d \times d}$（与 n 无关），再左乘 Q	$O(n\cdot d^2) + O(d\cdot nd) = O(nd^2)$	d（线性）

同一个数学式，两种括号化，复杂度差一个 n 的幂——这就是结合律的诱惑：矩阵乘法满足 $(AB)C = A(BC)$，先算哪边是自由的。裸注意力（线性代数层面）本来就能线性化。

那 softmax 挡在哪？ 标准注意力是 $\mathrm{softmax}(QK^\top)V$，softmax 在 $QK^\top$ 之后、乘 V 之前介入，并且它是行内非线性：第 i 行（第 i 个 query 对所有 key 的打分）必须整体过 $e^{x_i}/\sum_j e^{x_j}$——指数逐项非线性 + 行内归一化耦合。两个性质各堵死一条路：

1. 非线性破坏结合律：softmax 不是线性算子，$\mathrm{softmax}(QK^\top)V \ne Q\,\mathrm{softmax}'(K^\top V)$，中间结果没法先合并；$n \times n$ 矩阵必须先完整算出来；
2. 归一化引入全局耦合：分母 $\sum_j e^{q_i \cdot k_j}$ 依赖该行所有 n 个 key，哪怕只想算一个 query 的输出，也得先把整行算完——信息在 key 维度上全局耦合，没有可以「先结合掉」的独立块。

所以平方复杂度不是矩阵乘法的错，是 softmax 的作用位置的错：它非要等 Q 和 K 耦合完才动手。要线性化，就得把这个非线性从耦合点上搬走。

1.2 前提二：把非线性提前到 Q 和 K 各自身上

搬法就是核化(kernelization)。把注意力抽象成通用相似度函数 $\mathrm{sim}(q, k)$——它不必是 softmax 的指数，多项式相似度、RBF 核都属此类。数学依据是核技巧：只要 sim 非负（Mercer 条件），就存在特征映射 $\phi(\cdot)$ 使

$$\mathrm{sim}(q, k) = \phi(q)^\top \phi(k)$$

注意这个形式的本质：非线性被吸收进 $\phi$，分别作用于 q 和 k 各自身上，相似度本身变成线性的内积。softmax 的 $e^{q \cdot k}$ 作用在耦合后的标量上；核化的 $\phi(q)^\top\phi(k)$ 让 q 和 k 各自先做完所有非线性变换，最后只留一次线性内积。

线性注意力取 $\phi(x) = \mathrm{ELU}(x) + 1$(Katharopoulos et al. 2020)。先把 ELU（Exponential Linear Unit，指数线性单元）本身说清楚，它是个分段函数：

$$\mathrm{ELU}(x) = \begin{cases} x & x > 0 \\ e^{x} - 1 & x \le 0 \end{cases}$$

• 正数区：原样输出（和 ReLU 一样）;
• 负数区：输出 $e^x - 1 \in (-1, 0)$，一条平滑曲线，越负越接近 -1 但永远不到 -1。

所以 $\mathrm{ELU}(x) + 1$ 的取值范围是 $(0, \infty)$：恒正。算两个具体值感受一下：$x = 0$ 时 $\mathrm{ELU}(0)+1 = 0 + 1 = 1$；$x = -3$ 时 $e^{-3} - 1 + 1 = e^{-3} \approx 0.05$，很小但仍是正数。这个恒正不是自选的装饰，是核分解存在的条件（Mercer 条件要求相似度非负）：$\phi(q)^\top\phi(k)$ 是 d 个正数乘正数再求和，结果必为正，才能扮演「打分」的角色。于是：

$$\big(\phi(Q)\,\phi(K)^\top\big)V = \phi(Q)\big(\phi(K)^\top V\big)$$

结合律在非线性世界里重新可用：先算 $\phi(K)^\top V \in \mathbb{R}^{d \times d}$，复杂度回到 $O(nd^2)$。两个前提到此汇成一句话：非线性提前，耦合消失，结合律重新可用。写成逐 token 的归一化形式（softmax 的归一化也没丢，变成显式分母）:

$$\mathrm{Attn}(q) = \frac{\sum_i \phi(q)^\top \phi(k_i)\, v_i}{\sum_i \phi(q)^\top \phi(k_i)} = \frac{\phi(q)^\top S}{\phi(q)^\top z}, \qquad S = \sum_{i} \phi(k_i)\, v_i^\top$$

两个新符号 S 和 z 分别是：

• $S = \sum_i \phi(k_i)v_i^\top \in \mathbb{R}^{d \times d}$：分子里的 KV 外积矩阵，存「key-value 关联」的记忆本体；
• $z = \sum_i \phi(k_i) \in \mathbb{R}^{d}$：分母里的 key 累积和，就是 softmax 分母 $\sum_i e^{q\cdot k_i}$ 的核化版——归一化因子。

先说清 z，因为后续论文里它最容易被略写。z 在公式里承担的角色就是归一化：没有它，输出会随序列变长而无界增长。但后面 DeltaNet/GDN/KDA 的论文里，递推式往往只写 $S$ 的更新，z 要么藏在一句「输出再过 RMSNorm」的描述里，要么干脆不提——因为实测发现把归一化换成 RMSNorm 效果更好，z 就被简化掉了。所以读者常遇到的困惑是：看 KDA 论文时公式里根本没有 z，翻早期线性注意力文献才发现 z 是这里从 softmax 分母继承下来的归一化项。一句话：z = 归一化分母的累积状态，S = 关联记忆本体；后续模型改用 RMSNorm 后 z 退场，但 S 的更新规则一路演进到 KDA。

分子分母都变成对 S 的查询，S 一遍扫过序列累积即可——复杂度对 n 线性。更关键的是 S 可以写成递推，一步一读出（z 同样逐步累积）:

$$S_t = S_{t-1} + \phi(k_t)\, v_t^\top, \qquad o_t = \frac{\phi(q_t)^\top S_t}{\phi(q_t)^\top z_t}$$

这个递推还有一个更形象的理解，叫 fast weights 视角(Schlag et al., Linear Transformers Are Secretly Fast Weight Programmers)：把 S 看作一块快速权重——模型真正的参数（普通权重）训练完就固定了，而 S 每来一个 token 就被改写一次，相当于一个「随输入不断更新的小型权重」。写入靠 $\phi(k_t)v_t^\top$（每个 token 都在给这块权重编程），读出靠查询 $\phi(q_t)^\top S_t$（拿当前问题去这块权重里查答案）。所以这个视角下，序列处理 = 一边更新权重、一边用权重答题。

回过头总结一下，这两个前提各自换来了什么：

前提	换来的直接好处	对后续模型的影响
抛弃 softmax 非线性	结合律可用，$O(n^2) \to O(n)$	注意力矩阵 $n\times n$ 消失，换成固定大小状态 $S \in \mathbb{R}^{d \times d}$
非线性提前到 Q/K 各自身上	$\phi(q)^\top\phi(k)$ 可分离	S 可以递推累积 -> RNN 化 -> fast weights -> 一切后续演化的载体

注意代价也在表里：换来的 S 只会加法。这就引出了线性注意力最大的问题。

1.3 纯加性状态的问题：记忆碰撞

纯加性状态的核心问题：state 是纯加性的($S_t = S_{t-1} + \phi(k_t)v_t^\top$)，写入只有「叠加」，没有「删除」。序列长度远超 state 有效容量（$d \times d$ 矩阵只能存这么多关联）时，不同 $k \to v$ 关联互相干扰，旧信息永远赖在状态里，新信息无法覆盖——记忆像一个只进不出的仓库。

数值演示。设 $d_k = d_v = 2$，S 从零开始，依次写入四个 token:

token	key	value	说明
t=1	$k_1 = [1, 0]$	$v_1 = [1, 0]$
t=2	$k_2 = [0.6, 0.8]$	$v_2 = [0, 1]$
t=3	$k_3 = [1, 0]$	$v_3 = [2, 0]$	和 $k_1$ 同一个 key，写入新值
t=4	$k_4 = [0, 1]$	$v_4 = [3, 1]$

线性注意力这边，把每一步都算出来。写入规则是 $S_t = S_{t-1} + v_t k_t^\top$，每个 $v k^\top$ 是一个 2×2 外积。

t=1:$v_1 k_1^\top = \begin{bmatrix}1\\0\end{bmatrix}\begin{bmatrix}1&0\end{bmatrix} = \begin{bmatrix}1&0\\0&0\end{bmatrix}$，所以

$$S_1 = \begin{bmatrix}1&0\\0&0\end{bmatrix}$$

t=2:$v_2 k_2^\top = \begin{bmatrix}0\\1\end{bmatrix}\begin{bmatrix}0.6&0.8\end{bmatrix} = \begin{bmatrix}0&0\\0.6&0.8\end{bmatrix}$，叠加后

$$S_2 = \begin{bmatrix}1&0\\0.6&0.8\end{bmatrix}$$

t=3（关键一步，同一个 key 写入新值）:$v_3 k_3^\top = \begin{bmatrix}2\\0\end{bmatrix}\begin{bmatrix}1&0\end{bmatrix} = \begin{bmatrix}2&0\\0&0\end{bmatrix}$，注意它不清除 $S_2$ 里已有的 $\begin{bmatrix}1&0\\0&0\end{bmatrix}$，直接往上叠：

$$S_3 = \begin{bmatrix}3&0\\0.6&0.8\end{bmatrix}$$

第一行变成了 [3, 0]——旧值 1 和新值 2 加在一起，这就是碰撞发生的瞬间。

t=4:$v_4 k_4^\top = \begin{bmatrix}3\\1\end{bmatrix}\begin{bmatrix}0&1\end{bmatrix} = \begin{bmatrix}0&3\\0&1\end{bmatrix}$，叠加后

$$S_4 = \begin{bmatrix}3&3\\0.6&1.8\end{bmatrix}$$

接下来演示「查询」——先说这个操作是什么。写入是每个 token 做一次 $S \mathrel{+}= v k^\top$，把四步叠起来，$S_4$ 其实就是四个外积之和：

$$S_4 = v_1k_1^\top + v_2k_2^\top + v_3k_3^\top + v_4k_4^\top$$

查询的定义：拿一个向量 $k$ 去右乘 S，即 $S\,k$。为什么这样就是「查询」？把上式代入 $S_4 k_1$：

$$S_4 k_1 = v_1(k_1^\top k_1) + v_2(k_2^\top k_1) + v_3(k_3^\top k_1) + v_4(k_4^\top k_1)$$

每个 token 的 value 前面多了一个系数——它存入时的 key 与查询 key 的内积。key 完全匹配（内积=1）value 完整取回；key 正交（内积=0）完全不干扰；部分对齐就按比例混进来一份。这就是「按 key 相似度加权取回 value」，也正是注意力打分的雏形（softmax 注意力把内积换成 $e^{q\cdot k}$，思路相同）。

代入数字。$k_1^\top k_1 = 1$,$k_2^\top k_1 = 0.6$,$k_3^\top k_1 = 1$,$k_4^\top k_1 = 0$:

$$S_4 k_1 = 1{\times}v_1 + 0.6{\times}v_2 + 1{\times}v_3 + 0{\times}v_4 = [1,0] + [0, 0.6] + [2,0] = \begin{bmatrix}3\\0.6\end{bmatrix}$$

（直接用矩阵乘验证：取 $S_4$ 第一列，同样是 $[3, 0.6]^\top$。）

拆开看这个结果：[3.0, 0.6] = 旧值 $v_1=[1,0]$ + 新值 $v_3=[2,0]$ 各自完整叠加（两个「系数 1」都命中），再加 0.6 份 $v_2$（$k_2$ 和 $k_1$ 内积 0.6，部分对齐，混进来 0.6 个 [0,1]）。想读「key=[1,0] 对应的最新值」，读出来的却是一锅大杂烩。

delta rule 这边，同样四步。写入规则换成「先减旧值再加新值」:$S_t = S_{t-1} + (v_t - S_{t-1}k_t)k_t^\top$（取 $\beta = 1$）:

• t=1:$S_0 k_1 = 0$，写入 $v_1 k_1^\top$，得 $S_1 = \begin{bmatrix}1&0\\0&0\end{bmatrix}$（和线性注意力相同）;
• t=2：先查旧值 $S_1 k_2 = [0.6, 0]^\top$（$k_2 = [0.6, 0.8]$ 在第一维有 0.6 的分量，所以部分命中第一列）。写入差值 $u_2 = v_2 - S_1k_2 = [-0.6, 1]$，外积 $u_2 k_2^\top = \begin{bmatrix}-0.36&-0.48\\0.6&0.8\end{bmatrix}$。注意左上角是负数，它的作用是扣除 $k_2$ 方向上已存的 $v_1$ 残余，而非直接叠加。得 $S_2 = \begin{bmatrix}0.64&-0.48\\0.6&0.8\end{bmatrix}$；
• t=3（同一个 key 写新值）：先查旧值 $S_2 k_3 = [0.64, 0.6]^\top$。理想情况这里应该读出 $[1, 0]$（t=1 写入的 $v_1$），但读出的被 t=2 的写入带着偏了。写入差值 $u_3 = v_3 - S_2k_3 = [1.36, -0.6]$，外积只动第一列方向，把 $k_3$ 方向修正到 $v_3$。得 $S_3 = \begin{bmatrix}2&-0.48\\0&0.8\end{bmatrix}$——第一行回到 2，新值到位；
• t=4：先查 $S_3 k_4 = [-0.48, 0.8]^\top$，写入差值 $u_4 = v_4 - S_3k_4 = [3.48, 0.2]$，只修正 $k_4$ 方向。得 $S_4 = \begin{bmatrix}2&3\\0&1\end{bmatrix}$。

最后两边都查询 $k_1 = [1, 0]$：

• 线性注意力：$S_4 k_1 = [3.0, 0.6]$，新旧 value 相互叠加，并混入 0.6 份 $v_2$ 的残余；
• delta rule：$S_4 k_1$ 取 $S_4 = \begin{bmatrix}2&3\\0&1\end{bmatrix}$ 的第一列 $= [2.0, 0.0]$——精确返回最新的 $v_3 = [2, 0]$。这一步值得展开看：拿 t=4 的 $S_4$ 右乘 $k_1$，$k_1$ 只命中第一列（第一行的 2 来自 t=3 写入的 $v_3$，第二行的 0 恰好是 t=3 差值修正把第一列第二行清零的结果——t=2 混进来的 0.6 在 t=3 被 $u_3$ 的第二分量 $-0.6$ 抵消掉了）。查询、写入用的同一个 key，写入时已保证 $S k_3 \approx v_3$，所以查询原样取回新值。

delta rule 起作用的机制：写入时先查旧值、把误差算出来再写。旧记忆里与新写入相关的部分（包括之前叠加污染的分量）被差值中的负项抵消掉，相当于先删除旧 key 上的记忆、再写入新 value，从而保证当前 key 映射到的是完整且无残余的 value。同一个 key 写两次，线性注意力读出的是两个 value 的叠加，delta rule 读出的是新的那个——这就是「记忆碰撞」(memory collision)和它的修复方式。

到这里，DeltaNet 的雏形就有了：固定大小的外积状态 + 「先删旧、再写新」的更新规则。后面 DeltaNet/GDN/KDA 做的事，都是在雏形上加约束（如 key 归一化到单位球）、加门控（衰减系数 α）和解决并行训练的问题。

---

2. 路线二：SSM——从微分方程到遗忘门

线性注意力造出了固定状态，但这个状态只会加法。SSM 是从另一个领域来的——控制理论的状态空间模型——它恰好能精确回答「状态该怎么衰减」，最终和线性注意力在 Mamba-2 处汇合。

2.1 连续 SSM 的定义

单输入单输出(SISO)线性时不变(LTI)状态空间模型：

$$\begin{cases} h'(t) = A\,h(t) + B\,x(t) & \text{(状态方程)}\\[4pt] y(t) = C\,h(t) + D\,x(t) & \text{(输出方程)} \end{cases}$$

符号	维度	含义
$x(t) \in \mathbb{R}$	标量	输入信号
$h(t) \in \mathbb{R}^N$	N 维向量	状态：到 t 为止历史的压缩
$y(t) \in \mathbb{R}$	标量	输出
$A \in \mathbb{R}^{N\times N}$	矩阵	状态转移：旧记忆如何演化/衰减
$B \in \mathbb{R}^{N\times 1}$	向量	输入到状态的写入强度
$C \in \mathbb{R}^{1\times N}$	向量	状态到输出的读出权重
$D \in \mathbb{R}$	标量	直通项（深度学习中常设 0，以下略去）

要解决的问题：神经网络处理的是离散序列 $x_1, x_2, \dots$，需要把微分方程改写为递推式 $h_t = \bar A h_{t-1} + \bar B x_t$，并求出 $\bar A, \bar B$ 与 $A, B$ 的精确关系。

2.2 预备知识：矩阵指数

定义（对标量指数的泰勒级数的直接推广）:

$$e^{M} := \sum_{k=0}^{\infty} \frac{M^k}{k!} = I + M + \frac{M^2}{2!} + \frac{M^3}{3!} + \cdots$$

本推导用到的三条性质：

1. 微分：$\dfrac{d}{dt}e^{At} = A\,e^{At} = e^{At}A$（与标量 $e^{at}$ 求导完全平行）;
2. 交换性：$A$ 与 $e^{At}$ 可交换（因为 $e^{At}$ 是 $A$ 的幂级数）;
3. 逆：$(e^{At})^{-1} = e^{-At}$（由 $e^{At}e^{-At} = e^{A(t-t)} = I$）。

直觉：$e^{A\Delta}$ 是「让系统按自身动力学自由演化 Δ 时间」的算子。A 的特征值实部为负时，它就是各种速度衰减的混合。

2.3 齐次方程的解（无输入情形）

命题：若 $x(t) \equiv 0$，则 $h'(t) = Ah(t)$ 的解为

$$h(t) = e^{A(t - t_0)}\, h(t_0)$$

证明：直接验证满足方程与初值。令 $h(t) = e^{A(t-t_0)}h(t_0)$，则

$$h'(t) = \frac{d}{dt}\Big[e^{A(t-t_0)}\Big]h(t_0) = A\,e^{A(t-t_0)}h(t_0) = A\,h(t). \quad\blacksquare$$

含义：没有输入时，旧记忆按 $e^{A\Delta}$ 自然演化——这是通解第一项的来源。

2.4 通解推导：积分因子法

定理：$h'(t) = A h(t) + B x(t)$ 满足初值 $h(t_0)$ 的解为

$$h(t) = e^{A(t-t_0)}\,h(t_0) + \int_{t_0}^{t} e^{A(t-s)}\,B\,x(s)\,ds$$

证明（积分因子法，四步）:

第 1 步：移项。 把含 h 的项移到左边：

$$h'(t) - A\,h(t) = B\,x(t)$$

第 2 步：乘积分因子 $e^{-At}$。 两边左乘 $e^{-At}$：

$$e^{-At}h'(t) - e^{-At}A\,h(t) = e^{-At}B\,x(t)$$

第 3 步：识别乘积导数。 由矩阵指数的微分性质，

$$\frac{d}{dt}\Big[e^{-At}h(t)\Big] = -e^{-At}A\,h(t) + e^{-At}h'(t)$$

恰好等于左边。于是方程变成：

$$\frac{d}{dt}\Big[e^{-At}h(t)\Big] = e^{-At}B\,x(t)$$

这一步是整个推导的「机关」：乘以 $e^{-At}$ 后，左端塌缩成一个全导数，方程立刻可积。

第 4 步：两边积分并整理。 从 $t_0$ 到 $t$ 积分：

$$e^{-At}h(t) - e^{-At_0}h(t_0) = \int_{t_0}^{t} e^{-As}B\,x(s)\,ds$$

两边左乘 $e^{At}$（注意 $e^{At}e^{-At_0} = e^{A(t-t_0)}$，且 $e^{At}e^{-As} = e^{A(t-s)}$）:

$$h(t) = e^{A(t-t_0)}h(t_0) + \int_{t_0}^{t} e^{A(t-s)}B\,x(s)\,ds \quad\blacksquare$$

两项的物理含义：旧记忆自由演化 + 区间内每一瞬输入贡献的叠加（叠加原理）。

2.5 零阶保持(ZOH)离散化

零阶保持假设：在采样区间 $[t_k,\ t_k + \Delta)$ 内，输入保持为采样值：

$$x(t_k + \tau) = x_k, \qquad \forall\,\tau \in [0, \Delta)$$

推导：在通解中取 $t_0 = t_k$，$t = t_k + \Delta$：

$$h_{k+1} = e^{A\Delta}h_k + \int_{0}^{\Delta} e^{A(\Delta-\tau)}B\,x(t_k + \tau)\,d\tau$$

由 ZOH 假设，$x(t_k+\tau) = x_k$ 是常数，提出积分号：

$$h_{k+1} = \underbrace{e^{A\Delta}}_{\bar A}\,h_k + \underbrace{\left(\int_0^{\Delta} e^{A(\Delta-\tau)}B\,d\tau\right)}_{\bar B}\,x_k$$

计算 $\bar B$ 的积分（标量情形最直观；矩阵情形在 A 可逆时同样成立）。换元 $s = \Delta - \tau$：

$$\bar B = \int_0^{\Delta} e^{As}\,B\,ds$$

对级数逐项积分：

$$\int_0^{\Delta} e^{As}\,ds = \int_0^{\Delta}\sum_{k=0}^{\infty}\frac{(As)^k}{k!}ds = \sum_{k=0}^{\infty}\frac{A^k\Delta^{k+1}}{(k+1)!} = A^{-1}\big(e^{A\Delta} - I\big)$$

最后一步验证：$A^{-1}(e^{A\Delta} - I) = A^{-1}\sum_{k\ge1}\frac{(A\Delta)^k}{k!} = \sum_{k\ge1}\frac{A^{k-1}\Delta^k}{k!} = \sum_{j\ge0}\frac{A^j\Delta^{j+1}}{(j+1)!}$ ✓

结论（ZOH 离散化公式）:

$$\boxed{\ \bar{A} = e^{\Delta A}, \qquad \bar{B} = A^{-1}\big(e^{\Delta A} - I\big)\,B\ }$$

2.6 小步长近似

当 Δ 很小时，$e^{\Delta A} = I + \Delta A + O(\Delta^2)$，于是

$$\bar B = A^{-1}\big(\Delta A + O(\Delta^2)\big)B = \Delta B + O(\Delta^2)$$

即 $\bar B \approx \Delta B$。同理 $\bar A \approx I + \Delta A$（这等价于欧拉法）。

注意：近似只在 Δ -> 0 时可靠。S4/Mamba 的实际实现都用精确的 ZOH 公式；且 Mamba 中 Δ 是逐 token 变化的，每步现算 $e^{\Delta_t A}$。

2.7 数值验证：完整算一遍

取标量系统 $A = -1$，$B = 2$，$C = 1$，$\Delta = 0.5$。

第 1 步：离散化。

$$\bar A = e^{-0.5} \approx 0.6065, \qquad \bar B = \frac{e^{-0.5}-1}{-1}\times 2 = (1 - 0.6065)\times 2 \approx 0.7869$$

第 2 步：递归。 $h_0 = 0$，输入 $x = [1, 1]$：

k	$x_k$	$h_k = 0.6065\,h_{k-1} + 0.7869\,x_k$
1	1	0.7869
2	1	0.6065×0.7869 + 0.7869 ≈ 1.2642

第 3 步：与连续精确解对拍。 对 $x \equiv 1$ 的常数输入，连续方程 $h' = -h + 2$ 的解为 $h(t) = 2 + (h_0 - 2)e^{-t}$。在 $t = 1$（即两步后）:

$$h(1) = 2 - 2e^{-1} \approx 2 - 0.7358 = 1.2642 \quad✓$$

离散递归与连续精确解逐步完全一致——这正是 ZOH 离散化的性质：在 ZOH 假设成立（输入确为分段常数）时，它不是近似，而是精确等价。

2.8 卷积形式：递归展开 = 一维卷积

先把「卷积」本身说清楚（离散因果时序卷积）。输入时序序列 $u_1, u_2, \dots, u_t$，卷积核（权重模板）$K_0, K_1, K_2, \dots$，其中 $K_k$ 是与当前时刻相隔 k 步的历史信息的权重。因果(causal)：只能看过去，看不到未来。形式化：

$$y_t = \sum_{\tau=1}^{t} K_{t-\tau} \cdot u_\tau$$

最简单的数字例子。输入 $u = [10, 20, 30]$，衰减卷积核 $K = [1,\ 0.5,\ 0.25]$（越远权重越小）:

$$\begin{aligned} y_1 &= K_0 u_1 = 1\times10 = 10 \\ y_2 &= K_1 u_1 + K_0 u_2 = 0.5\times10 + 1\times20 = 25 \\ y_3 &= K_2 u_1 + K_1 u_2 + K_0 u_3 = 0.25\times10 + 0.5\times20 + 1\times30 = 42.5 \end{aligned}$$

每一步都把全部历史按距离加权求和，权重模板固定、随距离翻牌——这就是卷积。$y_1$ 只用了 $u_1$（因果），三个输出用的是同一套 K（时不变）。带着这两个属性看 SSM 的卷积形式，就是把 $K_k$ 具体化为 $C\bar A^k \bar B$。

命题：离散 SSM $h_t = \bar A h_{t-1} + \bar B x_t$,$y_t = C h_t$（设 $h_0 = 0$）等价于

$$y = \bar K * x, \qquad \bar K = \big(C\bar B,\ C\bar A\bar B,\ C\bar A^2\bar B,\ \dots,\ C\bar A^{L-1}\bar B\big)$$

证明（直接展开）:

$$h_t = \sum_{i=1}^{t} \bar A^{\,t-i}\bar B\, x_i$$

（归纳：$h_1 = \bar B x_1$；设 $h_{t-1} = \sum_{i\le t-1}\bar A^{t-1-i}\bar B x_i$，则 $h_t = \bar A h_{t-1} + \bar B x_t = \sum_{i\le t-1}\bar A^{t-i}\bar B x_i + \bar B x_t$ ✓）

代入输出方程：

$$y_t = \sum_{i=1}^{t} C\bar A^{\,t-i}\bar B\, x_i = \sum_{j=0}^{t-1} \bar K_j\, x_{t-j} \quad\blacksquare$$

数值验证（§2.7 的系统，输入 $x=[2,4,0,8]$）:

卷积核：$\bar K_j = 0.6065^j \times 0.7869$，即 $[0.7869,\ 0.4772,\ 0.2894,\ 0.1755]$

$$y_4 = 0.7869{\times}8 + 0.4772{\times}0 + 0.2894{\times}4 + 0.1755{\times}2 = 6.295 + 1.158 + 0.351 \approx 7.804$$

递归验证：$h_1=1.574,\ h_2=4.102,\ h_3=2.488,\ h_4=0.6065{\times}2.488+0.7869{\times}8 \approx 1.509+6.295 = 7.804$ ✓

推论：LTI 系统拥有双形式——训练用卷积（FFT，并行），推理用递归(O(1)/token)。Mamba 使 $B, C, \Delta$ 依赖输入后，$\bar K$ 不再固定，卷积形式失效，改由并行扫描承担训练侧并行。

2.9 从 Δ 到遗忘门：通往 Mamba 的最后一环

回看 $\bar A = e^{\Delta A}$：若 A 为负定（如 Mamba-2 取 $A = -a\cdot I$，$a>0$），则

$$\bar A_t = e^{-\Delta_t a} \in (0, 1)$$

就是一个衰减门：

• $\Delta_t \to \infty$:$\bar A_t \to 0$ —— 清空旧记忆，只看当前输入；
• $\Delta_t \to 0$:$\bar A_t \to 1$ —— 冻结状态，忽略当前输入。

Mamba 让 $\Delta_t = \mathrm{softplus}(\mathrm{Linear}(x_t))$，离散化公式每步现算，于是「步长」变成了看内容的标量遗忘门。

2.10 附录：双线性变换离散化对比

除 ZOH 外，S4 论文实际使用的是双线性变换（Tustin 方法）：用梯形法则近似积分，

$$\bar A = \Big(I - \frac{\Delta}{2}A\Big)^{-1}\Big(I + \frac{\Delta}{2}A\Big), \qquad \bar B = \Big(I - \frac{\Delta}{2}A\Big)^{-1}\Delta B$$

方法	性质	适用
ZOH	ZOH 假设下精确；保稳定性；公式含 $e^{\Delta A}$	Mamba 系列：$\Delta_t$ 逐 token 变化，每步现算矩阵指数（S4D/Mamba 的对角 A 使 $e^{\Delta_t A}$ 就是逐元素指数）
双线性	保稳定性；避免矩阵指数；把左半平面解析映射到单位圆内	S4 原论文：A 为 HiPPO 矩阵（非对角），双线性把它变成有理函数，配合 Cauchy 核计算

一句话收束：离散化方法的选择是被 A 的结构决定的——对角 A 配 ZOH（指数按元素算），非对角 HiPPO A 配双线性（变成多项式比值，可借 Cauchy 核求解）。

---

3. Mamba 一族：从 S4 到 Mamba-2

上面这条 SSM 线，从深度学习视角走过了三个关键站点：

S4(2021)：把连续 SSM 正经地搬进序列建模。$\bar A = e^{\Delta A}$、$\bar B = A^{-1}(e^{\Delta A} - I)B$ 都是固定矩阵（与输入无关），于是 LTI 成立、递归 = 卷积，训练用 FFT 卷积、推理用 $O(1)$ 递归（双形式，§2.8）。A 用 HiPPO 矩阵初始化（记住长历史的专门构造），离散化用双线性变换。限制也很明显：参数不随输入变，「记忆怎么衰减」在推理前就定死了。

Mamba / S6(2023)：选择性改造。让 $B, C, \Delta$ 都依赖输入($\Delta_t = \mathrm{softplus}(\mathrm{Linear}(x_t))$)，每步现算 $e^{\Delta_t A}$——「步长」变成了看内容的遗忘门(§2.9)。代价是 LTI 被打破、固定卷积核 $\bar K$ 失效，训练侧改用并行扫描(associative scan);A 限制为对角结构使 $e^{\Delta_t A}$ 逐元素可算。这一步是「SSM 学会看内容」的关键。

Mamba-2 / SSD(2024)：与线性注意力形式统一。状态改写成外积形式 $S_t = \alpha_t S_{t-1} + v_tk_t^\top$，矩阵 $A$ 退化为标量衰减 $\alpha_t = e^{-\Delta_t a}$——从这一步起，SSM 与线性注意力在数学上就是同一个东西的两个记法（SSD 框架）。训练用 chunkwise:chunk 内 $QK^\top$ 小注意力 + chunk 间递归，比纯 scan 的 GEMM 利用率高得多。

对照第 1 节的线性注意力递推 $S_t = S_{t-1} + \phi(k_t)v_t^\top$：Mamba-2 只多了一个乘在旧状态上的标量 $\alpha_t$。两条路线在 Mamba-2 处汇合：线性注意力给出了外积状态的样子，SSM 给出了衰减门。

---

4. 全链路一图流

$$\underbrace{h' = Ah + Bx}_{\text{连续 SSM}} \xrightarrow{\text{积分因子法}} \underbrace{h(t+\Delta) = e^{A\Delta}h(t) + \int_0^\Delta e^{A(\Delta-\tau)}Bx\,d\tau}_{\text{通解:旧记忆衰减 + 输入累积}} \xrightarrow{\text{ZOH}} \underbrace{h_t = \bar A h_{t-1} + \bar B x_t}_{\text{离散递归(推理用)}} \xrightarrow{\text{展开}} \underbrace{y = \bar K * x}_{\text{卷积(训练用)}}$$

线性注意力侧：$\mathrm{softmax}(QK^\top)V$ ——核化——> $\phi(Q)(\phi(K)^\top V)$ ——逐 token——> $S_t = S_{t-1} + \phi(k_t)v_t^\top$。

两线在 Mamba-2 汇合：$S_t = \alpha_t S_{t-1} + v_tk_t^\top$。

此后：GDN 在写入侧加 delta rule（可删除的写入）;KDA 把标量门打开成逐通道门 $\mathrm{Diag}(\alpha_t)$ 并给衰减加下界。骨架始终是同一条：状态 ×（衰减/删除算子）+（写入项）。后续演化见《KDA 的来龙去脉》。

总结

• 线性注意力：去掉 softmax 的耦合非线性 + 核化把非线性提前，$Q(K^\top V)$ 结合律重新可用，$O(n^2) \to O(n)$；代价是纯加性状态，只会叠加不会删除（记忆碰撞）;
• SSM 一条链推完：齐次解 $e^{At}h_0$ -> 积分因子法得通解 -> ZOH 假设下提出 $x_k$ 得离散递归，$\bar A = e^{\Delta A}$、$\bar B = A^{-1}(e^{\Delta A} - I)B$;
• ZOH 不是近似：输入分段常数时离散递归与连续解逐步相等（§2.7 数值对拍 1.2642 = 1.2642）;
• 递归 = 卷积：LTI 的双形式是 S4 训练（FFT 卷积）与推理（O(1) 递归）各取所长的根基；
• $\bar A = e^{\Delta A}$ 就是遗忘门：这是从控制论到 Mamba/KDA 的思想连续性；
• 两条路线在 Mamba-2 汇合：外积状态（线性注意力）+ 标量衰减门(SSM)= $S_t = \alpha_t S_{t-1} + v_tk_t^\top$，此后 delta rule 和逐通道门的演化都在这条骨架上进行。

---

参考：

• Katharopoulos et al., Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention, arXiv:2006.16236
• Schlag et al., Linear Transformers Are Secretly Fast Weight Programmers, arXiv:2102.11174
• Gu et al., Efficiently Modeling Long Sequences with Structured State Spaces (S4), arXiv:2111.00396
• Gu & Dao, Mamba: Linear-Time Sequence Modeling with Selective State Spaces, arXiv:2312.00752
• Dao & Gu, Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality, arXiv:2405.21060

KDA 的来龙去脉：从线性注意力到 Kimi Delta Attention

KDA（Kimi Delta Attention）是 Kimi K3 里负责长序列的那 69 层（总共 93 层）。本文不展开 K3 的完整架构，只讨论一条演进路线：KDA 之前的几个模型（线性注意力、Mamba、DeltaNet/GDN）分别解决了什么问题，KDA 又在它们的基础上改了什么。

演进脉络如下：线性注意力先构造出「固定大小的记忆」，但该记忆只能累加、无法清理；Mamba 引入遗忘机制，但衰减是全局统一的；DeltaNet 支持对单条记忆的精确改写；GDN 将「擦除」与「改写」结合；KDA 进一步让每个通道独立决定衰减速度。每一步均给出公式推导、数值验算与工程动机。

0. 出发点：固定大小的记忆

标准 softmax 注意力的 KV cache 随序列长度线性膨胀，几十万 token 的上下文可使其达到数十 GB 量级，显存与带宽同时成为瓶颈。K3 把「序列维度缩放」列为头号工程目标，93 层里 69 层换成 KDA，就是把 KV cache 换成一个固定大小的状态矩阵：$O(n \cdot d)$ 变 $O(d^2)$，上下文长度翻倍时状态大小保持不变。

但固定大小是有代价的。一个 $d_v \times d_k$ 的矩阵要承载任意长度的序列，记忆必须可写、可改、可遗忘：若只能写入而不能清理，序列一长信息就会相互干扰。如何设计这块「可自我管理的固定记忆」，是本文的主线。

线性注意力与 SSM 两条路线的完整推导见前置篇《线性注意力与 SSM：两条技术路线的完整推导》，本文直接使用其结论。

记号约定：两套写法互为转置

先把记号钉死。文献里状态矩阵有两种摆法，内容完全等价、互为转置，但混用会让推导看起来「中途换了个式子」：

	主约定（§1.1 与 §3 起使用，与 KDA 论文一致）	转置约定（部分实现与 chunkwise 推导常用）
状态形状	$S_t \in \mathbb{R}^{d_k \times d_v}$	$\hat S_t \in \mathbb{R}^{d_v \times d_k}$
读出	$o_t = S_t^\top q_t$	$o_t = \hat S_t q_t$
当前 key 的旧内容	$S_{t-1}^\top k_t$	$\hat S_{t-1} k_t$
写入项	$k_t v_t^\top$（左 key 右 value）	$v_t k_t^\top$（左 value 右 key）
擦除算子	左乘：$(I - \beta_t k_t k_t^\top)S_{t-1}$	右乘：$\hat S_{t-1}(I - \beta_t k_t k_t^\top)$

两者的严格关系就是一次转置 $\hat S_t = S_t^\top$。由于擦除算子 $H_t = I - \beta_t k_t k_t^\top$ 是对称矩阵（$H_t^\top = H_t$，因为 $(k_tk_t^\top)^\top = k_tk_t^\top$），转置可以直接穿过它：

$$\big(H_t S_{t-1} + \beta_t k_t v_t^\top\big)^{\!\top} = S_{t-1}^\top H_t^\top + \beta_t v_t k_t^\top = \hat S_{t-1} H_t + \beta_t v_t k_t^\top$$

所以后文若看到 $k v^\top$ 与 $v k^\top$ 互换、擦除算子从左边跑到右边，那是切换了约定，不是等式变了。GDN 数值验算与 chunkwise 一节为对齐论文公式会改用转置约定，届时会再次点明。

各模型按出场顺序（统一写成主约定）：

• 线性注意力：固定状态 $S_t = S_{t-1} + \phi(k_t)v_t^\top$，只支持累加写入（同一个 key 写两次，读出的是两个 value 的叠加，即记忆碰撞）；
• Mamba-2：引入标量衰减门 $S_t = \alpha_t S_{t-1} + k_t v_t^\top$，具备遗忘能力，但衰减是全局统一的；
• DeltaNet：改为差值写入 $S_t = (I - \beta_tk_tk_t^\top)S_{t-1} + \beta_t k_t v_t^\top$，支持定点改写；
• GDN：衰减门与差值写入结合 $S_t = \alpha_t(I - \beta_tk_tk_t^\top)S_{t-1} + \beta_t k_t v_t^\top$；
• KDA：将标量门拆为逐通道门 $\operatorname{Diag}(\bm{\alpha}_t)$，各维度独立决定衰减速度，并加数值下界，用于 K3。

---

1. 演进主线：从 delta rule 到 GDN

前置篇给出两个结论：线性注意力提供了固定状态，但只能累加写入、存在记忆碰撞；SSM 推进到 Mamba-2 提供了标量衰减门 $\alpha_t$，但衰减是全局统一的。本节讨论这两者如何组合成 GDN（Gated DeltaNet）——先看写入规则怎么从加法变成差值（§1.1），再把遗忘门拼进来（§1.2），然后手算验证（§1.3）并给出可并行的 chunkwise 形式（§1.4）。KDA 对 GDN 的改动从 §3 开始。

1.1 DeltaNet：从加法到差值写入

线性注意力得到的 S 只能不断叠加写入，修正这一点正是 DeltaNet 的动机。解法：写入差值，不写全值。写入前，先用当前 key 把状态里已存的内容读一遍：

$$v_{\mathrm{old}} = S_{t-1}^\top k_t \quad (\text{当前 key 指向的旧内容}), \qquad u_t = \beta_t (v_t - v_{\mathrm{old}})$$

$$S_t = S_{t-1} + k_t u_t^\top$$

符号	形状	含义
$S_t$	$[d_k, d_v]$	状态矩阵（主约定）
$k_t$	$[d_k]$	当前 key，经 L2 归一化后 $|k_t|_2 = 1$
$v_{\mathrm{old}}$	$[d_v]$	当前 key 从状态里读出的已有内容
$\beta_t$	标量 $\in (0,1)$	内容替换强度
$u_t$	$[d_v]$	实际写入的差值

严格改写：差值写入 = 先删后写。上式右侧看不出「擦除」在哪里，把 $u_t$ 代入展开即可，每一步只用外积的结合律 $k_t(k_t^\top S_{t-1}) = (k_tk_t^\top)S_{t-1}$：

$$\begin{aligned} S_t &= S_{t-1} + k_t u_t^\top && \text{定义} \\[2pt] &= S_{t-1} + k_t\big[\beta_t(v_t - v_{\mathrm{old}})\big]^\top && \text{代入 } u_t \\[2pt] &= S_{t-1} + \beta_t k_t v_t^\top - \beta_t k_t v_{\mathrm{old}}^\top && \text{转置展开} \\[2pt] &= S_{t-1} + \beta_t k_t v_t^\top - \beta_t k_t \big(S_{t-1}^\top k_t\big)^{\!\top} && \text{代入 } v_{\mathrm{old}} = S_{t-1}^\top k_t \\[2pt] &= S_{t-1} + \beta_t k_t v_t^\top - \beta_t k_t k_t^\top S_{t-1} && (S_{t-1}^\top k_t)^\top = k_t^\top S_{t-1} \\[2pt] &= \underbrace{\big(I - \beta_t k_t k_t^\top\big) S_{t-1}}_{\text{删除项：沿 } k_t \text{ 方向擦除}} + \underbrace{\beta_t k_t v_t^\top}_{\text{新值项}} && \text{提取公因式 } S_{t-1} \end{aligned}$$

关键的一步是第五行：$v_{\mathrm{old}}$ 自己就是由 $S_{t-1}$ 算出来的，所以「减去旧值」这个动作必然能写成一个作用在 $S_{t-1}$ 上的线性算子，而不是一个额外的加项。提取公因式之后，$-\beta_t k_tk_t^\top$ 就并入了单位阵，变成擦除算子。预测误差 $v_t - v_{\mathrm{old}}$ 就是 delta，Delta Rule 由此得名：每次写入的从来不是新值本身，而是新值与旧值之差。

两端均为 $d_k \times d_v$，维度自洽；若换成转置约定，同一个式子写作 $\hat S_t = \hat S_{t-1}(I - \beta_tk_tk_t^\top) + \beta_t v_tk_t^\top$。

写入差值这一形式并非经验设计，它等价于对回归损失做一步梯度下降。上面是先有「写差值」这个想法、再发现它等于先删后写；反方向走一遍会看到，差值根本不是选的，而是推出来的。

第一步：把记忆当成一个在线回归问题。状态 $S$ 要承担的职责是一张查询表：拿钥匙 $k_t$ 来，应当取出 $v_t$，即希望 $S^\top k_t \approx v_t$。把这个愿望写成当前样本上的平方损失：

$$\mathcal{L}(S) = \tfrac{1}{2}\big\|S^\top k_t - v_t\big\|^2$$

$S^\top k_t$ 是「用现在的记忆查 $k_t$ 能取出的值」，$v_t$ 是「应该取到的值」，两者之差就是残差；系数 $\tfrac12$ 纯为求导后消掉 2。

第二步：求梯度，得到残差与钥匙的外积。先用最熟的一维情形建立直觉：$\tfrac12(wx-y)^2$ 对 $w$ 的导数是 $(wx-y)\,x$——误差乘输入。矩阵版一模一样，只是乘法变成外积。记残差 $r_t = S^\top k_t - v_t \in \mathbb{R}^{d_v}$，取扰动 $\Delta$ 算一阶项：

$$\mathcal{L}(S+\Delta) - \mathcal{L}(S) = \big\langle r_t,\ \Delta^\top k_t \big\rangle + O(\|\Delta\|^2) = \big\langle k_t r_t^\top,\ \Delta \big\rangle + O(\|\Delta\|^2)$$

与 $\Delta$ 配对的那个矩阵就是梯度：

$$\nabla_S \mathcal{L} = k_t\,\big(S^\top k_t - v_t\big)^{\!\top} = k_t r_t^\top \ \in\ \mathbb{R}^{d_k \times d_v}$$

形状与 $S$ 一致，可直接用于更新。注意差值 $S^\top k_t - v_t$ 是自己冒出来的——平方损失的梯度天然就长成「残差 ⊗ 钥匙」的样子。这就是「为何恰好是差值」的答案：没人规定写入要用差值，是平方损失的梯度只能是差值。

第三步：以 $\beta_t$ 为步长走一步 SGD，展开重新归项：

$$\begin{aligned} S_t &= S_{t-1} - \beta_t \nabla_S\mathcal{L}\big|_{S = S_{t-1}} && \text{一步梯度下降} \\[2pt] &= S_{t-1} - \beta_t k_t\big(S_{t-1}^\top k_t - v_t\big)^{\!\top} && \text{代入梯度} \\[2pt] &= S_{t-1} - \beta_t k_t k_t^\top S_{t-1} + \beta_t k_t v_t^\top && \text{展开} \\[2pt] &= \big(I - \beta_t k_t k_t^\top\big)S_{t-1} + \beta_t k_t v_t^\top && \text{提公因式} \end{aligned}$$

结果与前面从「写差值」出发得到的式子逐字相同。两条路径交汇于同一个等式，于是 $\beta_t$ 的角色也明确了：它就是学习率。同样，「先删后写」不是设计直觉，而是展开式里必然的两项：$-\beta_t k_tk_t^\top$ 并入单位阵成为擦除，$+\beta_t k_tv_t^\top$ 就是写入。

验证：写完立即读一次。取 $\|k_t\|_2 = 1$（L2Norm 之后），用同一个 $k_t$ 查新状态：

$$S_t^\top k_t = \big[(I-\beta_tk_tk_t^\top)S_{t-1} + \beta_tk_tv_t^\top\big]^{\!\top}k_t = \underbrace{(1-\beta_t)}_{\text{保留旧值}}\,S_{t-1}^\top k_t + \underbrace{\beta_t}_{\text{接纳新值}} v_t$$

读出结果是旧值与新值的凸组合，$\beta_t$ 就是插值系数：$\beta_t = 1$ 时 $S_t^\top k_t = v_t$，该样本的损失一步降到 0，即完全覆写；$\beta_t = 0.5$ 时新旧各一半；$\beta_t = 0$ 时不学。这也解释了 L2Norm 为何是前提：只有 $\|k_t\| = 1$ 时上式才是干净的插值，否则系数会变成 $1 - \beta_t\|k_t\|^2$，可能跌出 $[0,1]$。

一句话总结这条链：记忆 = 在线回归 → 平方损失 → 梯度 = 残差 ⊗ 钥匙 → 一步 SGD = 先删后写。它有严格出处：Widrow-Hoff 1960 年的 delta rule / LMS 规则（名字里的 delta 正是指误差 $\delta$）在联想记忆矩阵上的应用。后面 GDN 与 KDA 做的事，就是在这个损失里再加一项正则，把「别忘了旧账」量化进目标（见 §1.2 的在线学习统一视角）。

DeltaNet 只改写入规则，两个前置条件一律保留：特征映射 $\phi$（实现里常取 $\phi = \mathrm{L2Norm}$，即下文的单位球约束）、外积状态、逐步递推形式完全没动，变的只有一处：$+\,k v^\top \longrightarrow +\,k(v - S^\top k)^\top$。

直观类比：state 是白板，key 是指针。纯加性写入相当于在白板上不断叠加便签，写满后内容互相遮盖；DeltaNet 先擦除指针 $k_t$ 指向的区域，再写入新内容。$\beta_t = 0$：完全不写入，状态不动；$\beta_t = 1$：完全替换，指针指向的内容被整体替换。这种「先擦后写」的机制使状态能够覆盖错误记忆，这是 DeltaNet 与 GDN 这条路线的核心改进。

关键整理：写成转移矩阵形式。定义 $H_t = I - \beta_t k_t k_t^\top$，状态更新变成

$$S_t = H_t\, S_{t-1} + \beta_t k_t v_t^\top$$

这个形式之所以非常关键，是因为它暴露了 DeltaNet 和 SSM 的同构：$H_t$ 正是随输入变化的状态转移矩阵（SSM 里是 $\bar A = e^{\Delta A}$），$\beta_t k_t v_t^\top$ 正是写入项（SSM 里是 $\bar B x_t$）。

$H_t$ 到底是什么：秩 1 与特征值

$H_t = I - \beta_t k_t k_t^\top$ 是全文出现频率最高的矩阵，值得把它彻底拆开。它由两块拼成：单位阵，减去一个秩 1 矩阵。

先看「秩」。矩阵的秩 = 它的列里真正不同的方向有几个，形式定义是线性无关列的最大个数，直觉是这个矩阵作为变换、输出能铺满几维空间。单位阵 $I \in \mathbb{R}^{d\times d}$ 的 $d$ 列是 $d$ 根坐标轴，谁也不沾谁，秩 $= d$（满秩）；而 $k k^\top$ 的所有列都挤在同一条线上，秩 $= 1$。

为什么 $kk^\top$ 的列都是 $k$ 的倍数。$kk^\top$ 的 $(i,j)$ 元素是 $k_ik_j$，于是它的第 $j$ 列是

$$\begin{pmatrix} k_1 k_j \\ k_2 k_j \\ \vdots \\ k_d k_j \end{pmatrix} = k_j \cdot \begin{pmatrix} k_1 \\ k_2 \\ \vdots \\ k_d \end{pmatrix} = k_j \cdot k$$

第 $j$ 列 = 标量 $k_j$ 乘同一个向量 $k$，换 $j$ 只换倍率、方向永远是 $k$。取 $k = (1,2)^\top$ 验算：

$$k k^\top = \begin{pmatrix}1\\2\end{pmatrix}\begin{pmatrix}1&2\end{pmatrix} = \begin{pmatrix}1&2\\2&4\end{pmatrix}$$

第二列 $(2,4)$ 恰是第一列 $(1,2)$ 的 2 倍——形式上是 $2\times2$ 矩阵，实际只携带一个方向的信息，故行列式为 0、不可逆。反过来也成立：任何秩 1 矩阵都能写成某个外积 $uv^\top$，所以「秩 1 矩阵」与「外积」基本同义。

作为变换，它把一切压到 $k$ 那条线上。作用在任意向量 $x$ 上，用结合律：

$$(k k^\top)\, x = k\,(k^\top x) = (k^\top x)\cdot k$$

$k^\top x$ 是标量，即 $x$ 在 $k$ 方向的投影长度；乘回 $k$ 得到一个沿 $k$ 的向量。不管输入什么，输出永远落在 $k$ 张成的一维直线上——这就是「只张出一维」的几何含义，整个 $d$ 维空间被拍扁成一条线。

再看「特征值」。若存在非零向量 $x$ 使 $Mx = \lambda x$，即 $x$ 经变换后方向不变（或恰好反向）、只被缩放 $\lambda$ 倍，则 $x$ 是特征向量(eigenvector)、$\lambda$ 是特征值(eigenvalue)。多数向量过一个矩阵会又转又缩，特征向量是躺在矩阵「主轴」上的特例，变换对它们只是纯缩放；特征值就是各主轴上的缩放倍率。

用 $k=(1,2)^\top$ 的例子算：沿 $k$ 方向，$(kk^\top)k = k(k^\top k) = \|k\|^2 k = 5k$，故 $\lambda_1 = \|k\|^2 = 5$；与 $k$ 垂直的 $x = (2,-1)^\top$ 满足 $k^\top x = 0$，于是 $(kk^\top)x = k\cdot 0 = 0 = 0\cdot x$，故 $\lambda_2 = 0$。$2\times2$ 恰好两个特征值 5 与 0，正对应「秩 1 把正交方向压没、只在 $k$ 方向放大 $\|k\|^2$ 倍」。

放回 $H_t$。结构一目了然：$I$ 让所有方向原样保留，减去 $\beta_t k_tk_t^\top$ 只在 $k_t$ 这一个方向上动刀，其余 $d-1$ 个方向碰都不碰。特征值分两种：

$$H_t k_t = k_t - \beta_t k_t(k_t^\top k_t) = \big(1 - \beta_t\|k_t\|^2\big)k_t, \qquad H_t x = x \quad (\forall\, x \perp k_t)$$

配合 L2Norm（$\|k_t\| = 1$）就是：沿 $k_t$ 缩放 $1-\beta_t$，正交补方向特征值为 1，即特征值落在 $[1-\beta_t,\ 1] \subset (0,1]$——不放大、不翻转、不发散，这就是数值稳定性的特征值表述。反例也很直白：若不做归一化，取 $k = (1,2)^\top$、$\beta = 0.6$，则 $1-\beta\|k\|^2 = 1-3 = -2$，特征值变号且模长大于 1，反复作用必然发散。

$H_t$ 还有两个后文要用的性质：对称（$H_t^\top = H_t$，这是前面两套约定能靠转置互换的原因）；以及这类「$I$ 减秩 1」结构与**豪斯霍尔德变换（Householder transformation）**同型，QR 分解用它做反射消元。区别在于 Householder 取 $\beta = 2/\|k\|^2$，$\|k\|=1$ 时是精确反射（保长）；DeltaNet 的 $\beta_t \in (0,1)$ 是「部分反射」，软化成可学习的写入强度。

秩 1 也解释了为何删除项开销低：擦除单一方向不需要满秩运算，一次外积即可。更进一步，$S \leftarrow H_tS + \beta_t k_tv_t^\top$ 每步只给状态加一个秩 1 矩阵（秩 1 更新），chunk 内 $C$ 步就是 $C$ 个秩 1 更新的连乘叠加——而 WY / UT 变换正是数值线性代数里专门处理「一串秩 1 更新如何打包」的经典工具，后文 chunkwise 一节的源头就在这里。

为什么特征值这个概念到处出现。因为它回答了迭代系统最关心的问题：一个变换反复作用很多次之后会怎样。$M$ 作用 $n$ 次，在特征向量方向上就是 $\lambda^n$：$|\lambda| > 1$ 的方向爆炸，$|\lambda| < 1$ 的方向衰减消失，$\lambda = 1$ 的方向保持不变。本文这条线上的约束几乎都在围着它转：

出现位置	特征值/缩放倍率的约束	目的
SSM/Mamba 的离散化 $\bar A$	特征值（或对角衰减因子）模长 $\le 1$	状态不发散
GDN / KDA 的 $\alpha \in (0,1)$	直接强制衰减算子逐方向缩放 $< 1$	可控遗忘
$H_t = I-\beta_tk_tk_t^\top$	特征值 $\in [1-\beta_t, 1]$	擦除是收缩的
$1/\Gamma$ 溢出（K3 加下界的原因）	$\Gamma = \prod\alpha$ 连乘趋 0，倒数爆炸	与「$

一句话：特征向量是矩阵的「自然方向」，特征值是每个自然方向上的缩放倍率；看懂这两个数，就看懂了矩阵反复作用后的长期行为。

把递归展开，消掉时间依赖。记 $B_t = \beta_t k_t v_t^\top$，递推 $S_t = H_t S_{t-1} + B_t$ 逐层代入（主约定下 $H$ 在左侧，越晚的时间步越靠外）：

$$S_1 = H_1 S_0 + B_1$$

$$S_2 = H_2H_1 S_0 + H_2B_1 + B_2$$

$$S_3 = H_3H_2H_1 S_0 + H_3H_2B_1 + H_3B_2 + B_3$$

$$S_4 = H_4H_3H_2H_1 S_0 + H_4H_3H_2B_1 + H_4H_3B_2 + H_4B_3 + B_4$$

规律如下：

$$S_t = \Big(\prod_{i=t}^{1} H_i\Big) S_0 + \sum_{i \le t} \Big(\prod_{j=t}^{i+1} H_j\Big) B_i$$

其中 $\prod_{i=t}^{1}H_i = H_tH_{t-1}\cdots H_1$ 表示按时间倒序左乘。展开后递归被彻底消掉了：每个 $S_t$ 都是初始状态、各步写入项与转移矩阵连乘的线性组合，只剩矩阵乘法和求和。而矩阵乘法满足结合律，「从左往右扫」只是众多括号化方案之一——换个括号方式（比如二叉树式两两合并），$H$ 的连乘与写入项的累积可以在 $O(\log n)$ 深度内并行完成。这就是 parallel scan / associative scan（并行扫描/结合扫描） 类方法的核心思想，也是 chunkwise 并行化和 SSM 训练并行（如 Mamba 的 selective scan）共同的理论根基。

到这里两条路线可以拼在一起了：DeltaNet 的 $S_t = H_t S_{t-1} + \beta_t k_t v_t^\top$ 与 SSM 的 $h_t = \bar A h_{t-1} + \bar B x_t$ 结构完全同构，差的只有一件事——$H_t$ 的遗忘是「沿 $k_t$ 方向删一块」，没有 SSM 那种全通道的指数衰减。

1.2 GDN：把遗忘门与定点改写拼在一起

Gated DeltaNet = DeltaNet 的精确写入 + Mamba-2 的全局遗忘。论文的核心洞察：gating 和 delta rule 是互补的两种记忆管理机制：

机制	比喻	能力	缺陷
Gating（Mamba-2）	板擦	大面积擦除，即全局衰减	无法定点修改
Delta rule（DeltaNet）	铅笔	定点覆写某个 key 的关联	无法快速清空

序列长度超过状态容量时，记忆碰撞必然发生；GDN 以板擦与铅笔的组合来管理这块固定大小的白板。主约定下写作

$$S_t = \alpha_t\big(I - \beta_tk_tk_t^\top\big)S_{t-1} + \beta_t k_t v_t^\top$$

从这里开始切换到转置约定（$\hat S = S^\top$，读出 $o_t = \hat S_tq_t$），以便与 GDN 论文及 chunkwise 推导逐项对齐；§1.2 余下部分与 §1.3、§1.4 的数值验算和 chunkwise 公式全部使用它。同一个式子转置后是

$$\hat S_t = \hat S_{t-1}\big(\alpha_t(I - \beta_tk_tk_t^\top)\big) + \beta_t v_t k_t^\top$$

为减少符号负担，转置约定内部仍把状态记作 $S_t$（即下文 $S_t$ 指 $\hat S_t$，形状 $d_v \times d_k$，读出为 $S_tq_t$、旧读出为 $S_{t-1}k_t$）。

其中 $\alpha_t \in (0,1)$ 是数据相关的标量门（Mamba-2 的参数化：$\alpha = \exp(-\mathrm{Softplus}(\mathrm{Linear}(x_t)))$，在 log 空间计算以保证数值稳定）。通过三种极限情形理解这个式子：

极限	行为	对应模型
$\alpha_t \to 1$	纯 delta rule，只定点改写	DeltaNet
$\beta_t \to 1$，k ⊥ 已有记忆	退化为 $S_t = \alpha_tS_{t-1} + v_tk_t^\top$	Mamba-2
$\alpha_t \to 0$	整表清零再写入（硬重置）	新能力：两者都做不到

几何解释：$(I - \beta kk^\top)$ 是广义 Householder 反射，沿 $k$ 方向压缩状态；标量 $\alpha$ 则将整个状态矩阵均匀缩小。前者是定向操作，后者是全局操作，两者作用于不同自由度，因此可以叠加。

注意作用顺序：擦除量是 $\beta_t(S_{t-1}k_t)$，用的是未衰减的旧读出；而 delta 对照的是衰减后的旧值($v_t - \alpha_tS_{t-1}k_t$)。$\alpha$ 乘的是整个 $(I-\beta kk^\top)$，这一点在实现时极易出错（把 α 只乘到擦除项上，chunkwise 形式会与递归形式对不上）。读取侧同样随时间累积衰减：token 在时间步 $x$ 写入，在 $x+t$ 读取时已经被 $\alpha_x\alpha_{x+1}\dots\alpha_{x+t}$ 衰减过。实现中通过 $\gamma^r/\gamma^i$ 项修正——分子分母都是 $\alpha$ 连乘，相除就是区间衰减，本质是乘法形式的前缀和（prefix-sum），与 SSM 的 $\bar A$ 连乘完全同源。

统一视角。至此四个模型均已出现，它们本质上是同一个在线优化问题的闭式解，差别只在目标函数：

$$\text{Linear Attn}\,(\text{纯加性}) \to \text{Mamba-2}\,(\text{全局遗忘门}) \searrow \\ \text{DeltaNet}\,(\text{定点覆写}) \nearrow \;\; \text{GDN}\,(\text{遗忘门} + \text{定点覆写}) \to \text{KDA}\,(\text{逐通道门} + \text{下界})$$

先说清这个优化问题本身。把每个时间步看成一次在线学习：已有状态 $S_{t-1}$，新到一对样本 $(k_t, v_t)$，需要解出新状态 $S_t$。所有四个模型的目标函数都是下面这个形式，自变量是 $S_t$，$S_{t-1}$、$k_t$、$v_t$ 均为已知量：

$$\mathcal{L}(S_t) = \underbrace{\|S_t - A_t\|_F^2}_{\text{正则项}} - \underbrace{2\langle S_tk_t,\ u_t\rangle}_{\text{拟合项}}$$

两项各自度量的是：

• 正则项 $\|S_t - A_t\|_F^2$：新状态与锚点 $A_t$ 的 Frobenius 距离，即所有矩阵元素差的平方和。它惩罚状态的改动量，对应记忆保留。锚点取 $S_{t-1}$ 表示要求尽量不动，取 $\alpha_tS_{t-1}$ 表示允许先按 $\alpha_t$ 收缩再比较，即容忍遗忘；
• 拟合项 $-2\langle S_tk_t,\ u_t\rangle$：用 $k_t$ 检索新状态得到 $S_tk_t$，再与写入目标 $u_t$ 做内积。前面的负号使内积越大、损失越小，即要求检索结果朝 $u_t$ 的方向对齐，对应关联学习。

该目标对 $S_t$ 是二次的，$\nabla_{S_t}\mathcal{L} = 2(S_t - A_t) - 2u_tk_t^\top = 0$，因此闭式解统一为

$$S_t = A_t + u_tk_t^\top$$

于是四个模型的差别可以完全归结为两个量的选择：锚点 $A_t$ 决定怎么遗忘，写入目标 $u_t$ 决定怎么写入。

模型	锚点 $A_t$	写入目标 $u_t$	在线学习目标	状态更新的闭式解
Linear Attn	$S_{t-1}$	$v_t$	$|S_t - S_{t-1}|_F^2 - 2\langle S_tk_t, v_t\rangle$	$S_t = S_{t-1} + v_tk_t^\top$
Mamba-2	$\alpha_tS_{t-1}$	$v_t$	$|S_t - \alpha_tS_{t-1}|_F^2 - 2\langle S_tk_t, v_t\rangle$	$S_t = \alpha_tS_{t-1} + v_tk_t^\top$
DeltaNet	$S_{t-1}$	$\beta_t(v_t - S_{t-1}k_t)$	$|S_t - S_{t-1}|_F^2 - 2\langle S_tk_t, \beta_t(v_t - S_{t-1}k_t)\rangle$	$S_t = S_{t-1}(I - \beta_tk_tk_t^\top) + \beta_tv_tk_t^\top$
GDN	$\alpha_tS_{t-1}$	$\beta_t(v_t - \alpha_tS_{t-1}k_t)$	$|S_t - \alpha_tS_{t-1}|_F^2 - 2\langle S_tk_t, \beta_t(v_t - \alpha_tS_{t-1}k_t)\rangle$	$S_t = S_{t-1}(\alpha_t(I-\beta_tk_tk_t^\top)) + \beta_tv_tk_t^\top$
KDA	$S_{t-1}\mathrm{Diag}(\bm\alpha_t)$ 逐通道收缩	$\beta_t(v_t - S_{t-1}\mathrm{Diag}(\bm\alpha_t)k_t)$	GDN 的逐通道化	$S_t = S_{t-1}\mathrm{Diag}(\bm\alpha_t)(I-\beta_tk_tk_t^\top) + \beta_tv_tk_t^\top$

把 $A_t$ 与 $u_t$ 代入 $S_t = A_t + u_tk_t^\top$ 即可得到最后一列。以 DeltaNet 为例：$u_t = \beta_t(v_t - S_{t-1}k_t)$，代入后 $S_t = S_{t-1} + \beta_t(v_t - S_{t-1}k_t)k_t^\top$，展开即 $S_{t-1}(I - \beta_tk_tk_t^\top) + \beta_tv_tk_t^\top$，与前面用梯度下降推出的结果一致。

这张表读法很简单：损失里只有两样东西——$v_t$ 是 ground truth（这个 key 本来该存的值），$S_tk_t$ 是当前记忆对它的预测（这个 key 实际读出来的值），拟合项衡量两者是否一致；正则项则约束新状态别离锚点太远，即该保留多少旧记忆。四个模型的差别只在于：拟合项拿什么当 target（整份 $v_t$，还是残差 $v_t - A_tk_t$），正则项拿什么当锚点（固定的 $S_{t-1}$，还是可收缩的 $\alpha_tS_{t-1}$）。GDN 在两处都取强化版本，KDA 再把锚点的标量收缩换成逐通道的 $\mathrm{Diag}(\bm\alpha_t)$。

说到底，这就是把「$k \to v$ 这条记忆是否还对得上」写成了一个损失函数：对不上就修（拟合项），但别为了修这一条把整张表推翻（正则项）。

KDA 的最后一步由此确定。Kimi Linear（后演化为 KDA）在 Gated DeltaNet 基础上的核心改进是细粒度门控：不再是每个注意力头一个标量 $\alpha$，而是每个通道一个独立衰减值：

$$\alpha_t \in (0,1)^{d_k} \quad (\text{channel-wise 遗忘})$$

作用是模型可以对不同维度做不同程度的记忆衰减：部分通道 $\alpha$ 接近 1，保留长期信息；部分通道 $\alpha$ 接近 0，快速遗忘。类比来说，Gated DeltaNet 的标量门相当于总开关，KDA 的逐通道门相当于每个通道各有一个独立调节旋钮：同一个状态内，慢通道承载长程依赖，快通道负责局部上下文，记忆容量按维度重新分配。再加上衰减下界（$\log$-decay 限制在 $(g_{\min}, 0)$）以保证数值稳定，即得到 KDA 的完整递推式，见下一小节。

下面先梳理 GDN（Gated DeltaNet）的机制：手工验算一遍、推导 chunkwise 并行形式，最后对照 KDA 分析其继承与改动。

1.3 GDN 数值验算：手算一遍

设定 $d_k = d_v = 2$，$C = 3$ 个 token，$S_0 = 0$。数据刻意构造为**$k_1 = k_2 = e_1$，以制造 key 碰撞**；query 取 $Q = K$，即每一步都用当前 token 自己的 key 去查（$q_1 = q_2 = e_1$、$q_3 = e_2$），这样读出结果能直接对照「这个地址此刻存的是什么」：

$$Q = K = \begin{bmatrix}1&0\\1&0\\0&1\end{bmatrix},\ V = \begin{bmatrix}1&0\\2&0\\3&1\end{bmatrix},\ \alpha = [0.8,\,0.5,\,0.9],\ \beta = [1,\,1,\,0.6]$$

本节沿用 §1.2 声明的转置约定：$S \in \mathbb{R}^{d_v \times d_k}$，读出 $o_t = S_tq_t$，旧读出为 $S_{t-1}k_t$。

顺序递归，作为对照基准。累积衰减 $\gamma_j = \prod_{i\le j}\alpha_i = [0.8, 0.4, 0.36]$。

t=1（$k=e_1$， $v=[1,0]$， $\alpha=0.8$， $\beta=1$）：$S_0k = 0$，无旧记忆可删：

$$S_1 = 0.8\cdot 0 + 1\cdot([1,0]-0)\,e_1^\top = \begin{bmatrix}1&0\\0&0\end{bmatrix}, \qquad o_1 = S_1q_1 = S_1e_1 = [1,0]$$

t=2（$k=e_1$， $v=[2,0]$， $\alpha=0.5$， $\beta=1$）：旧读出 $S_1k_2 = [1,0] = v_1$——碰撞发生。擦除 $-1\cdot[1,0]e_1^\top$ 把 $v_1$ 完全擦掉；写入 delta $= [2,0] - 0.5\cdot[1,0] = [1.5, 0]$：

$$S_2 = 0.5S_1 - [1,0]e_1^\top + [1.5,0]e_1^\top = \begin{bmatrix}2&0\\0&0\end{bmatrix}$$

此时读出 $o_2 = S_2q_2 = S_2e_1 = [2,0]$，即 $v_2$，$v_1$ 已被覆写（对照线性注意力：纯加性写入会得到 [3,0] 的叠加结果）。

t=3（$k=e_2$， $v=[3,1]$， $\alpha=0.9$， $\beta=0.6$）：旧读出 $S_2k_3 = 0$，正交无碰撞。写入 $0.6\cdot[3,1]e_2^\top$，同时全表再乘 $\alpha$（此处也乘了已写入的 $e_1$ 行）：

$$S_3 = \begin{bmatrix}1.8&1.8\\0&0.6\end{bmatrix}, \qquad o_3 = S_3q_3 = S_3e_2 = [1.8,\,0.6]$$

检查点：为什么 $S_3[0,0] = 1.8$ 不是 2.0？ t=3 的 $\alpha_3=0.9$ 作用在整张表上：第 1 行 $2.0\times0.9 = 1.8$。这就是 gating 与 delta 的交互：即使 token 3 的 key 与 $e_1$ 正交，它的遗忘门仍然衰减了 $e_1$ 通道上的记忆。逐通道门（KDA）与下界衰减都是围绕这一约束做文章。

1.4 GDN 的 Chunkwise 并行形式

推理用递归($O(1)$/token)，但训练/prefill 必须并行。GDN 的贡献是把 gating 并入 DeltaNet 的 WY 表示 chunkwise 框架。设 chunk 大小 C，chunk 入口状态 $S_0$，目标：一次矩阵乘算出整个 chunk 的 O 和 chunk 出口状态 $S_C$。

第一步：部分展开递归：

$$S_r = \underbrace{\gamma_r S_0 P_r}_{F_r} + \underbrace{\sum_{i=1}^r\frac{\gamma_r}{\gamma_i}\,\tilde u_i k_i^\top}_{G_r}$$

• $\gamma_r = \prod_{j\le r}\alpha_j$（$\alpha$ 是标量，可提到矩阵连乘外面）；
• $P_r = \prod_{i\le r}(I - \beta_ik_ik_i^\top)$：纯 Householder 连乘，与 gating 无关；
• $\tilde u_i$：吸收了 $\beta$ 和衰减修正的「伪 value」。

第二步：WY 表示——秩 1 连乘压缩成两个小矩阵。

先说清为什么非做不可。$P_r$ 是 $C$ 个 $d_k\times d_k$ 矩阵逐个相乘，$O(C\,d_k^3)$ 且严格顺序——比原递推还贵，并行化直接失败。输出侧同理，每个 $o_c$ 都要「前 $c$ 个擦除矩阵的乘积」。

关键观察：这种乘积永远不膨胀。每个因子都是「单位阵减秩 1」，这类矩阵连乘的结果仍是「单位阵减一个低秩矩阵」，秩不超过因子个数：

$$P_r := \prod_{i=1}^{r}(I - \beta_i k_i k_i^\top) = I - \sum_{i\le r} w_i k_i^\top$$

证明（对 $r$ 归纳）。$r=0$ 时 $P_0 = I$，空和成立。设 $P_{r-1} = I - \sum_{i<r} w_i k_i^\top$ 已成立，右乘第 $r$ 个因子：

$$\begin{aligned} P_r &= P_{r-1}\big(I - \beta_r k_r k_r^\top\big) \\[2pt] &= \Big(I - \sum_{i<r} w_i k_i^\top\Big) - \beta_r\Big(I - \sum_{i<r} w_i k_i^\top\Big)k_r k_r^\top \\[2pt] &= I - \sum_{i<r} w_i k_i^\top - \beta_r k_r k_r^\top + \beta_r \sum_{i<r} w_i \underbrace{(k_i^\top k_r)}_{\text{标量}} k_r^\top \end{aligned}$$

第三、四项都以 $k_r^\top$ 结尾，合并同类项：

$$P_r = I - \sum_{i<r} w_i k_i^\top - \underbrace{\beta_r\Big(k_r - \sum_{i<r} w_i (k_i^\top k_r)\Big)}_{\text{记作 } w_r} k_r^\top = I - \sum_{i\le r} w_i k_i^\top$$

归纳完成。注意 $w_r$ 不是定义出来的技巧，而是「乘积保持低秩」这个要求逼出来的——要让结果保持 $I - \sum_i w_ik_i^\top$ 的形式，括号里那一坨只能是 $w_r$：

$$w_r = \beta_r\Big(k_r - \sum_{i<r}w_i\,(k_i^\top k_r)\Big)$$

value 侧同理。把第 $i$ 次写入 $\beta_iv_ik_i^\top$ 穿过它之后所有的擦除矩阵与衰减，追踪一遍即得

$$\tilde u_r = \beta_r\Big(v_r - \sum_{i<r}\tilde u_i\,\tfrac{\gamma_r}{\gamma_i}(k_i^\top k_r)\Big)$$

两条递归的直觉。$w_r$ 是修正后的擦除向量：第 $r$ 步本想擦除 $k_r$ 方向，但若 $k_r$ 与之前的 $k_i$ 有重叠（$k_i^\top k_r \ne 0$），连乘展开时前面的擦除项已经顺带擦过这部分，$w_r$ 把已擦的量减掉以避免重复擦除，减法权重恰是重叠度 $k_i^\top k_r$。$\tilde u_r$ 是同一修正的 value 版，唯一差别是那个衰减比 $\gamma_r/\gamma_i$：第 $i$ 次写入到第 $r$ 步时已多衰减 $\prod_{s=i+1}^{r}\alpha_s = \gamma_r/\gamma_i$ 倍，故其干扰要按此比例打折——越早的写入衰减越多、干扰越小。

为什么 $\gamma$ 只出现在 $\tilde u$ 里（即 gating 并入的位置）：GDN 的衰减是标量，标量与一切矩阵可交换，擦除连乘里的衰减可整体提到外面变成总因子 $\gamma_r$，所以 $w$ 的递归里看不见 $\gamma$；但 value 侧每次写入的「存活时长」不同，这个相对衰减无法外提，只能以比值留在递归里。对照 KDA：衰减变成向量后与擦除不可交换，$\gamma$ 再也提不出去，只能渗进内积本身（见 §4.1 的 $M_{ci}$）。

第三步：UT 变换——递归变成一次下三角方程求解。

两条递归里 $w_r$ 只依赖 $w_{i<r}$，是严格下三角依赖，因此可以整体写成矩阵方程。把 $w_r$ 的递归移项：

$$w_r + \sum_{i<r} \beta_r(k_i^\top k_r)\,w_i = \beta_r k_r$$

令 $W \in \mathbb{R}^{C\times d_k}$ 的第 $r$ 行为 $w_r^\top$，并定义严格下三角矩阵

$$L_{ri} = \begin{cases}\beta_r\,(k_i^\top k_r), & i < r\\ 0, & i \ge r\end{cases} \qquad\text{即}\qquad L = \mathrm{strictLower}\big(\mathrm{diag}(\beta)\,KK^\top\big)$$

则 $C$ 个方程可一次写成 $(I + L)\,W = \mathrm{diag}(\beta)\,K$，于是

$$W = (I+L)^{-1}\,\mathrm{diag}(\beta)\,K = T_{\text{plain}}K, \qquad T_{\text{plain}} = \big[I + \mathrm{strictLower}(\mathrm{diag}(\beta)KK^\top)\big]^{-1}\mathrm{diag}(\beta)$$

求这个逆很便宜，原因是 $L$ 幂零。严格下三角矩阵满足 $L^C = 0$，所以 Neumann 级数有限项精确截断：

$$(I+L)^{-1} = I - L + L^2 - \cdots + (-1)^{C-1}L^{C-1}$$

既不需要迭代、也不存在收敛性问题，一次前代法（forward substitution）即可，代价 $O(C^2)$——相对于省下的 $O(C\,d_k^3)$ 连乘完全可以忽略。这就是 UT 变换：$(I+L)$ 是单位下三角（Unit Triangular，对角为 1，因为 $w_r$ 完整依赖自己），求解它即「UT」名字的来源。$\tilde U$ 侧只需把内积换成带衰减比的版本：

$$\tilde U = T_{\text{gated}}V, \qquad T_{\text{gated}} = \big[I + \mathrm{strictLower}(\mathrm{diag}(\beta)(\Gamma\odot KK^\top))\big]^{-1}\mathrm{diag}(\beta)$$

所以 UT 不是额外发明的东西，它就是这两条递归的矩阵形态。

乘法链 → 加法链：这才是并行的真正来源。整件事的本质是把擦除矩阵的连乘 $\prod_r(I - \beta_rk_rk_r^\top)$ 换成了求和 $I - \sum_r w_rk_r^\top$，代价是求和项不再是原始的 $k_r$ 而是带修正的 $w_r$，修正系数由那个小三角求解预先算清。准确地说：把大的顺序依赖（$C$ 个 $d_k\times d_k$ 矩阵依次相乘）换成了小的顺序依赖（$C\times C$ 三角求解）加一堆可任意并行的加法。

求和为什么就是胜利：加法可交换、可结合，因而可任意分组——树形归约、分块、稠密 matmul，GPU 的全部并行性都在奖励「求和结构」；而连乘与递推必须一步一步来。

这个手法在本文这条技术路线上出现了至少四次，难度递增但模式相同：

场景	恒等式	把什么变成了求和
log 空间衰减	$\prod_s \alpha_s = \exp(\sum_s g_s)$	累积衰减 → cumsum（最字面的一个）
SSM 的卷积形式	$x_t = \sum_s \bar A^{t-s}\bar B u_s$	顺序递推 → 对历史的加权和，可用卷积/FFT
Mamba-2 的 SSD	递推 $\equiv$ 半可分矩阵，块内 $(CB^\top)\odot L$	选择性递推 → 下三角掩码 × 求和
DeltaNet/GDN/KDA 的 WY-UT	$\prod(I-\beta kk^\top) = I - \sum w_ik_i^\top$	秩 1 连乘 → 外积求和（本节）

一个反向的注脚：状态本身 $S = \sum_i \tilde u_ik_i^\top$ 也是求和——推理时每步加一个秩 1，训练时 WY 把顺序过程也变成求和。累积是语义，求和是算法，这条路线的美学是自洽的。

辨析：因果掩码 ≠ UT 变换。两者容易混，因为碰巧都是下三角，但要管的完全是两件事：

• 因果掩码(tril)：把 score 矩阵的严格上三角直接置零，一行掩码操作，没有任何「变换」可言。它管的是「第 i 个输出不许看未来的 token」；
• UT 变换（求 $(I+L)^{-1}$）：处理的是块内历史写入之间的相互影响。delta rule 每次写入都是「先读、再改」，块内第 2 次写入读到了第 1 次的结果，第 3 次读到前两次，历史写入相互耦合，UT 变换负责解耦。

两者都是下三角不是巧合，是同一个原因：因果性。位置 i 的写入只能影响 i 之后的位置，所以「干扰系数矩阵」天然下三角；对角线天然是 1（自己的写入自己完整可见），于是要逆的矩阵恰好是单位下三角——这就是「UT」（Unit Triangular）名字的由来。一句话：因果性决定了它是三角的，但做它的目的是解耦，不是掩码。

为什么必须做：并行化要求把 C 次顺序写入合并为一次外积累加 $\sum_i \tilde v_i k_i^\top$。如果直接用原始 $v_i$ 累加，重叠部分会被重复计算——第 1 次写入的内容会透过后续写入的「先读」环节被间接再写一遍。UT 变换算出每个 $v_i$ 该扣除多少，使等式精确成立。不做的代价：要么结果错，要么退回逐 token 循环。

这类下三角变换是个大家族。「顺序递推 ↔ 三角矩阵求逆」是个通用模式，KDA 的 UT 只是其中一员：

家族成员	三角结构	与 UT 的关系
三角方程组求解（前代/回代）	LU、Cholesky 分解之后的三角系统	UT 变换的计算过程即一次前代法，两者为同一算法
Householder QR 的紧凑 WY 表示	反射连乘 $\prod(I - \beta kk^\top) = I + YTY^\top$，$T$ 三角	「WY」「UT」两个名字的学术出处（Schreiber-Van Loan 1989）；DeltaNet 把同样的打包思想借到 delta rule
因果卷积的逆（去卷积）	因果线性系统 = 下三角 Toeplitz，其逆也是下三角 Toeplitz	信号处理经典：「用三角逆矩阵解顺序依赖」
Mamba-2/SSD 的半可分矩阵	块内注意力 $(CB^\top)\odot L$，$L$ 下三角衰减	同一枚硬币另一面：顺序 SSM 递推等价于带结构下三角矩阵，KDA 的 $A^{qk}$ 衰减注意力项完全是这个结构
幂零矩阵 Neumann 级数	$(I+L)^{-1} = I - L + L^2 - \cdots$	严格下三角矩阵幂零（$L^C=0$）故有限项精确截断，即上面 UT 能精确且便宜算出的数学原因

归纳一条通则：凡是「顺序执行的因果更新」，在分块并行化时都会转化为一个下三角矩阵的求逆或求解问题，SSM、delta rule、因果卷积、QR 分解都属于这一模式。KDA chunkwise 中的 WY 表示与 UT 变换，分别是这个模式在「写入打包」与「依赖解耦」上的具体化。

Householder 与 WY 的出处（1958 / 1989）

WY 与 UT 都是数值线性代数的经典老物件，被 DeltaNet 系列「考古」出来复用。既然本文反复用到，把家谱交代清楚。

Householder 变换（1958）就是关于一个超平面的镜像反射。给定单位法向量 $u$，反射矩阵为 $H = I - 2uu^\top$。把任意 $x$ 拆成沿 $u$ 的分量与平行镜面的分量，反射即把法向分量翻号：

$$Hx = x - 2u(u^\top x) = x - 2(u^\top x)\,u$$

三个性质直接从这个结构来：对称（$H^\top = H$）、正交（$H^\top H = I$，反射保长）、对合（$H^2 = I$，照两次镜子回到原样）。其特征值是一个 $-1$（法向翻转）与 $d-1$ 个 $+1$（镜面内不动）。

它与 delta rule 的擦除矩阵是同族对象。对比 $I - 2uu^\top$ 与 $I - \beta_tk_tk_t^\top$：取 $\beta_t\|k_t\|^2 = 2$ 时两者完全相同。结合 §1.1 算过的特征值 $1 - \beta\|k\|^2$：

$\beta$（取 $|k|=1$）	沿 $k$ 的特征值	性质
$\beta \to 0$	$\to 1$	几乎不动，不擦除
$\beta = 1$	$0$	该方向完全清零（投影）
$\beta = 2$	$-1$	正交反射，即 Householder

所以 delta rule 的擦除矩阵可以理解为没照到底的半面镜子：$\beta \in (0,1)$ 只做收缩而非翻转，代价是不再正交，好处是「擦除强度」成了可学习的连续量。Householder 的主战场是 QR 分解：对第 1 列选一面镜子把对角线以下全照成 0，再对第 2 列选一面……$m$ 面镜子依次照完得到上三角 $R$，镜子之积即正交阵 $Q$。

WY 表示（1989，Schreiber & Van Loan）解决的是「一串镜子怎么存」。QR 做完后 $Q = H_1H_2\cdots H_m$ 是 $m$ 个 $n\times n$ 反射之积，每次用它都重新连乘既贵又顺序。他们的观察是

$$Q = H_1H_2\cdots H_m = I + WY^\top, \qquad W, Y \in \mathbb{R}^{n\times m}$$

$m$ 个大方阵之积压缩成两个瘦矩阵（$m \ll n$），用的时候两次矩阵乘即可：$Qx = x + W(Y^\top x)$。推导与上面 $w_r$ 的归纳一模一样：每个因子是「$I$ 加秩 1」，连乘时秩只累加不膨胀，归纳地合并出第 $j$ 个修正向量。进一步可写成 $Q = I - YTY^\top$，其中 $T$ 是 $m\times m$ 上三角矩阵，由一个小递归算出——这就是 UT 变换名字的出处。这套东西在 LAPACK 的 QR 例程（xGEQRF / xORMQR）底层已经跑了几十年。

把家谱摆出来：

	数值线性代数（1958 / 1989）	DeltaNet / GDN / KDA（2020s）
基本砖块	$I - 2uu^\top$（反射）	$I - \beta kk^\top$（擦除）
要打包的对象	$m$ 面镜子之积 $Q$	chunk 内 $C$ 次擦除之积 $P_C$
紧凑形式	$I + WY^\top$（或 $I - YTY^\top$）	$I - \sum_i w_ik_i^\top$
修正向量递归	逐个镜子扣重叠	$w_r = \beta_r(k_r - \sum_{i<r}w_i\,k_i^\top k_r)$
小三角因子	$T$（上三角）	$(I+L)^{-1}$（单位下三角）
目的	$Q$ 的应用变成 BLAS-3	顺序写入变成稠密 matmul

一句话总括：Householder 变换是一类「$I$ 减秩 1」的反射矩阵，WY 表示是把这类矩阵的连乘压缩成两个瘦矩阵的经典技巧；DeltaNet 的作者发现 delta rule 的擦除矩阵恰是同一族对象，于是把这个三十多年前的打包技巧搬了过来，让 chunk 内的顺序写入得以并行——GDN 与 KDA 一路继承，本文的 UT 变换就是 compact-WY 里那个三角因子的计算。

回到公式。上面 $T_{\text{gated}}$ 里的衰减感知掩码即 $\Gamma_{ij} = \gamma_i/\gamma_j\ (i>j)$；$W$ 与 $\tilde U$ 只差内积处的一个 $\gamma$ 比。下三角求解（$C\times C$，实践中 $C = 64$）用前代法完成。

第四步：chunk 输出与出口状态。记号沿用论文的箭头约定：$\overleftarrow{(\cdot)}_r = \gamma_r(\cdot)_r$（衰减到 chunk 首端），$\overrightarrow{(\cdot)}_r = \frac{\gamma_C}{\gamma_r}(\cdot)_r$（衰减到 chunk 末端）。

输出（两项：读 chunk 外旧状态 + chunk 内交互）：

$$O = \overleftarrow{Q}\,S_0^\top + \big(QK^\top\odot\Gamma_{\text{causal}}\big)\big(\tilde U - \overleftarrow W S_0^\top\big)$$

出口状态：

$$S_C = \gamma_C S_0 + \big(\overrightarrow{\tilde U} - \overrightarrow W S_0^\top\big)^\top K \qquad(\overrightarrow{\tilde U}_r = \tfrac{\gamma_C}{\gamma_r}\tilde u_r)$$

结构读法：

• 输出的第二项是「chunk 内小注意力」：$QK^\top\odot\Gamma_{\text{causal}}$ 就是带衰减的因果注意力矩阵，attend 的对象不是 V 而是修正后的伪 value $\tilde U - \overleftarrow WS_0^\top$（后者是「旧状态在这个 chunk 里该被擦掉的部分」）；
• 出口状态 = 旧状态整体衰减 $\gamma_C$ + 修正量加权写入（权重 $\gamma_C/\gamma_i$：越早写入衰减越多）；
• 全部计算都是 $C\times C$、$C\times d_k$、$C\times d_v$ 的稠密矩阵乘——Tensor Core 友好；chunk 间只传一个 $d_v\times d_k$ 矩阵。

数值验算：用上面顺序递归的例子核对 chunkwise 形式。

Step 1：$KK^\top = \begin{bmatrix}1&1&0\\1&1&0\\0&0&1\end{bmatrix}$，$\Gamma_{\text{strict}}\odot KK^\top$ 只有 (2,1) 处非零 $= \gamma_2/\gamma_1\times1 = 0.5$。

Step 2：解两个下三角方程（$\beta = [1,1,0.6]$）：

$$T_{\text{plain}} = \begin{bmatrix}1&0&0\\-1&1&0\\0&0&0.6\end{bmatrix}, \qquad T_{\text{gated}} = \begin{bmatrix}1&0&0\\-0.5&1&0\\0&0&0.6\end{bmatrix}$$

对比唯一差别 (2,1)：-1 → -0.5，正是 $\gamma_2/\gamma_1 = 0.5$ 的衰减——t=2 时 $v_1$ 已被衰减一半，擦除它的需求也减半。

Step 3:$W = T_{\text{plain}}K = \begin{bmatrix}1&0\\0&0\\0&0.6\end{bmatrix}$,$\tilde U = T_{\text{gated}}V = \begin{bmatrix}1&0\\1.5&0\\1.8&0.6\end{bmatrix}$。

看 $\tilde u$ 的第二行：$v_2 - 0.5\cdot\tilde u_1(k_1^\top k_2) = [2,0] - 0.5[1,0] = $ [1.5, 0]，与顺序递归中计算的 delta 完全一致 ✓（$W_2 = 0$ 是因为 $w_1$ 已将 $e_1$ 方向完全擦除，$\beta=1$ 时无需重复擦除）。

Step 4（$S_0=0$，修正项消失）：$\overrightarrow{\tilde U} = \frac{\gamma_C}{\gamma_i}\tilde u_i$ 逐行乘 $[0.36/0.8, 0.36/0.4, 1] = [0.45, 0.9, 1]$：

$$\overrightarrow{\tilde U} = \begin{bmatrix}0.45&0\\1.35&0\\1.8&0.6\end{bmatrix}, \qquad S_C = \overrightarrow{\tilde U}^\top K = \begin{bmatrix}1.8&1.8\\0&0.6\end{bmatrix}\ \checkmark$$

与顺序递归的 $S_3$ 完全一致。

Step 5:$\Gamma_{\text{causal}} = \begin{bmatrix}1&0&0\\0.5&1&0\\0.45&0.9&1\end{bmatrix}$,$O = (QK^\top\odot\Gamma_{\text{causal}})\tilde U$:

$$O = \begin{bmatrix}1&0&0\\0.5&1&0\\0&0&1\end{bmatrix}\begin{bmatrix}1&0\\1.5&0\\1.8&0.6\end{bmatrix} = \begin{bmatrix}1&0\\2&0\\1.8&0.6\end{bmatrix}\ \checkmark$$

与顺序递归的 $o_1=[1,0]$、$o_2=[2,0]$、$o_3=[1.8,0.6]$ 逐步精确一致（含非零 $S_0$ 的一般情形同样对拍通过）。

2. GDN 在网络里长什么样

§1 讲的都是状态怎么更新，属于 token mixer 内部的数学。但 $q, k, v, \alpha, \beta$ 这些量本身从哪来、算完的 $\tilde o$ 又怎么变成层输出，还没交代。本节补上这一层：GDN 采用 Llama 式宏架构，把 attention 换成 gated delta token mixer：

1 2 3 4 5 6 7

x ─┬─ W_q/W_k ─ ShortConv ─ SiLU ─ L2Norm ──> q, k ├─ W_v ──── ShortConv ─ SiLU ───────────> v ├─ W_α(线性投影, log 空间负 Softplus)──> α ∈ (0,1) 标量 ├─ W_β(线性投影 + Sigmoid)────────────> β ∈ (0,1) │ 递归/分块计算 gated delta rule ──> õ ├─ W_g ─ SiLU ─────────────────────────> 输出门 └─ y = W_o( Sigmoid(W_g x) ⊙ RMSNorm(õ) ), 再接 SwiGLU MLP + 残差

要点：q/k 依次经过 ShortConv、SiLU 与 L2Norm，分别提供局部上下文与归一化后的稳定擦除；$\alpha$ 与 $\beta$ 是标量，只需线性投影，不经过卷积；输出门沿用 Mamba 的 SiLU 门设计，K3 将其升级为满秩。

2.1 ShortConv

ShortConv（Short Convolution，短因果深度卷积）出自 Kimi Linear（K3 技术报告引用 [64]），位于 Q/K/V 线性投影之后、进入 KDA 递归之前——顺序是 $x \to W_{q/k/v} \to \mathrm{ShortConv} \to \dots$，即卷积是「KDA 前置」而非「投影前置」。它只捕捉当前 token 之前少量的局部上下文，不引入未来 token 信息；且在 Kimi Linear / FLA 实现里卷积不是裸用的，后面紧跟 SiLU：$\mathrm{silu}(\mathrm{conv}(x))$。

输入单头向量 $x_t \in \mathbb{R}^d$，卷积核窗口大小 W（标准取 4），深度可分离（depthwise）且因果：

$$\mathrm{ShortConv}(x)_t = \sum_{j=0}^{W-1} w_j \odot x_{t-j}$$

记号	含义
$w_j \in \mathbb{R}^d$	每通道独立卷积权重——depthwise，每个特征通道一套独立卷积核
$\odot$	逐元素相乘
因果约束	$t - j \ge 0$；$t < j$ 时零填充，看不到未来 token

三个性质决定了它为什么放在这个位置：

1. 时序维度滑动，只混合最近 W 个历史 token，开销远小于全局注意力；
2. depthwise：$w_k$ 与 $x_{t-k}$ 逐通道相乘，通道间不混——局部上下文的注入不破坏各通道独立的衰减语义（与 $\mathrm{Diag}(\alpha_t)$ 逐通道门配套）；
3. 因果：$t-j \ge 0$ 保证只看历史，$t<j$ 时零填充，LLM 自回归必备。

其作用是补足线性 RNN 缺失的局部建模能力：递归状态只携带压缩后的全局历史，最近若干 token 的精细局部模式（词内字符、短程搭配）由这层卷积负责。

2.2 Swish 与 SiLU

ShortConv 之后、L2Norm 之前是 SiLU，即 Swish——严格说 Swish 带可学参数时为 $x \cdot \sigma(\beta x)$，论文和实现里固定 $\beta = 1$，两个名字就此等价：

$$\mathrm{Swish}(x) = x \cdot \sigma(x), \qquad \sigma(x) = \frac{1}{1 + e^{-x}}$$

计算分两步：其一，对输入的每个元素计算 $\sigma(x) = 1/(1+\exp(-x))$；其二，原输入 x 与 sigmoid 结果逐元素相乘得到输出。Swish = 输入 × 输入自己的 sigmoid 门——自门控（self-gated）：门控信号不是外部来的，是输入自身，免参数。

此处使用它的原因有两点：其一，平滑且非单调（负区间存在小幅下凹，$x \to -\infty$ 时输出趋于 0，而非 ReLU 的硬截断），梯度处处非零，深层网络训练更稳定；其二，门控形式与整个 block 的「信息通过与抑制」语义一致，Q/K/V 进入递归状态前先经过一次自门控，相当于对局部卷积混合后的特征做一次软筛选，随后由 L2Norm 归一化到单位范数。K3 将输出侧的这道门升级为满秩输入相关门，其来源即此处的 SiLU。

2.3 L2Norm

Q/K 支路的最后一步。对单头向量 $\bm{z} \in \mathbb{R}^{d_k}$，逐通道 L2 标准化到单位范数：

$$\mathrm{L2Norm}(\bm{z}) = \frac{\bm{z}}{\|\bm{z}\|_2 + \epsilon}, \qquad \|\bm{z}\|_2 = \sqrt{\sum_{i=1}^{d_k} z_i^2}$$

记号	含义
$\epsilon$	极小防除零常数（$10^{-6}$ 左右）
操作维度	每个注意力头独立归一化，跨头不共享统计

为什么只有 Q/K 使用、V 不使用？回到 §1.1 的结论：归一化后 $\|k_t\|_2 = 1$，于是 delta rule 的擦除矩阵 $I - \beta k k^\top$ 的特征值落在 $[1-\beta,\ 1]$ 区间内，写入步长因此稳定，$\beta = 1$ 时为精确的保长反射。Q 也做归一化，目的是使读出 $o = S^\top q$ 的尺度可控：query 与 key 的范数均为 1，内积才具备可比性，chunkwise 公式中 $QK^\top$ 的 score 也被限制在 $[-1, 1]$ 内。V 不做归一化，因为写入内容的幅值本身携带信息，且 $\beta_t k_t v_t^\top$ 的稳定性由 k 侧保证，与 v 的尺度无关。这与 softmax 注意力中 QK-norm 防止 logit 爆炸的动机同源，但在线性 RNN 中它还额外承担擦除操作的数值稳定性，因此归一化并非可选优化，而是 delta rule 正常工作的前提。

至此 Q/K 支路的四步全部交代完毕：Linear 投影、ShortConv（局部混合）、SiLU（软筛选）、L2Norm（归一化）。这几步均为因果、逐通道操作，不涉及跨头统计，与 $\mathrm{Diag}(\alpha_t)$ 的逐通道语义一致。三者各自负责一部分数值稳定性：ShortConv 负责局部混合，L2Norm 负责幅度稳定，逐通道衰减差 $\gamma_i - \gamma_j \le 0$ 负责指数项不溢出。这条全链路的数值稳定性是 KDA 能在 BF16 下训练的前提。

混合架构：GDN + 滑窗注意力（H1）或 Mamba-2 + GDN + SWA（H2）交错堆叠，互补长短程建模能力，与 K3 的「3 KDA + 1 MLA」思路一致，GDN 论文可视为这一混合范式的早期工作。

3. 从 GDN 到 KDA：K3 继承了什么、改了什么

维度	GDN	KDA（Kimi Linear → K3）	动机
更新式	$S_{t-1}(\alpha_t(I-\beta kk^\top)) + \beta vk^\top$	$(I-\beta kk^\top)\,\mathrm{Diag}(\alpha_t)S_{t-1} + \beta vk^\top$	α 从标量 → 逐通道向量
遗忘门粒度	标量（整头同一衰减率）	向量 $\alpha_t\in(0,1)^{d_k}$	长期记忆通道与短期工作区分离
门作用顺序	α 在外乘整个更新	Diag(α) 在内侧先衰减 S，再删写	与逐通道参数化配套（KCP 推导需要）
α 参数化	负 Softplus，值域 $(-\infty,0)$	K3：缩放 sigmoid，下界 $g_{\min}=-5$	$1/\Gamma$ 有界 → 对角 tile 全走 Tensor Core
chunkwise	WY + UT + 衰减箭头	同框架，Γ 从标量比变成向量累积比	表达力↑ 数值难度↑（K3 用下界解决）
输出门	低秩/简单门	K3：输入相关全秩 sigmoid 门	逐通道调节读出

两处容易忽略的改动：

1. 作用顺序变了：GDN 是 $S(\alpha(I-\beta kk^\top))$（α 吸进 Householder 连乘），KDA 是 $(I-\beta kk^\top)\mathrm{Diag}(\alpha)S$（α 先作用、再删写）。KDA 的逐通道门是矩阵 $\mathrm{Diag}(\alpha)$，与 Householder 不交换，顺序成为实质设计选择——它使 KCP 的「段转移分解」成为可能。
2. 衰减在 Γ 处的复杂化：GDN 的 γ 是标量连乘，$\Gamma_{ij} = \gamma_i/\gamma_j$ 只是数；KDA 的 Γ 是向量逐元素累积，chunk 公式里 K/Γ、Q⊙Γ 等运算随之复杂化，数值范围问题（$1/\Gamma$ 溢出）由此而生——K3 的下界衰减正是对 GDN→KDA 这一步引入的新问题的修复。

3.1 SSM 路线的结论

SSM 从控制论的状态方程出发，经 ZOH 离散化、S4、Mamba 到 Mamba-2，推导过程见前置篇第 2 节。本文需要的只是其结论：乘在旧状态上的标量衰减系数 $\alpha_t$，即线性注意力一族对「状态如何遗忘」的回答，但它是全局衰减、不区分通道。它与 DeltaNet 的定点覆写在 GDN 处结合，GDN 又被 KDA 逐通道化。整体骨架始终不变：

$$\text{状态} \times (\text{衰减/删除算子}) + (\text{写入项})$$

3.2 KDA 的递推公式

本节回到主约定（$\mathbf{S}_t \in \mathbb{R}^{d_k\times d_v}$，读出 $\mathbf{S}_t^\top\bm q_t$），与 KDA 论文写法一致：

$$\mathbf{S}_t = \left(\mathbf{I} - \beta_t \bm{k}_t \bm{k}_t^\top\right) \operatorname{Diag}(\bm{\alpha}_t)\, \mathbf{S}_{t-1} + \beta_t \bm{k}_t \bm{v}_t^\top$$

$$\tilde{\bm{o}}_t = \mathbf{S}_t^\top \bm{q}_t$$

符号说明，沿用论文定义：

符号	含义
$\bm{\alpha}_t \in \mathbb{R}^{d_k}$	逐通道一维保留因子向量（channel-wise one-step retention factor）
$\operatorname{Diag}(\bm{\alpha}_t)$	向量转对角矩阵算子，把通道级衰减系数变成矩阵乘
$\mathbf{I}$	同维度单位矩阵
$\beta_t \in (0,1)$	delta rule 写入强度

该式包含三步操作，按从右往左的顺序：

1. 通道衰减：$\operatorname{Diag}(\bm{\alpha}_t)\mathbf{S}_{t-1}$ 等价于对 $\mathbf{S}_{t-1}$ 的每一行分别乘以对应通道的 $\alpha$ 系数——逐通道缩放历史记忆。普通线性注意力/SSM 大多全局统一衰减（$\alpha_t$ 是标量），KDA 给每一个 key 通道分配独立衰减权重：不同语义通道可以选择更快/更慢遗忘 $\mathbf{S}_{t-1}$；
2. 方向擦除：$\left(\mathbf{I} - \beta_t \bm{k}_t \bm{k}_t^\top\right)$ 再对衰减后的状态做当前 token 的定点擦除（秩 1 Householder 型，详见 §1.1）；
3. 新信息写入：叠加 $\beta_t \bm{k}_t \bm{v}_t^\top$。

三步合起来：先通道衰减，再方向擦除，最后写入——带通道精细遗忘的 delta 递推。作用顺序是设计选择：Diag 与 Householder 不交换，这个顺序使 KCP 的段转移分解成为可能。

记号约定：论文里大写 $\operatorname{Diag}(\cdot)$ 是「向量 → 对角矩阵」算子；小写 $\operatorname{diag}(\cdot)$ 有时指反向操作（输入矩阵、提取对角线为向量）。本文全程大写表示向量转对角矩阵。

3.3 为什么是逐通道门：动机与在线学习视角

标量门的表达力瓶颈。GDN 的 $\alpha_t \in (0,1)$ 是标量：每一步遗忘时，所有 key 通道以同一个比例衰减——要么一起记住，要么一起忘记。但不同通道承担的角色不同：

• 有的通道在存「长期主题」（希望 $\alpha \approx 1$，几乎不遗忘）；
• 有的通道在存「临时指针」（希望快速衰减，腾出容量）。

KDA 的核心改动只有一处：把标量换成向量 $\bm{\alpha}_t \in (0,1)^{d_k}$（$\beta_t$ 仍是标量，这是 KDA 的选择而非必须）。直觉：S 的第 j 列对应 key 空间的第 j 个通道，$\mathrm{Diag}(\alpha_t)$ 作用上去就是给每一列配一个独立的遗忘速度。GDN 是 KDA 在 $\mathrm{Diag}(\alpha_t) = \alpha_t I$ 时的特例。

在线学习视角：逐通道权重衰减的 delta rule。与 §1.2 的在线学习表同构，只需把正则项换成逐通道版。每步给定新样本 $(k_t, v_t)$，希望新状态 S 满足两点：其一，拟合新样本 $Sk_t \approx v_t$；其二，不过度偏离「衰减后的历史记忆」$S \approx S_{t-1}\mathrm{Diag}(\alpha_t)$（以下记 $D_t = \mathrm{Diag}(\alpha_t)$，$\alpha_t = \exp(g_t)$，$g_t \in \mathbb{R}_{<0}^{d_k}$）：

$$\mathcal{L}_t(S) = \underbrace{\tfrac12 \|S k_t - v_t\|^2}_{\text{拟合}} + \underbrace{\tfrac12 \|S - S_{t-1} D_t\|_F^2}_{\text{逐通道正则}}$$

从 $S_{t-1}D_t$ 出发对第一项做一步梯度下降（步长 $\beta_t$）：

$$S_t = S_{t-1}D_t - \beta_t\,(S_{t-1}D_t\, k_t - v_t)\,k_t^\top = S_{t-1} D_t (I - \beta_t k_t k_t^\top) + \beta_t v_t k_t^\top$$

正是递推式（转置约定下）。逐通道正则的含义：第 j 列的「信任区域」宽度正比于 $\alpha_t^{(j)}$——$\alpha$ 小的通道，旧记忆先被压缩，新写入覆盖几乎没有阻力（快遗忘）；$\alpha \approx 1$ 的通道，旧记忆原样进入下一步，delta rule 只做精细增量（慢遗忘）。这就是「细粒度记忆控制」的优化论表述：KDA = 逐通道权重衰减 + delta rule。

实现注意：作用顺序不可颠倒。$D_t$ 作用于整个 $S_{t-1}$、先于擦除项——擦除时检索用的也是已衰减的状态：

$$S_t = \underbrace{S_{t-1} D_t}_{\text{先衰减}}\underbrace{(I - \beta_t k_t k_t^\top)}_{\text{再擦除/写入}}$$

写成 $S_{t-1}(I-\beta kk^\top)D_t$（顺序颠倒）或只衰减单位阵部分都是错的——$D_t$ 与 $(I - \beta kk^\top)$ 不可交换，顺序错了结果就错（与 §1.2「α 乘整个括号」的警告同源，但逐通道化之后错误更隐蔽）。FLA 参考实现里对应 S = S * g.exp() 之后立刻用衰减后的 S 做检索 v - k^T S。

3.4 下界衰减（Lower-bounded decay）

KDA 的衰减参数化是一个关键改进。Kimi Linear 使用无界的负 Softplus 映射 $g = -e^A \text{Softplus}(z) \in (-\infty, 0)$，而 K3 改用有界缩放 sigmoid：

$$g_t^h = g_{\min} \cdot \text{Sigmoid}(e^{A_h} z_t^h) \in (g_{\min}, 0)$$

其中 $g_{\min} = -5$ 固定，$A_h$ 是可学习的每头对数尺度。这意味着每个保留因子满足 $\alpha > e^{-5} \approx 6.7 \times 10^{-3}$，16 token 块的累积对数衰减落在 $(-80, 0)$ 内，对应的重缩放因子小于 $e^{80}$，在 BF16 动态范围内。

计算收益：有限范围使得因果对角块和离对角块都能用密集 Tensor Core 矩阵乘法，消除了 Kimi Linear 中需要的 position-pair 对角计算路径。

$1/\Gamma$ 溢出：向量门控引入的数值问题

为什么这个修复在 GDN 上不必要、在 KDA 上变成刚需？GDN 的标量衰减在 chunkwise 里只以比值出现($\prod_{s=j+1}^{i}\alpha_s \le 1$，$i \ge j$)，天然安全。KDA 把 $\Gamma$ 变成向量累积 $\Gamma_t = \exp(\sum_{s\le t} g_s)$，逐通道独立：第 4 步式的推导可以刻意只用 $i \ge j$ 的差（指数 $\le 0$，安全）；但只要换一种等价写法——把状态「反归一化」回 chunk 起点、或把衰减从 key 上整体外提（论文公式 (4) 的 $K/\Gamma$ 因式分解正是这种写法）——就得真的算出

$$\Gamma_t^{-1} = \exp\Big(-\sum_{s \le t} g_s\Big) \quad \text{(逐通道)}$$

衰减越快的通道，$-\gamma_t$ 越大，$1/\Gamma$ 呈指数膨胀。具体量级如下：

恒定 $\alpha$	$t=100$	$t=500$	$t=1000$	$t=2000$
0.9	$3.8\times10^{4}$	$7.6\times10^{22}$	$5.7\times10^{45}$	$3.3\times10^{91}$
0.5	$1.3\times10^{30}$	$3.3\times10^{150}$	$1.1\times10^{301}$	溢出 float64
0.1	$10^{100}$	溢出	溢出	溢出

float64 上界约 $e^{709} \approx 1.8\times10^{308}$；BF16 训练下数十步即会溢出。标量推广为向量后，衰减率的动态范围被放大，数值溢出由个别情形变为普遍现象，因此必须对衰减率本身设置边界。

Kimi Linear 的规避方案：在对数空间算相对衰减（减法代替除法，不溢出），并把每个 chunk 再切成 16 token 的二级瓦片。效果：瓦片之间（非对角块）可以安全交给 Tensor Core 稠密矩阵乘；但瓦片内部（对角块）衰减可能极端，仍需按位置对显式计算，position-pair 路径无法组织成大矩阵乘，Tensor Core 利用率低，成为块内主要瓶颈。

K3 的解决方式：不修改公式，而是修改参数化，使溢出在数学上不可能发生（负 Softplus 允许 $\alpha$ 任意接近 0，即「一步清零」；缩放 sigmoid 不允许）。

表达力为何不受损：快通道在瓦片内仍可将记忆衰减到 $e^{-80} \approx 10^{-35}$（数值上接近零，但并非严格为零）；长期遗忘靠多步连乘（每步乘 $0.0067$），数十步后衰减量已足够小，不需要单步清零的能力。以一个衰减下界换取全链路 Tensor Core 化，是有利的取舍。

3.5 满秩门控（Full-rank gate）

K3 将 KDA 的输出门从低秩参数化改为输入相关的满秩投影。在递推输出经过 head-wise RMSNorm 后，应用数据相关的输出门控：

$$y_t = W_o [\text{Sigmoid}(W_g x_t) \odot \text{RMSNorm}(\tilde{o}_t)]$$

满秩门控允许每个 token 独立调制从循环状态读取的通道。

4. KDA 的 Chunkwise 并行形式

递推形式在推理阶段是优势——$O(1)$ 状态更新；但在训练与 prefill 阶段成为瓶颈：每个 token 的状态依赖前一个 token，顺序循环使 GPU 的数千个核心无法并行工作。Chunkwise 并行化把序列切成长度 C 的块：块内矩阵运算并行，块间只传状态。先看通用的复杂度框架，再看 KDA 逐通道门带来的推导细节。

通用框架。Chunk 内：token 交互用带衰减的因果注意力直接算，$O(C^2 d)$——C 是常数(64/128)，对序列长度 N 线性。Chunk 间：每个 chunk 对状态做一次递推更新，chunk 内外积先归约成固定大小的 state 增量，块间只传 $d \times d$ 的 state。总计算量：

$$\underbrace{O\big(N \cdot C \cdot d\big)}_{\text{chunk 内注意力}} + \underbrace{O\big(N/C \cdot d^2\big)}_{\text{chunk 间状态更新}} \;=\; 2Nd^2(\text{固定项}) + 2NCd$$

C	形态	复杂度
$C = 1$	每个 token 一个 chunk，chunk 内注意力消失	纯线性注意力递推，FLOPs 最少但不一定最快（GPU 对小矩阵乘利用率低）
$C = N$	整个序列一个 chunk，递推消失	标准 $O(N^2)$ 注意力

实践中 C 取 64 或 128：足够小以控制 chunk 间项的开销，足够大以让 $C\times C$ 注意力矩阵填满 Tensor Core 的 tile。这与 S4 时期「训练用卷积、推理用递归」的双形式思路一致：选择性打破 LTI 后，chunkwise 就是卷积的继任者。

4.1 逐通道衰减下的 WY 表示与 UT 变换

记 chunk 起点传入状态 $S_{[0]}$（以下用局部下标 $i = 1..C$；乘积按时间倒序）。核心记号是累积 log 衰减：

$$\gamma_i = \sum_{s=1}^{i} g_s \in \mathbb{R}^{d_k}, \qquad \Gamma_{i \leftarrow j} = \operatorname{diag}\big(\exp(\gamma_i - \gamma_j)\big) \quad (i \ge j)$$

$\Gamma_{i\leftarrow j}$ 是「从第 j 步衰减到第 i 步」的逐通道算子。两条性质：$i \ge j$ 时 $\gamma_i - \gamma_j \le 0$ 逐分量成立（$g_s < 0$），元素都在 $(0,1]$，数值安全；反向 $\Gamma_{j\leftarrow i}^{-1}$ 的元素 $\ge 1$ 且随 chunk 长度指数增长——这是 $1/\Gamma$ 爆炸的根源，先记住这个观察。

第一步：衰减 KKT 矩阵 M。类比 GDN chunkwise 里的普通 $k_i^\top k_j$，逐通道版需要带衰减的 key-key 内积：

$$M_{ci} = \big(k_c \odot e^{\gamma_c - \gamma_i}\big)^\top k_i, \qquad 1 \le i < c \le C$$

含义：$k_i$ 写入的记忆衰减到第 c 步时，与 $k_c$ 的重叠程度。Hadamard 积 $\odot$ 作用在 key 通道维——正是逐通道衰减出现的位置。

第二步：UT 变换。构造严格下三角 $L$：$L_{ci} = \beta_i M_{ci}\ (c > i)$，求 $T = (I+L)^{-1}$（幂零，有限项截断；实践中不显式求逆，前代法逐行解），再每列乘 $\beta_j$ 得 $\hat{A} = T\,\operatorname{diag}(\beta)$。FLA 实现中的三行循环，数学上即求解 $(I+L)T = I$。

与 GDN 对照：GDN 这一步的 M 是普通 $k_c^\top k_i$（标量衰减被拆成比值吸收进别的项）；KDA 里衰减「长」在 M 内部，无法外提——这是向量门控带来的结构性变化，KDA chunkwise 推导的核心难点。

第三步：WY 表示：

$$W = \hat{A}\,\big(e^{\gamma_i} \odot k_i\big)_{i=1..C} \in \mathbb{R}^{C \times d_k}, \qquad U = \hat{A}\,V \in \mathbb{R}^{C \times d_v}, \qquad \tilde{V} = U - W\,S_{[0]}^\top$$

伪值 $\tilde V$ 的含义。UT 变换产出 U 和 W，由它们定义 $\tilde V := U - WS$。三个符号的角色如下：

符号	形状	角色
$S_{[0]}$	$d_k \times d_v$	历史记忆：chunk 之前所有 token 写入的内容，块内计算时固定不变
$W$	$C \times d_k$	历史读取算子：每行是某位置的衰减 key 修正组合；$WS$ 表示该位置能从历史记忆中读到的内容
$U$	$C \times d_v$	块内互扣后的写入目标：$\hat A$ 作用于 V，块内写入之间的重叠已扣除
$\tilde V$	$C \times d_v$	实际写入的净增量 = 写入目标减去（历史记忆已有部分 + 块内其他位置已写部分）

称其为「伪」值的原因：它们并非真实的 v（手算例子中 $\tilde v_2 = (-2,2) \ne v_2$），而是扣除全部重叠后可直接累加、无需再做修正的增量。这与单步 delta rule 一致：单步写入为 $v_t - S_{t-1}^\top k_t$，即目标值减去历史读数；$\tilde V$ 是其 chunk 并行版本，每行给出该位置真正新增的部分。重叠在 $\tilde V$ 中已扣除完毕，后续的块内注意力 $A\tilde V$ 与状态更新才能以单次矩阵乘完成。

第四步：输出与跨 chunk 状态：

$$A^{qk}_{cj} = \big(q_c \odot e^{\gamma_c - \gamma_j}\big)^\top k_j \ (j \le c), \qquad o_c = \underbrace{S_{[0]}\,(q_c \odot e^{\gamma_c})}_{\text{块间：衰减后的 query 检索历史状态}} + \underbrace{\sum_{j \le c} A^{qk}_{cj}\,\tilde v_j}_{\text{块内:衰减注意力}}$$

$$S_{[C]} = S_{[0]}\,\Gamma_{C\leftarrow 0} + \sum_{c=1}^{C} \tilde v_c \big(k_c \odot e^{\gamma_C - \gamma_c}\big)^\top$$

出口状态读法：旧状态整体按整 chunk 累积衰减缩小；每个伪值以「写入时刻衰减到块末」的 key 为地址写入。所有指数都是 $\le 0$ 的差，整条链路没有一个 $\ge 1$ 的因子——刻意保持，原因见下界衰减一节。

4.2 数值验算（$d_k = d_v = 2$，C = 2）

零初始状态，每步恒定衰减 $\alpha = (0.5, 0.25)$（即 $g = (\ln 0.5, \ln 0.25)$），β 取 1：

$$k_1 = \binom{1}{1},\ v_1 = \binom{2}{0};\quad k_2 = \binom{1}{2},\ v_2 = \binom{0}{2};\quad q_1 = q_2 = \binom{1}{1}$$

递推式。第 1 步（$S_0 = 0$）：$S_1 = v_1k_1^\top = \begin{pmatrix}2&2\\0&0\end{pmatrix}$，$o_1 = (4,0)$。第 2 步，$D = \mathrm{diag}(0.5, 0.25)$，先衰减 $S_1D = \begin{pmatrix}1&0.5\\0&0\end{pmatrix}$（第 1 列 ×0.5、第 2 列 ×0.25——逐通道在动），再擦除写入：

$$S_1D(I - k_2k_2^\top) = \begin{pmatrix}-1&-3.5\\0&0\end{pmatrix}, \qquad S_2 = \begin{pmatrix}-1&-3.5\\2&4\end{pmatrix}, \qquad o_2 = (-4.5,\ 6)$$

Chunkwise。$e^{\gamma_1} = (0.5, 0.25)$，$e^{\gamma_2} = (0.25, 0.0625)$，$e^{\gamma_2-\gamma_1} = (0.5, 0.25)$。衰减 KKT：$M_{21} = (k_2 \odot e^{\gamma_2-\gamma_1})^\top k_1 = (0.5, 0.5)\cdot(1,1) = 1$。UT：$L = \begin{pmatrix}0&0\\1&0\end{pmatrix}$，$T = I - L = \begin{pmatrix}1&0\\-1&1\end{pmatrix}$，$\hat A = T$。WY：

$$W = \hat A\begin{pmatrix}0.5&0.25\\0.25&0.125\end{pmatrix} = \begin{pmatrix}0.5&0.25\\-0.25&-0.125\end{pmatrix}, \quad U = \hat A\begin{pmatrix}2&0\\0&2\end{pmatrix} = \begin{pmatrix}2&0\\-2&2\end{pmatrix}$$

伪值（$S_{[0]}=0 \Rightarrow \tilde V = U$）：$\tilde v_1 = (2,0)$，$\tilde v_2 = (-2,2)$。注意 $\tilde v_2 \ne v_2$：因为 $k_2$ 与衰减后的 $k_1$ 写入重叠（$M_{21} = 1 \ne 0$），WY 把 $v_2$ 修正为扣除重叠后真正的新增——单步 delta rule 的 chunk 版样子。衰减注意力与输出：

$$A^{qk} = \begin{pmatrix}2&0\\0.75&3\end{pmatrix}, \qquad o_1 = 2\tilde v_1 = (4,0)\ \checkmark, \qquad o_2 = 0.75\,\tilde v_1 + 3\,\tilde v_2 = (-4.5,\ 6)\ \checkmark$$

块末状态：$S_{[2]} = \tilde v_1(k_1 \odot e^{\gamma_2-\gamma_1})^\top + \tilde v_2 k_2^\top = \begin{pmatrix}-1&-3.5\\2&4\end{pmatrix}$ $\checkmark$ 与递推式逐项一致。（随机对拍：非零初始状态、随机门控下递推 vs chunkwise 最大误差 $10^{-9}$ 量级。）

4.3 与论文公式 (4) 的对照

K3 报告（沿用 Kimi Linear）用乘积记号：$\gamma_{i\to j} = \prod_{r=i}^{j}\alpha_r = \exp(\sum_{r=i}^j g_r)$；$\Gamma \in \mathbb{R}^{C\times d_k}$ 把各步 $\gamma$ 按行堆叠（注意 $\Gamma$ 本身不是对角阵，每个位置 $r$ 的 $\mathrm{diag}(\gamma_r)$ 才是遗忘对角阵，$\Gamma$ 是 C 个对角阵的打包）。论文状态约定 $S \in \mathbb{R}^{d_k \times d_v}$（本文的转置），其公式 (4)：

$$A = \mathrm{Tril}\big[(Q\odot\Gamma)(K/\Gamma)^\top\big], \qquad O = \underbrace{(\Gamma\odot Q)S}_{\text{块间}} + \underbrace{A\,\tilde V}_{\text{块内}}$$

为什么 A 能这样拆：看 $(i,j)$ 元素 $A_{ij} = \sum_d q_{i,d}\gamma_{i,d}\cdot k_{j,d}/\gamma_{j,d} = (q_i \odot \gamma_{j\to i})^\top k_j$，与 $A^{qk}$ 逐元素相同——逐对位置的衰减比值被因式分解成 query 侧乘 Γ、key 侧除以 Γ 两个逐位置操作，整个 $C\times C$ 矩阵 = 一次稠密 matmul + 两次逐元素乘，完全并行。Tril 保留对角线：delta rule 里 $o_i$ 读的是写入当前 token 之后的状态。

用上面的例子核对：$Q\odot\Gamma = \begin{pmatrix}0.5&0.25\\0.25&0.0625\end{pmatrix}$，$K/\Gamma = \begin{pmatrix}2&4\\4&32\end{pmatrix}$，乘积 Tril 后 $A = \begin{pmatrix}2&0\\0.75&3\end{pmatrix}$，与上面 $A^{qk}$ 一致。注意 $K/\Gamma$ 里已出现 32 这种被放大的数——$1/\Gamma$ 的膨胀就藏在这一步，数值后果见下界衰减一节。

$C$ 与 $d_k$ 是否存在倍数关系？ 不存在。C 是序列轴的切分（一个 chunk 装多少 token），$d_k$ 是特征轴的宽度，两根轴独立。有整除要求的是：K3 把 chunk 再切成 16 token 二级瓦片，故 C 需是 16 的倍数；$d_k$、$d_v$ 按 Tensor Core 友好尺寸取是工程约束，不是数学要求。

KDA 的核心优势是：相比传统 softmax attention，它是线性复杂度的；相比纯粹的线性 RNN，它通过 delta rule 实现了更强大的信息写入和遗忘控制。

4.4 速查表（KDA 与 GDN）

维度	内容
状态	S ∈ R^{d_v×d_k}（论文记法），固定大小，每序列每头一份
更新	S = S(α(I-βkkT)) + βvkT，全局衰减 α 与定点覆写 δ 的组合
读出	o = Sq，后接 RMSNorm + sigmoid 输出门
α	GDN 标量 / KDA 逐通道，数据相关；β：sigmoid
q/k	Linear → ShortConv → SiLU → L2Norm
等价视角	在线最小二乘 SGD（β 为学习率）+ 自适应权重衰减（α）
并行训练	chunkwise：WY 表示（W 无 γ / Ũ 有 γ）+ UT 变换（下三角求逆）+ 衰减箭头
chunk 输出	O = Q⃖S0T + (QKT ⊙ Γ_causal)(Ũ - W⃖S0T)
chunk 状态	S_C = γ_C S0 + (Ũ→ - W→S0T)TK
记忆瓶颈的应对	覆写（δ）解决叠加干扰；全局衰减（α）解决长期累积
后继	KDA：α→逐通道、换作用顺序、加下界 → 进 K3

---

参考：

• Yang, Kautz & Hatamizadeh, Gated Delta Networks: Improving Mamba2 with Delta Rule, arXiv:2412.06464（GDN 出处，ICLR 2025）
• Kimi K3 Technical Report, arXiv:2607.24653（KDA 出处）
• Gu & Dao, Mamba: Linear-Time Sequence Modeling with Selective State Spaces, arXiv:2312.00752
• Gu et al., Efficiently Modeling Long Sequences with Structured State Spaces (S4), arXiv:2111.00396
• Katharopoulos et al., Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention, arXiv:2006.16236