/ Kimi

[Kimi-2] Kimi Linear：用 KDA 重写长上下文注意力

从 Delta Rule、逐通道遗忘与 DPLR 转移出发，推导 Kimi Delta Attention，拆解 3:1 KDA/MLA 混合架构、chunkwise kernel、公平对照实验，以及 1M 上下文下的质量与吞吐取舍。

2026年8月31日15 minKimi · Kimi Linear · Linear Attention · Kimi Delta Attention

Kimi Linear 最醒目的结论是：在相同训练配方和 1.4T token 的对照实验中，它不仅比全 MLA 更省，而且在短上下文、长上下文和 RL 阶段都取得了更好的结果；在 1M 上下文下，KV Cache 最多减少 75%，论文还报告了最高 6.3 倍的解码吞吐。1

但如果只把它概括成“Linear Attention 终于击败 Full Attention”，反而会错过这篇报告最重要的设计判断。Kimi Linear 并不是纯线性模型，而是一个 3:1 的 KDA/MLA 层间混合架构：

KDA -> KDA -> KDA -> MLA
  \___________________/
       repeated

三层 Kimi Delta Attention（KDA）把大部分历史压进固定大小的递推状态，一层 Multi-Head Latent Attention（MLA）保留对完整上下文的全局访问。前者解决成本，后者兜底精确检索。

因此，这篇论文真正回答的是：

能否让固定容量的线性状态更会记、更会忘，再用少量全注意力补回压缩记忆不擅长的能力，从而让混合架构同时跨过质量和效率两道门槛？

本文基于 Kimi Team 发布的《Kimi Linear: An Expressive, Efficient Attention Architecture》v2、官方代码仓库和模型卡展开。1 3

1. Full Attention 与 Linear Attention 在保存什么#

标准 causal attention 会为历史每个 token 保留 key 和 value。生成第 $t$ 个 token 时，query 可以重新访问全部历史：

o_t=\operatorname{softmax}\left(\frac{q_tK_{\le t}^{\top}}{\sqrt d}\right)V_{\le t}.

这种机制的优势是历史仍以 token 粒度存在。模型要找回很久以前的一行代码、一个 UUID 或一句原文时，可以直接让 query 指向对应 key。代价则是：

prefill 的 attention 计算随序列长度近似二次增长；
decode 每一步都要读取不断增长的 KV Cache；
长上下文的 KV Cache 占据大量显存，压缩可用 batch size；
agent 和长 CoT 场景输出越长，每个新 token 越贵。

Linear Attention 不保存逐 token 的 KV，而是维护一个固定大小的矩阵状态：

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

展开读取公式可得：

o_t=\sum_{i=1}^{t}v_i(k_i^\top q_t).

它仍然通过 query-key 相似度读取 value，但所有历史关联已经叠加进同一个 $S_t$ 。若每个 head 的 key/value 维度固定，decode 时只需保留固定大小的状态，不再让主要缓存随上下文长度增长。

Full Attention:
 
k1,v1  k2,v2  k3,v3  ...  kt,vt
  \      |      |            /
       query 回看完整历史
 
 
Linear Attention:
 
(k1,v1) -> S1 -> S2 -> S3 -> ... -> St
                                      |
                                  query 读取

问题也恰好来自这种压缩：多个 key-value 关联写入有限状态后会彼此干扰。状态不只要会写，还必须知道旧内容何时过期、同一个地址如何被更新，以及有限容量应该留给什么。

2. Delta Rule：写新值之前先纠错#

最简单的线性状态只做外积累加，无法判断当前 key 方向上已经存了什么。DeltaNet 把状态看成一个在线学习的关联记忆，并定义重建损失：

\mathcal L_t(S)=\frac{1}{2}\left\|S^\top k_t-v_t\right\|^2.

$S^\top k_t$ 是状态按当前 key 读出的旧值。对这个损失做一步学习率为 $\beta_t$ 的梯度下降：

S_t =S_{t-1}-\beta_t\nabla_S\mathcal L_t(S_{t-1}),

得到经典 Delta Rule：

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

把它改写后，语义更直接：

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

它不是无条件叠加 $v_t$ ，而是先计算“目标值与当前读值的误差”，再沿 $k_t$ 对应的方向纠正状态：

当前 key k_t
    |
    v
从状态读出 old_value
    |
    | error = target_value - old_value
    v
