Kimi Delta Attention (KDA) 详解

Chase Woo2026-07-202026-07-31

现在模型推理的瓶颈正在逐渐从模型能不能回答转向 模型能不能以足够低的成本持续回答 ，Kimi 团队据此提出 Kimi Linear。它并没有完全抛弃全注意力，而是将新的线性注意力模块 Kimi Delta Attention（KDA） 与 MLA 全局注意力层按照 3:1 的比例进行混合。KDA 通过通道级遗忘机制和 Delta Rule，更精细地控制哪些历史信息需要保留、更新或删除；同时，论文还针对其特殊状态转移结构设计了高效的 Chunkwise 并行算法，使其能够更充分地利用 GPU 的矩阵计算能力。

Kimi Linear: An Expressive, Efficient Attention Architecture

一、背景

1. 全注意力面临长上下文瓶颈

标准 Softmax Attention 在序列长度为 $L$ 时，注意力矩阵大小为 $L\times L$，因此：

Prefill 计算复杂度近似为 $O(L^2)$；
解码时，每生成一个 token 都要访问历史 KV；
KV Cache 会随上下文长度线性增长；
在 Agent、工具调用、长轨迹推理和 RL Test-time Scaling 中，推理成本非常高。

当上下文扩展到几十万甚至一百万 token 时，全注意力的计算量、显存占用和通信成本都会成为瓶颈。

2. 传统线性注意力能力不足

线性注意力不显式保存所有历史 KV，而是将历史信息压缩进固定大小的状态矩阵：

$$
S_t=S_{t-1}+k_tv_t^\top,\qquad o_t=S_t^\top q_t
$$

这样可以把序列建模转化为类似 RNN 的递归计算，理论上解码成本不再随历史长度明显增长。

但它的问题是：所有历史信息都被压缩到有限状态 $S_t$ 中，容易产生：

不同 Key-Value 之间的记忆干扰；
精确复制能力不足；
长距离检索能力弱；
旧信息无法被合理删除；
在短上下文语言建模中也经常不如 Softmax Attention。

因此，线性注意力的核心矛盾并不只是“容量有限”，更在于：

模型能否学习应该写入什么、覆盖什么、遗忘什么，以及不同类型的信息应该保留多久。

Kimi 将这个问题定义为：如何在显著降低速度和显存开销的同时，使线性注意力达到或超过全注意力的模型质量。

二、动机

1. 改善有限状态记忆的管理能力

1.1 线性注意力累加

普通线性注意力只是不断累积：

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

没有删除机制，旧信息持续叠加，最终造成记忆冲突。

DeltaNet 将状态更新解释为对 Key-Value 重建损失进行在线梯度下降：

$$
S_t=(I-\beta_tk_tk_t^\top)S_{t-1}+\beta_tk_tv_t^\top
$$

其中：

$\beta_tk_tk_t^\top S_{t-1}$ 用于删除或修正旧映射；
$\beta_tk_tv_t^\top$ 用于写入新的 Key-Value 映射。

原式展开为：

$$
(I-\beta_tk_tk_t^\top)S_{t-1}=S_{t-1}-\beta_tk_tk_t^\top S_{t-1}
$$

含义就是先完整保留旧状态 $S_{t-1}$，再从旧状态中减去一部分与当前 $k_t$ 相关的记忆。

其中：

$$
k_t^\top S_{t-1}
$$

表示用当前 Key $k_t$ 从旧状态中读出的 Value 预测：

$$
\hat v_t=S_{t-1}^\top k_t
$$

而：

$$
k_tk_t^\top S_{t-1}
$$

表示把“当前 Key 对应的旧记忆”定位出来。

所以：

$$
I-\beta_tk_tk_t^\top
$$

可以理解为一个记忆修正矩阵：

$I$：保留原来的全部记忆；
$\beta_tk_tk_t^\top$：删除或削弱与当前 $k_t$ 方向相关的旧记忆；
$\beta_t$：控制删除强度。

如果我们从 Delta Rule 的角度理解，则完整更新为：

$$
S_t=(I-\beta_tk_tk_t^\top)S_{t-1}+\beta_tk_tv_t^\top=S_{t-1}+\beta_tk_t\left(v_t^\top-k_t^\top S_{t-1}\right)
$$

括号中的：