沿 k_t 方向写入 beta_t * error

如果当前地址已经能读出 $v_t$ ，误差接近零，不必重复写入；如果同一地址的目标发生变化，更新会擦除一部分旧关联并写入新关联。这比“只加不改”的线性状态更适合有限记忆。

3. 从 Gated DeltaNet 到 KDA：遗忘不该只有一个旋钮#

Delta Rule 能定向纠错，却不会主动清理长久不用的状态。Gated DeltaNet（GDN）在更新前增加一个标量遗忘门 $\alpha_t$ ：1

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

对同一个 attention head 来说，这个 $\alpha_t$ 是统一的：保留 90% 就意味着该 head 状态的所有 key channel 都保留 90%。它能控制记忆寿命，却只有一个总开关。

KDA 把标量门升级为 $d_k$ 维向量，并将其对角化：

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

其中 $\alpha_t\in[0,1]^{d_k}$ 。按照论文的矩阵方向，这次更新可以拆成三步：

\widetilde S_{t-1}=\operatorname{Diag}(\alpha_t)S_{t-1},

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

旧状态 S_(t-1)
      |
      | 每个 key channel 用不同 alpha 衰减
      v
衰减状态 S~_(t-1)
      |
      | 读取当前 k_t 对应的旧值
      v
Delta correction
      |
      | beta_t 控制更新强度
      v
新状态 S_t

细粒度 gate 让一个 head 内的不同记忆通道拥有不同寿命：有的快速响应局部变化，有的长期保留稳定信号。论文在 Palindrome、MQAR 和多栈状态跟踪等合成任务中比较 KDA、GDN、Mamba2；序列从 256 增长到 2,048 时，KDA 整体保持最高准确率，尤其在需要回忆的 Palindrome 和 MQAR 上比 GDN 收敛更快。1

这组实验说明了 gate 粒度的价值，但也要注意其边界：合成任务隔离了状态跟踪能力，不等同于大模型最终能力；真正有说服力的证据还要来自后面的同规模预训练对照。

4. KDA 为什么是一种特殊的 DPLR 转移#

KDA 的状态转移部分可以写成：

A_t =(I-\beta_tk_tk_t^\top)\operatorname{Diag}(\alpha_t) =D_t-a_tb_t^\top.

这是 Diagonal-Plus-Low-Rank（DPLR）矩阵：对角项承担逐通道衰减，rank-1 项承担定向修正。一般 DPLR 允许 $a_t$ 和 $b_t$ 独立，表达力很强，却会让 chunkwise 并行实现变得复杂。

KDA 给它加了关键约束：低秩项两侧都绑定到同一个 $k_t$ 。换句话说，它没有追求最一般的 DPLR，而是选择了与经典 Delta Rule 对齐的特殊结构：

General DPLR:  D_t - a_t b_t^T
KDA:           (I - beta_t k_t k_t^T) Diag(alpha_t)
                            \___/
                         shared key

这个约束看起来减少了自由度，却换来两项系统收益：1

处理细粒度累计衰减时，KDA 将二级 chunk 计算从四次降到两次，缓解除法带来的数值精度问题；
inter-chunk 状态更新和输出计算还能少做约三次矩阵乘法。

论文 Figure 2 的 kernel microbenchmark 中，在 batch size 1、16 heads、2K 到 64K 输入长度下，KDA kernel 的执行速度约为通用 DPLR 的两倍。这里的贡献不是发现 DPLR，而是找到一个 表达力、Delta Rule 语义与 Tensor Core 友好实现之间的交点。

5. 训练时分块并行，推理时递归更新#

如果严格按递推式逐 token 更新 $S_t$ ，训练仍然存在串行依赖。KDA 因此采用与现代 Linear Attention 相同的双重执行形态：

训练 / Prefill:
sequence -> chunk 0 -> chunk 1 -> ... -> chunk n
              |          |
           块内并行   块间递推
 
Autoregressive Decode:
S_(t-1) + current token -> S_t + output

设序列按长度 $C$ 分块。KDA 用 UT transform 把块内一串 rank-1 转移压成稠密矩阵运算；输出阶段把两类信息相加：

inter-chunk：当前 query 从进入本块前的历史状态读取；
intra-chunk：当前 query 读取同一块中更早 token 写入的“伪 value”。

这样，块与块之间保留递推语义，块内大部分工作则变成硬件擅长的矩阵乘法。论文给出的单 head、chunk size $C=64$ 时 KDA 训练 FLOPs 为：

\operatorname{FLOPs}_{KDA}(T;C,d_h) =6Td_h^2+3TCd_h+TC^2,

而 Full Attention 的主项为：

\operatorname{FLOPs}_{Attn}(T;d_h)=2T^2d_h.

前者对序列长度 $T$ 为线性，后者为二次。但公式上的复杂度优势不会自动变成墙钟时间：chunk 变换、gate、状态 I/O 和 kernel 融合都决定真实速度。KDA 的 chunkwise 算法和开源 kernel 正是在补齐这一段。1

6. 完整 KDA 层不只是一条状态公式#

论文中的 KDA 模块还包含几项很重要但容易被“逐通道 gate”遮住的设计：1

x_t
 |-- ShortConv -> Swish -> L2Norm -> q_t, k_t
 |-- ShortConv -> Swish            -> v_t
 |-- low-rank projection           -> alpha_t
 |-- projection + Sigmoid          -> beta_t
 |
 v
KDA(q_t, k_t, v_t, alpha_t, beta_t)
 |
 | RMSNorm
 | Sigmoid output gate
 v
output projection

6.1 ShortConv 捕获局部依赖#

$q/k/v$ 投影后先经过短卷积和 Swish。递推状态擅长压缩较长历史，局部卷积则为相邻 token 提供低成本的短程混合。消融中移除卷积后，validation PPL 从 5.65 上升到 5.70，说明即使已经混合 MLA，局部卷积仍有增益。1

6.2 L2Norm 稳定 key 与 query#

$q$ 和 $k$ 会做 L2 normalization，控制状态转移的特征值稳定性。每个实验的 $d_k=d_v=128$ ，因此单个 KDA head 的主要递推状态为固定的 $128\times128$ 矩阵，不随上下文长度增长。1

6.3 Sigmoid output gate 控制读出#

KDA 输出经过 head-wise RMSNorm，再乘以由输入生成的 Sigmoid gate。移除 output gate 后 validation PPL 从 5.65 变为 5.67；换成 Swish gate 则恶化到 5.81。作者据此在 KDA 和 GDN-H 对照中统一采用 Sigmoid gate。1

这些消融提醒我们：最终结果来自一套协同设计，不能把全部提升都归因于 channel-wise decay。

7. 3:1 混合：压缩记忆与显式检索的分工#

纯线性状态有固定容量，精确复制和极长上下文中的稀疏检索仍是短板。Kimi Linear 没有回避这个限制，而是每三层 KDA 插入一层全局 MLA：

层类型	保存的历史	擅长的问题	主要成本
KDA	固定大小递推状态	状态跟踪、持续更新、长程信息流	状态压缩会产生干扰
MLA	压缩后的逐 token KV Cache	精确检索、复制、全局关联	Cache 和 decode I/O 随长度增长

论文选择 layerwise hybrid，而不是在同一层混合不同 head。原因偏工程：整层采用同一种 token mixer，更容易训练，也更方便 kernel、缓存和分布式执行。1

比例消融给出了明确取舍：

KDA:MLA	Training PPL ↓	Validation PPL ↓	含义
0:1	9.45	5.77	纯 MLA 对照
1:1	9.29	5.66	质量接近，但全注意力成本更高
3:1	9.23	5.65	最终采用的平衡点
7:1	9.23	5.70	训练 PPL 相同，分布外验证变差
15:1	9.34	5.82	全注意力过少，质量明显下降

有趣的是，3:1 不仅比更激进的线性比例好，也比纯 MLA 好。这说明 KDA 在这个设定中并非只是“便宜但稍差的替代品”；它的递推归纳偏置和可学习遗忘可能本身就改善了状态跟踪与泛化。

8. 为什么 MLA 层反而不用 RoPE#

Kimi Linear 的全局 MLA 层采用 NoPE，不添加 RoPE；位置和新近性主要由 KDA 的数据依赖状态转移承担。1

理解这件事，可以把 KDA 展开成从历史 $i$ 到当前 $t$ 的读取：

o_t =\sum_{i=1}^{t} \left[ q_t^\top \left(\prod_{j=i+1}^{t}A_j\right) k_i \right]v_i.