$$
v_t^\top-k_t^\top S_{t-1}
$$

就是：

$$
\text{真实 Value}-\text{旧状态预测的 Value}
$$

也就是预测误差。

1.2 标量遗忘门

Gated DeltaNet 又增加一个标量遗忘门：

$$
S_t=\alpha_t(I-\beta_tk_tk_t^\top)S_{t-1}+\beta_tk_tv_t^\top
$$

但这里的 $\alpha_t$ 通常是一个 head 级标量，即一个注意力头中的所有特征维度采用相同的遗忘率。

作者认为这种遗忘机制过于粗糙：一个头内部可能同时存储局部语法、实体信息、位置关系和长程语义，它们不应该以相同速度衰减。

2. 解决表达能力强但算子不快的问题

更细粒度的 DPLR、GLA 类状态转移虽然表达能力更强，但实现时常需要对数域计算、二级分块、FP32 中间运算、更多矩阵乘法、额外数值稳定处理。因此，理论复杂度低并不等于 GPU 上实际运行快。

Kimi 希望同时完成两件事：

增强线性注意力的表达能力；
设计能够真正利用 Tensor Core 和半精度矩阵乘法的实现。

3. 不追求纯线性，而追求整体最优

作者承认纯线性注意力在精确检索和复制上仍有结构性限制。因此，论文没有完全删除全注意力，而是保留少量全局 MLA 层：

KDA 负责高效压缩、局部与时序建模；
MLA 负责全局访问和精确检索；
通过混合架构取得质量与效率的平衡。

三、方法

1. Kimi Delta Attention

KDA 的核心更新公式是：

$$
S_t=(I-\beta_tk_tk_t^\top)\operatorname{Diag}(\alpha_t)S_{t-1}+\beta_tk_tv_t^\top\in\mathbb{R}^{d_k \times d_v},\qquad o_t=S_t^\top q_t\in\mathbb{R}^{d_v}
$$

1.1 Channel-wise 遗忘

Gated DeltaNet 对一个注意力头只使用一个标量遗忘系数，同一头内的所有特征维度只能以相同速度衰减。与 Gated DeltaNet 相比，KDA的关键变化是遗忘系数扩展为向量：

$$
\alpha_t\in\mathbb{R}^{d_k}
$$

形成对角矩阵：

$$
\operatorname{Diag}(\alpha_t)
$$

也就是说，每个 Key 通道都有独立的遗忘率。

可以将其直观理解为：

某些通道保存短期局部信息，衰减较快；
某些通道保存实体或任务状态，衰减较慢；
某些通道在遇到新信息时快速覆盖；
另一些通道继续保留较早的信息。

相比整个注意力头同时遗忘，独立遗忘率使得 KDA 可以更精确地分配有限的状态容量。

1.2 Delta Rule（增量规则/误差修正规则）

KDA 不仅有遗忘门，还保留了 Delta Rule 这种在线更新记忆矩阵的方法，它的核心思想是先用当前记忆预测 Value，再根据预测值和真实 Value 之间的误差修正记忆。

KDA 将状态矩阵 $S$ 看作一个 Key 到 Value 的映射：

$$
S^\top k\approx v
$$

输入当前 token 的 Key $k_t$ 后，旧状态给出的预测是：

$$
\hat v_t =S_{t-1}^\top k_t
$$

但当前真正希望记住的 Value 是 $v_t$。因此，预测误差为：

$$
e_t=v_t-\hat v_t =v_t-S_{t-1}^\top k_t
$$

Delta Rule 根据这个误差更新状态：

$$
\boxed{
S_t=S_{t-1}+\beta_tk_te_t^\top
}
$$

代入 $e_t$ ：

$$
S_t=S_{t-1}+\beta_tk_t\left(v_t-S_{t-1}^\top k_t\right)^\top
$$

其中：

$S_{t-1}$ ：旧记忆；
$k_t$ ：当前要修改哪个 Key 方向；
$e_t$ ：当前预测错误了多少；
$\beta_t$ ：更新步长或写入强度。

例如状态中原来保存：$k_A\rightarrow v_{\text{old}}$，当前输入希望更新为：$k_A\rightarrow v_{\text{new}}$，普通线性注意力会把新旧信息直接叠加；Delta Rule 则先根据当前 Key 修正旧映射，再写入新映射。

因此，在原式中：