中间所有 $A_j$ 的乘积决定历史信息经过多少次、什么样的衰减与修正后抵达当前位置。因此，KDA 的状态转移本身就是一种数据依赖的乘法位置编码：不同于 RoPE 的固定旋转频率，它根据内容学习某个通道应该保留多久。

长上下文对照也支持 NoPE 选择。Kimi Linear (RoPE) 的综合平均分为 51.8，而 NoPE 版本为 54.5；RULER 分别为 78.8 和 84.3，RepoQA 分别为 66.5 和 68.5。1

不过这仍是架构内的经验结果，不能推广成“RoPE 对所有混合模型都有害”。更准确的结论是：当 KDA 已承担强位置感知职责时，再给稀疏分布的全局层施加强 RoPE bias，可能不利于上下文外推。

9. 公平对照：KDA 是否真的胜过 Full Attention#

这篇报告最有价值的实验不是最终 5.7T checkpoint，而是三组同配方的 1.4T token 对照：1

MLA       : 全注意力基线
GDN-H     : Gated DeltaNet + MLA 混合基线
Kimi Linear: KDA + MLA 混合模型
 
相同模型规模 / 训练 token / 数据 / 训练配方

9.1 短上下文预训练与 SFT#

预训练评测中，Kimi Linear 在多数项目领先：MMLU-Pro 为 51.0，MLA 为 47.2，GDN-H 为 47.9；MMLU 为 73.8、71.6、72.2。它并非逐项胜出，例如 EvalPlus 为 60.2，低于 GDN-H 的 63.1。1

相同 SFT 配方后，Kimi Linear 在 GPQA-Diamond 达到 62.1，MLA 和 GDN-H 分别为 57.1、58.6；但 LiveBench 为 45.2，略低于 45.7 和 46.4，EvalPlus 也落后。更准确的说法是 整体平均与多数基准领先，而不是每项全面碾压。1

9.2 128K 长上下文#

模型	RULER	MRCR	HELMET-ICL	RepoQA	综合平均
MLA	81.3	22.6	88.0	63.0	52.2
GDN-H	80.5	23.9	85.5	63.0	51.2
Kimi Linear (RoPE)	78.8	22.0	88.0	66.5	51.8
Kimi Linear	84.3	29.6	90.0	68.5	54.5

Kimi Linear 的平均分最高，但并非每列第一：LongBench V2 和 Frames 上仍由 MLA 领先。这恰好说明混合结构不是消除了固定状态的所有局限，而是在整体上移动了质量与效率的 Pareto frontier。1

9.3 RL 阶段#

作者还让 1.4T 的 Kimi Linear 与 MLA 使用相同数学数据、RL 算法和超参数做 RLVR。Figure 6 中，Kimi Linear 在训练准确率以及 MATH500、AIME 2025 测试曲线上都更快上升并保持领先。1

但论文只提供了曲线，没有给出统一终点数值表、方差或多次随机种子结果。因此，这部分更适合解读为“KDA 没有妨碍 RL scaling，并显示出更好的经验趋势”，还不足以推导它为何必然更适合 RL。

10. 1M 上下文的 2.3×、2.9× 与 6.3×#

论文中出现了几组很容易混淆的速度数字，必须拆开看。1

10.1 Prefill#

Figure 7a 在 batch size 1 下比较整模型 prefill latency：Kimi Linear 在 512K 输入时相对 MLA 快 2.3 倍，在 1M 时快 2.9 倍。短上下文 4K–16K 时，两者差异不大。

10.2 单请求 Decode#

Figure 7b 同样使用 batch size 1，比较 TPOT。图中 Kimi Linear 在 1M 上下文约有 2.3 倍优势。这接近 3:1 混合结构的渐近上限：四层里仍有一层 MLA 必须读取长 KV Cache，不可能获得纯线性模型的无限增长优势。

10.3 借助缓存节省扩大 batch#

Figure 1b 则采用另一种口径：KDA 层不再保存随长度增长的 KV Cache，整模型最多省下约 75% KV Cache 显存；把这些显存重新用于更大的 batch 后，1M 长度下 Kimi Linear 的 TPOT 为 1.84 ms，而 MLA 为 11.48 ms，对应 6.3 倍。1

2.3x: batch=1 的 1M decode TPOT 优势
2.9x: batch=1 的 1M prefill latency 优势
6.3x: 利用省下的 KV Cache 扩大 batch 后的理论吞吐优势

所以，6.3 倍并不是“同一个请求固定 batch 下天然快 6.3 倍”。它依赖长上下文、显存成为瓶颈，以及 serving 系统把节省的容量转化为更高 batching。真实线上收益仍会受到请求长度分布、并发、调度、并行策略和硬件影响。

11. 5.7T 最终模型证明了什么#

在受控的 1.4T 实验之外，团队还训练了 48B 总参数、3B 激活参数的 MoE 模型，共使用 5.7T token，并发布 Base 和 Instruct checkpoint。1

Kimi-Linear-Instruct 在 RULER 128K 和 1M 上分别达到 95.4 与 94.8；AIME 2025 Avg@64 为 58.6，MATH500 为 94.6，LiveCodeBench v6 Pass@1 为 45.7。官方仓库提供 Hugging Face 推理示例，vLLM 也已支持直接部署 1M context 的 OpenAI-compatible 服务。2

这些结果证明 KDA 可以扩展到真实的 48B-A3B MoE，而不只是小规模消融。但 Table 8/9 的 Moonlight 对比不是严格的 attention-only 实验：两者虽同为 3B 激活参数并训练 5.7T token，Kimi Linear 总参数为 48B，Moonlight 为 16B，且新模型还有 3 倍稀疏度等变化。要判断 KDA 相对 MLA 的因果收益，仍应优先看前面的 1.4T controlled runs。

12. 这项工作的边界#

论文没有单列 Limitations 章节，但从方法和实验仍能看到几个清晰边界。

12.1 它不是纯 Linear Attention 的胜利#

最终架构每四层仍有一层全局 MLA。75% 是理论上的最大 KV Cache 缩减比例，不是完全摆脱随上下文增长的缓存。精确检索也主要依赖混合结构共同完成。

12.2 固定状态依然有容量上限#

每个 KDA head 的状态不随长度增长，这是效率来源，也是信息瓶颈。长上下文表中 Kimi Linear 在 LongBench V2、Frames 和 Long Code Arena Commit 上没有领先 MLA，说明压缩记忆并未普遍取代显式 token 检索。1

12.3 “优于 Full Attention”只在报告设置内成立#

1.4T 对照做得较严格，但模型族、数据、训练超参数和评测仍来自同一团队。结论尚需在更多规模、数据分布、独立复现和真实线上 workload 中验证。

12.4 Kernel 与 runtime 是收益的一部分#

线性复杂度不等于自动更快。KDA 依赖专用 chunkwise/recurrent kernel，完整部署还需要 runtime 正确管理混合层状态。好消息是团队已开源 FLA kernel、模型实现和 vLLM 支持；坏消息是不同加速器或缺少融合实现时，论文速度不能直接迁移。2

12.5 RL 证据仍偏经验性#

RL 曲线很有启发，但缺少终点表格、统计波动以及对“为何 KDA 更快学习”的消融。它证明了兼容性与趋势，没有建立一条普适的 RL scaling law。

13. Kimi Linear 真正值得记住的设计原则#

Kimi Linear 可以压缩成三层判断：

算法层：
GDN 的 head-wise 遗忘太粗
-> KDA 用 channel-wise gate 精细管理有限状态
 
Kernel 层：
通用 DPLR 太贵
-> 把低秩转移绑定到同一个 key，保留 Delta Rule 并减少 matmul
 
架构层：
纯线性状态不擅长精确检索
-> 每三层 KDA 插入一层全局 MLA

最重要的不是某个单独公式，而是这三层约束共同形成了闭环：

channel-wise decay 提高固定状态的可控性；
Delta Rule 让状态能按地址纠错，而不是只会累加；
特化 DPLR 让更强的转移仍能高效运行；
chunkwise/recurrent 双形态兼顾训练并行与 decode 常量状态；
3:1 MLA 兜底精确检索，并把系统复杂度保持在可部署范围内。

如果只记一句话，可以记成：

Kimi Linear 没有证明所有历史都应该被压成一个状态；它证明的是，只要状态足够会遗忘、会纠错、kernel 足够快，再保留少量显式全局检索，Linear Attention 就能从“省但弱的替代品”变成真正有竞争力的主干架构。

这也可能是长上下文模型更现实的演进方向：不在 Full Attention 与 Linear Attention 之间二选一，而是让不同记忆机制按层分工——大部分计算负责持续压缩与更新，少部分计算负责对原始历史做精确回看。