$\alpha_t$ 控制“哪些通道应该遗忘”；
$\beta_t$ 控制“当前 Key-Value 应该更新多大幅度”；
Delta Rule 负责消除冲突和覆盖旧关联。

两者结合后，KDA 获得了比纯衰减式模型更强的状态更新能力。

1.3 KDA可学习位置编码

Gated Delta 类模型中的连续状态转移矩阵，本身就携带了 token 间的相对位置信息。所以 Kimi Linear 中的全局 MLA 层不使用 RoPE，而采用 NoPE，即不显式加入位置编码，将位置建模责任主要交给 KDA。

与固定 RoPE 相比，它是：

内容相关的；
数据依赖的；
不受正交旋转矩阵约束的；
可自动学习不同维度的时间尺度。

RoPE 使用固定频率旋转矩阵，而 KDA 的状态转移取决于当前 token 产生的 $\alpha_t$, $\beta_t$ 和 $k_t$。因此，其位置偏置能够随内容动态改变。

NoPE 还有两个工程优势：

MLA 在推理时更容易转换为高效 MQA；
扩展上下文时不需要重新调节 RoPE Base 或使用 YaRN 等外推方案。

2. Chunkwise 并行算法

递归状态适合逐 token 解码，但直接递归训练会严重限制 GPU 并行度。

论文将序列划分成多个 chunk：

chunk 之间采用递归状态传递；
chunk 内部采用并行矩阵运算；
使用 WY Representation 压缩一系列 Rank-1 状态变换；
使用 UT Transform 降低非矩阵乘法操作；
将输出拆成 inter-chunk 与 intra-chunk 两部分。

其本质是将多次逐 token 的状态修正和写入转换为少量较大的矩阵乘法，这样能够更充分地利用 GPU Tensor Core。这里需要注意，训练、Prefill、Decode阶段略有不同。

2.1 训练和 Prefill 阶段

输入已经完全知道，因此可以一次性计算所有 token 的 $Q,K,V,\alpha,\beta$

例如一个 chunk 有 $C$ 个 token：

$$
Q,K\in\mathbb{R}^{C\times d_k},\qquad V\in\mathbb{R}^{C\times d_v}
$$

虽然第 $t$ 个 token 的状态依赖前面的状态，但第 $t$ 个 token 的 $q_t,k_t,v_t,\alpha_t,\beta_t$ 已经可以提前计算出来。所以问题变成已知整个 chunk 中所有 token 的参数，能不能不逐个执行状态更新，而是一次性算出所有输出？答案是可以。

我们把 KDA 简写成：

$$
S_t=A_tS_{t-1}+B_t
$$

其中：

$$
A_t=
(I-\beta_tk_tk_t^\top)
\operatorname{Diag}(\alpha_t),\qquad B_t=\beta_tk_tv_t^\top
$$

这里的 $A_t$ 并不是三个固定的模型参数，而是分别由第 t 个 token 动态计算出来的状态转移矩阵。

对于一个包含 $C$个 token 的 chunk，假设输入状态是 $S_0$。

第一个 token：

$$
S_1=A_1S_0+B_1
$$

第二个 token：

$$
S_2=A_2A_1S_0+A_2B_1+B_2
$$

第三个 token：

$$
S_3=A_3A_2A_1S_0
+A_3A_2B_1
+A_3B_2
+B_3
$$

一般形式为：

$$
S_r=
\left(\prod_{i=1}^{r}A_i\right)S_0
+
\sum_{i=1}^{r}
\left(\prod_{j=i+1}^{r}A_j\right)B_i
$$

因此，chunk 内第 $r$ 个位置的状态，可以直接由 chunk 初始状态 $S_0$ 和第1到第 $r$ 个 token 的参数计算出来。在 chunk 边界上，$S_0$ 既可以是当前 chunk 前一个 token 的状态，也可以是前一个 chunk 的最终状态。

假设现在有 4 个 chunk：

1
2
3

Chunk 0：token 1、2、3、4
Chunk 1：token 5、6、7、8
Chunk 2：token 9、10、11、12

其传递过程是：

初始状态
S₀
 ↓
token 1 → token 2 → token 3 → token 4
                                   ↓
                                  S₄
                                   ↓
token 5 → token 6 → token 7 → token 8
                                   ↓
                                  S₈

对于第一个 chunk：$S_{\text{chunk 0}}^{0}=S_0$

对于第二个 chunk：$S_{\text{chunk 1}}^{0}=S_4$

对于第三个 chunk：$S_{\text{chunk 2}}^{0}=S_8$

因此，第二个 chunk 的输入状态是 $S_4$，它既是：

token 4 处理完成后的状态；
chunk 0 的最终状态；
chunk 1 的初始状态。

那么，KDA 是怎么利用 $A_t$ 的特殊结构来做简化的呢？

KDA 的状态转移矩阵不是任意的稠密矩阵，而是：

$$
A_t=
(I-\beta_tk_tk_t^\top)
\operatorname{Diag}(\alpha_t)
$$

它由两部分组成：

对角矩阵 $\operatorname{Diag}(\alpha_t)$；
Rank-1 修正项 $k_tk_t^\top$。

其中 $k_tk_t^\top$ 是一个秩最多为1的矩阵。这种对角矩阵加低秩修正的结构，使一连串状态变换可以被压缩，而不需要真的计算大量完整的矩阵乘法。

论文使用 WY Representation，将一系列 Rank-1 变换压缩为类似：

$$
P_r=\operatorname{Diag}(\gamma_r)-\sum_{i=1}^{r}\operatorname{Diag}(\gamma_{i\rightarrow r})k_iw_i^\top
$$

这里：

$\gamma$ 表示累计衰减；
$k_i$ 是各 token 的 Key；
$w_i$ 是经过变换后的辅助向量。

原本要执行：

$$
A_rA_{r-1}\cdots A_1
$$

现在可以压缩成：

一次通道级衰减；
若干低秩矩阵项；
最终转化为大矩阵乘法。

于是，chunk 的输出写成两部分：

$$
O_{\text{chunk}}=O_{\text{inter}}+O_{\text{intra}}
$$

第一部分：来自前面 chunk 的历史状态

$$
O_{\text{inter}}=(\Gamma\odot Q)S_0
$$

其中：

$Q\in\mathbb{R}^{C\times d_k}$；
$S_0\in\mathbb{R}^{d_k\times d_v}$；
输出形状为 $C\times d_v$。

这一次矩阵乘法会同时计算 chunk 内所有 token 如何读取前面 chunk 保存的历史记忆。

第二部分：来自当前 chunk 内早先 token 的信息

论文公式可以概括为：

$$
O_{\text{intra}}=\operatorname{Tril}(Q’K’^\top)V’
$$

其中 Tril 表示只保留下三角部分。

假设 chunk 有4个 token，对应的因果交互矩阵是：

$$
\operatorname{Tril}(Q’K’^\top)=
\begin{bmatrix}
q_1k_1 & 0 & 0 & 0\
q_2k_1 & q_2k_2 & 0 & 0\
q_3k_1 & q_3k_2 & q_3k_3 & 0\
q_4k_1 & q_4k_2 & q_4k_3 & q_4k_4
\end{bmatrix}
$$

然后一次矩阵乘法：

$$
(C\times C)(C\times d_v)\rightarrow C\times d_v
$$

即可同时得到所有 $C$ 个 token 的输出。

2.2 自回归 Decode 阶段

在 KDA 层的解码阶段，每个新 token 不需要重新访问全部历史 token，而是主要依赖“上一个固定大小的状态 $S_{t-1}$ 以及当前 token 计算出的 $q_t,k_t,v_t,\alpha_t,\beta_t$，计算当前输出并更新为 $S_t$，不需要访问所有历史 token 的 K、V。

KDA 在解码阶段依然需要自回归解码，其优势不是同时生成多个 token，而是：

每次只维护固定大小状态 $S_t$；
不需要遍历全部历史 KV；
状态大小不随上下文长度增长。

因此，Chunkwise 并行主要服务于：

模型训练；
长 Prompt 的 Prefill；
已知完整序列时的批量计算。

Prefill 结束后怎么进行 Decode 的呢？在 Prefill 阶段，KDA 使用 Chunkwise 算法处理整个 Prompt，最后为每个 KDA 层得到 $S_{prompt}$，MLA 层则生成自己的历史KV Cache。随后生成第一个输出 Token，更新为新的 KDA 状态，扩展 MLA KV Cache，再生成第二个 Token，以此类推。