AI-Workshop 文献分享 #15 — Kimi K3 为什么这么强？

分享人：ltw | 日期：2026-08-01

主题：Kimi K3 技术优势的零基础通俗讲解——开放权重、MoE 大容量、KDA 长上下文与 Agent 能力

Kimi K3 的优势在哪里？

一句话总结：Kimi K3 的优势，不只是参数规模大，而是它同时解决了“看得远、记得牢、容量大、能执行”这几个问题。

它特别适合长时间编程、搜索资料、分析复杂文件、调用工具和完成多步骤任务。

1. Kimi K3 是什么？

Kimi K3 是月之暗面推出的大型开源权重模型。它的主要特点包括：

总参数量约 2.8 万亿；
每次处理一个 token 时，实际激活约 1040 亿参数；
支持最长约 100 万 token 的上下文；
支持文本和视觉输入；
可以进行持续思考、调用工具和执行复杂任务；
主要面向长程编程、知识工作、推理和智能体任务。

这里要特别说明：K3 更准确的说法是 开放权重模型（open-weight model）。它公开了模型权重和技术资料，但使用时需要遵守自己的 Kimi K3 License，不能简单等同于完全没有限制的开源软件。

2. 最核心的优势：它更像一个“能干活的智能体”

很多大模型更像一个问答机器人：

用户提问 → 模型回答

Kimi K3 更强调下面这种工作方式：

理解任务
  ↓
制定计划
  ↓
搜索资料或读取文件
  ↓
调用工具执行操作
  ↓
检查执行结果
  ↓
发现问题并修改
  ↓
继续执行，直到完成任务

例如，用户让它分析一个大型代码项目时，它可以：

浏览项目目录；
阅读多个源文件；
找到相关调用链；
修改代码；
运行测试；
根据报错继续修复；
最后给出修改说明。

这和只回答一个问题有很大不同。它考验的不是某一轮回答是否漂亮，而是模型能不能在较长时间内保持目标、记住上下文、正确使用工具，并且根据反馈调整方案。

K3 的突出能力，主要就体现在这种长时间、多步骤的任务中。

3. 优势一：上下文很长，能够处理大型材料

3.1 什么是上下文？

上下文可以理解为模型当前能够“放在桌面上查看”的内容，包括：

用户的问题；
之前的聊天记录；
上传的 PDF、代码和图片；
工具调用结果；
模型之前的思考和操作记录。

普通模型的上下文有限。当材料太多时，模型可能需要删除旧内容，或者只保留一个摘要。摘要如果丢失细节，后续工作就容易出错。

3.2 K3 的优势在哪里？

K3 支持约 100 万 token 的上下文。粗略理解，它可以一次性处理：

一个很大的代码仓库；
大量论文和研究报告；
一批结构复杂的 PDF；
很长的项目讨论和工具执行记录。

这并不意味着把 100 万 token 全部塞进去就一定有效。真正重要的是：K3 还针对长上下文和长程任务进行了训练，学习了如何在很长的材料中查找、使用和验证信息。

3.3 通俗比喻

普通模型像一个桌面比较小的研究员：材料多了以后，需要不断把旧文件收起来。

K3 像是拥有一个很大的会议室：可以同时摊开更多资料，不必频繁清理桌面。

但是，会议室大不等于一定能找到资料。K3 的价值在于，它不仅会议室大，还训练了如何在会议室里检索和组织信息。

4. 优势二：模型容量特别大，但每次不需要全部运行

4.1 为什么参数量重要？

模型参数可以粗略理解为模型学到的“知识和处理模式”。参数越多，模型理论上能容纳的知识和能力越丰富。

但如果每次回答都运行全部参数，计算成本会非常高。

4.2 K3 使用了 MoE 架构

K3 使用的是 Mixture-of-Experts，简称 MoE，混合专家模型。

可以把它想象成一家公司：

公司里有很多专家；
面对不同问题时，只叫相关专家来处理；
不需要让全公司的所有人同时参加每个会议。

K3 的设计大致是：

总共有约 896 个路由专家；
每个 token 只选择其中 16 个左右的专家；
每个 token 实际激活约 104B 参数；
但整个模型拥有 2.8T 参数的总容量。

因此，它同时获得了两种好处：

模型容量大：可以容纳更多知识和专业能力；
单次计算相对可控：不需要每次都运行全部参数。

4.3 通俗比喻

普通大模型像一个只有一个超级专家的办公室，所有问题都由他处理。

K3 像一个大型研究院，里面有很多不同方向的专家。遇到数学问题找数学专家，遇到代码问题找编程专家，遇到视觉问题找视觉专家。

这就是 K3 能够把模型做得很大，同时又尽量控制推理计算量的原因。

5. 优势三：长文本处理效率更高

标准 Transformer 的注意力机制在处理很长文本时，会遇到两个主要问题：

需要保存大量历史信息；
序列越长，计算和显存压力增长越明显。

K3 使用了 Kimi Delta Attention，简称 KDA，并且与部分全局注意力层组合使用。

5.1 KDA 可以理解成什么？

KDA 可以理解为一种更适合长序列的“压缩记忆机制”：

不需要把所有历史 token 都原样保存；
会把过去的信息整理成更紧凑的状态；
在处理后续内容时，直接读取这些状态。

5.2 为什么还要保留全局注意力？

如果完全依赖压缩记忆，模型可能会丢失某些精确的远距离关系。

因此，K3 并不是只使用 KDA，而是周期性加入 Gated MLA 等全局交互机制。可以理解为：

KDA 负责日常的高效记忆；
全局注意力负责定期进行精确的全文检索。

这种组合在效率和精确度之间做了平衡。

5.3 通俗比喻

读一本很厚的书时，有两种方式：

每次查资料都从第一页重新翻到最后一页；
把每一章整理成摘要，需要时先看摘要，关键地方再回到原文。

KDA 更像第二种方式，而全局注意力则负责在关键时刻重新核对原文。

6. 优势四：网络很深，但信息不容易被“冲淡”

深层模型有一个问题：随着层数增加，早期信息可能逐渐被后面的信息覆盖或稀释。

普通残差连接通常是简单地把前一层结果加到当前层：

当前表示 = 上一层表示 + 当前层新信息

K3 使用了 Attention Residuals，也就是注意力残差。

它的思路是：当前层不再机械地接收所有历史表示，而是根据当前任务，选择哪些早期信息更有用。

可以理解为：

普通残差：把所有会议记录直接叠加；
注意力残差：先检索历史会议记录，再挑选和当前问题最相关的部分。

这有助于：

保留早期的重要信息；
改善深层网络的信息流动；
减轻深层模型训练不稳定的问题；
提升多步骤推理和代码生成能力。

7. 用数学公式看 K3 和传统 Transformer 的区别

这一节的公式是教学化简版。K3 的完整实现还包含门控、归一化、状态初始化、混合注意力层和工程优化。这里的目标不是复现全部代码，而是帮助我们看懂它为什么更适合长上下文和大规模 Agent 任务。

7.1 传统全注意力：每个 token 都看所有 token

标准 Transformer 的自注意力通常写成：

\[ Q = XW_Q, \qquad K = XW_K, \qquad V = XW_V \]

\[ \operatorname{Attention}(X)=\operatorname{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \]

其中：

\(X \in \mathbb{R}^{n \times d}\) 是长度为 \(n\) 的输入序列；
\(Q\)、\(K\)、\(V\) 分别表示查询、键和值；
\(d_k\) 是每个注意力头的维度；
\(QK^T\) 会得到一个 \(n \times n\) 的 token 两两关系矩阵。

这个公式的直观含义是：每个 token 都和整个序列中的 token 计算相关性，再按相关性加权读取信息。

计算和显存开销

全注意力的主要关系计算量近似为：

\[ O(n^2d_k) \]

需要保存的注意力关系也接近：

\[ O(n^2) \]

当上下文长度从 \(n\) 增加到 \(2n\) 时，二次项会变成：

\[ (2n)^2=4n^2 \]

也就是说，序列长度翻倍，相关性计算大约变成 4 倍。这就是传统全注意力处理超长上下文时的主要压力。

注意：现代实现会使用 FlashAttention、分块计算和 KV Cache，实际显存不会简单等于完整的 \(n \times n\) 矩阵，但全局两两交互带来的二次计算压力仍然是核心问题。

7.2 KDA：把“保存所有历史”改成“维护一个记忆状态”

Kimi K3 使用的 Kimi Delta Attention 属于带门控的线性注意力路线。它可以先被理解成：模型一边阅读，一边更新自己的“记忆本”；需要回答时，再拿当前问题去查询记忆本。

重点：KDA ≈ LSTM 式门控状态更新 + Attention 式 QKV 检索。

像 LSTM 的部分：通过门控递推更新记忆状态，决定旧信息保留多少、新信息写入多少；

像 Attention 的部分：仍然使用 \(Q\)、\(K\)、\(V\) 的“查询—地址—内容”分工，用 \(K/V\) 写入记忆，再用 \(Q\) 检索记忆；

但不是简单拼接：这是帮助理解 KDA 的结构类比，并不表示 KDA 在数学上等同于 LSTM 与标准 Attention 的直接组合。

因此，可以先用一句话抓住 KDA 的数据流：

像 LSTM 一样门控更新状态，像 Attention 一样用 QKV 写入和检索

下面首先使用教学化简公式解释直觉，随后再补充 Delta Rule 的“差量纠错”。这些公式用于帮助理解，不等于 K3 完整工程实现。

先把一枚 token 的完整旅程串起来

模型读到第 \(t\) 个 token 时，最先得到的不是一句人能看懂的事实，而是一个向量 \(x_t\)。随后，网络通过不同的投影和门控分支，从同一个 \(x_t\) 生成几组用途不同的量：

\[ q_t=x_tW_Q,\qquad k_t=x_tW_K,\qquad v_t=x_tW_V \]

同时还会产生控制记忆更新的门控量。教学上可把它们概括成：

\[ A_t=\operatorname{gate}_{\text{retain}}(x_t), \qquad \beta_t=\operatorname{gate}_{\text{write}}(x_t) \]

这些量不是分别来自五个外部模块，而是当前 token 的表示经过不同可学习分支后得到的。训练会逐渐让各分支形成不同分工：

同一个当前 token x_t
        │
        ├── q_t：这一刻想从历史中查什么
        ├── k_t：当前信息应该使用什么检索地址
        ├── v_t：当前信息真正携带的内容
        ├── A_t：旧记忆的哪些通道应该保留或衰减
        └── β_t：这次修正应该写入多强

接下来发生两件事：

用 \(k_t\)、\(v_t\) 和门控更新记忆状态 \(S_{t-1}\rightarrow S_t\)；
用 \(q_t\) 查询更新后的状态，得到当前 token 能读取到的历史信息 \(y_t\)。

因此，KDA 不是先把整篇文章读完再统一压缩，而是一个逐 token 读取、逐 token 修正、逐 token 查询的递推过程。

\(S_t\) 为什么是一块“矩阵记忆”？

假设：

\[ k_t,q_t\in\mathbb{R}^{d_k}, \qquad v_t\in\mathbb{R}^{d_v} \]

那么记忆状态可以写成：

\[ S_t\in\mathbb{R}^{d_k\times d_v} \]

它可以被理解成一张“地址特征到内容特征”的关联表：

行方向对应 key/query 使用的地址空间；
列方向对应 value 使用的内容空间；
整个矩阵保存“什么地址通常关联什么内容”。

写入时使用外积：

\[ k_tv_t^T \]

如果 \(k_t\) 有 \(d_k\) 个分量、\(v_t\) 有 \(d_v\) 个分量，外积就会得到一个 \(d_k\times d_v\) 的矩阵，正好可以写入 \(S_t\)。

先看一个故意简化的二维地址例子。假设模型使用：

\[ k_{\text{地点}}= \begin{bmatrix}1\\0\end{bmatrix}, \qquad k_{\text{职业}}= \begin{bmatrix}0\\1\end{bmatrix} \]

把“北京”的内容向量记为 \(v_{\text{北京}}\)，把“医生”的内容向量记为 \(v_{\text{医生}}\)。连续写入两条关联后，可以得到：

\[ S = k_{\text{地点}}v_{\text{北京}}^T +k_{\text{职业}}v_{\text{医生}}^T = \begin{bmatrix} v_{\text{北京}}^T\\ v_{\text{医生}}^T \end{bmatrix} \]

如果问题需要查询地点，就使用：

\[ q_{\text{地点}}= \begin{bmatrix}1\\0\end{bmatrix} \]

于是：

\[ q_{\text{地点}}^TS=v_{\text{北京}}^T \]

查询职业时改用 \(q_{\text{职业}}=[0,1]^T\)，便会读出 \(v_{\text{医生}}\)。这就是“用 key 写地址、用 value 写内容、用 query 按地址读取”的最小例子。

真实模型当然不会使用“第一行固定表示地点、第二行固定表示职业”这种人工字典。真实的 \(k_t\) 和 \(q_t\) 是稠密的连续向量：

一个地址可以同时带有“人物、地点、时间”等多种特征；
两个意思相近的查询可以落到相近的向量方向；
查询结果通常是多个关联的软组合，而不是数据库里某一行的精确取值。

这也解释了它为什么既能泛化，又会发生记忆干扰：如果不同信息使用了相近的地址，它们写入同一个有限状态时就可能互相覆盖。后面的门控和 Delta Rule，正是用来控制这种覆盖与修正的。

第一步：更新记忆

为了便于理解，可以先把递推过程简化为：

\[ S_t=A_tS_{t-1}+\beta_tk_tv_t^T \]

用大白话翻译就是：

\[ \text{新记忆} = \text{保留下来的旧记忆} + \text{当前写入的新记忆} \]

各个符号可以这样理解：

\(S_{t-1}\)：模型读完前 \(t-1\) 个 token 后形成的旧记忆；
\(S_t\)：读完当前 token 后得到的新记忆；
\(A_t\)：保留门，控制旧记忆的不同部分保留或衰减多少；
\(k_t\)：当前信息的“地址”或“标签”，决定写到记忆的什么位置；
\(v_t\)：真正要保存的内容；
\(k_tv_t^T\)：按照 \(k_t\) 给出的地址，把 \(v_t\) 写入记忆矩阵；
\(\beta_t\)：写入门，控制当前内容应该写入多强。

其中，\(A_t\) 和 \(\beta_t\) 管理的是两个不同方向：

A_t：旧的留多少
β_t：新的写多重

这里尤其不能把 \(A_t\) 只理解成一个控制整本记忆的总开关。KDA 的重要特点之一，是使用更细粒度的衰减控制。教学上可以把它想成一排独立旋钮：

旧记忆中的人物通道：保留 95%
旧记忆中的地点通道：保留 20%
旧记忆中的时间通道：保留 80%
旧记忆中的语气通道：保留 60%

上面的“人物、地点、时间”只是帮助理解的名字，模型内部并没有人工标注这些固定通道。重点是：它可以让不同维度以不同速度遗忘，而不是要求所有记忆一起保留或一起清空。

这比单一标量遗忘门更灵活。例如当前句子只更新了“小明的居住地”，模型可以重点衰减与旧地点有关的状态，同时尽量保留“小明的职业、年龄和其他关系”。在真实 KDA 中，这类细粒度门控会与 Delta Rule 的低秩修正共同形成更有表达力的状态转移；本文用 \(A_t\) 统一表示这部分作用。

例如模型先读到：

小明住在北京。

记忆中可能形成“人物居住地 → 北京”。后来又读到：

小明已经搬到了上海。

此时模型需要降低旧信息“住在北京”的影响，并加强写入“现在住在上海”。如果模型只会不断添加、不会遗忘和修正，记忆中就容易同时保留两个相互冲突的答案。

第二步：读取记忆

有了记忆状态 \(S_t\) 后，读取过程可以简化为：

\[ y_t=q_t^TS_t \]

其中：

\(q_t\)：当前想查询什么；
\(S_t\)：已经积累的记忆本；
\(y_t\)：从记忆中读取出来的结果向量。

例如，模型已经读过：

小明今天去了北京，他准备参观故宫。

记忆里可能压缩保存了：

人物 → 小明
地点 → 北京
计划 → 参观故宫

当模型处理“小明去了哪里？”时，\(q_t\) 可以理解成“查询小明的地点”。通过 \(q_t^TS_t\)，模型会从记忆中读取与这个问题最相关的信息，最后经过后续网络生成“北京”。

完整过程可以记成：

读到一个新 token
      ↓
A_t 决定旧记忆保留多少
      ↓
k_t 决定信息写到哪里
      ↓
v_t 表示具体写入什么
      ↓
β_t 决定写入强度
      ↓
得到新记忆 S_t
      ↓
用查询 q_t 读取记忆
      ↓
得到读取结果 y_t

和传统注意力有什么不同？

传统全注意力可以简化为：

\[ y_t=\sum_{i=1}^{t}\operatorname{score}(q_t,k_i)v_i \]

它更像在回答每个问题时，重新翻阅全部历史资料：

保存过去每个 token 的 \(k_i\) 和 \(v_i\)；
让当前查询 \(q_t\) 与所有历史 key 比较；
根据相关性读取所有 value。

KDA 的状态递推更像边读边整理笔记：

\[ \text{旧记忆} \rightarrow \text{门控更新} \rightarrow \text{当前读取} \]

因此，两者的直观区别是：

传统注意力：
保存所有原始资料，需要时重新检索全部资料

KDA：
边阅读边把历史压缩进记忆状态，需要时查询压缩记忆

KDA 把历史信息不断写入固定形状的状态 \(S_t\)。在自回归解码时，不需要为了每个新 token 都继续保存一份不断增长的完整 KDA KV 历史。

“Delta”为什么叫差量更新？

前面的公式：

\[ S_t=A_tS_{t-1}+\beta_tk_tv_t^T \]

适合解释“保留旧记忆，再写入新记忆”，但没有完整体现 Delta 的纠错思想。

更接近 Delta Rule 直觉的教学化简是先读取旧答案：

\[ \hat v_t=S_{t-1}^Tk_t \]

这里 \(\hat v_t\) 表示：按照地址 \(k_t\) 查询时，旧记忆原本会返回什么。

再计算新内容与旧答案之间的差值：

\[ \Delta v_t=v_t-\hat v_t \]

最后只把需要修正的差量写回记忆：

\[ S_t = A_tS_{t-1} + \beta_tk_t(\Delta v_t)^T \]

把 \(\Delta v_t\) 展开后就是：

\[ S_t = A_tS_{t-1} + \beta_tk_t\left(v_t-S_{t-1}^Tk_t\right)^T \]

它表达的不是“无论如何都把 \(v_t\) 再加一遍”，而是：

先看看记忆里原来写了什么，再写入新内容与旧内容之间的差值。

可以先用一个一维数字理解。假设某个地址当前读出的旧值是 \(0.7\)，而新信息希望它变成 \(0.9\)：

\[ \hat v_t=0.7,\qquad v_t=0.9 \]

那么真正需要写入的差量只有：

\[ \Delta v_t=0.9-0.7=0.2 \]

如果写入强度 \(\beta_t=0.5\)，这次不会一步改到目标值，而是只写入一半纠偏量：

\[ 0.7+0.5\times0.2=0.8 \]

这说明 \(\beta_t\) 更像“纠偏步长”：

\(\beta_t\) 接近 0：几乎不相信当前新信息，少改一点；
\(\beta_t\) 接近 1：充分采用当前修正；
旧答案已经接近新答案：\(\Delta v_t\) 很小，不必重复写入；
旧答案与新答案冲突：\(\Delta v_t\) 较大，需要明显纠偏。

真实情况下，\(v_t\)、\(\hat v_t\) 和 \(\Delta v_t\) 都是向量，所以不同内容维度可以同时向不同方向修正。这里的一维数字只是把向量运算压扁成了一个容易观察的例子。

仍以搬家为例：

旧记忆：小明居住地 → 北京
新信息：小明居住地 → 上海
Delta 更新：不是简单累加“北京 + 上海”，而是修正旧答案

这种差量写入可以减少重复信息，并允许模型修正已经存在的关联。

复杂度上的直观对比

在简化分析下，长度为 \(n\) 的序列：

机制	历史信息的组织方式	典型长度相关开销	直观特点
全注意力	保存并比较所有 token	训练中通常含 \(O(n^2d)\) 关系计算	精确，但长序列昂贵
线性/状态型注意力	汇总成状态 \(S_t\)	递推部分近似随 \(n\) 线性增长	高效，但压缩可能损失细节
K3 的混合结构	KDA + 周期性 Gated MLA	在效率和全局精确检索之间折中	平时高效，关键处重新全局交互

这里不能简单说“KDA 完全替代了注意力”。压缩记忆虽然高效，但不一定能保留所有 token 级细节。因此，K3 让 KDA 负责大部分长序列处理，再周期性使用 Gated MLA 进行更精确的全局信息交换。

为什么公式是逐 token 的，训练却不一定很慢？

从公式看，\(S_t\) 依赖 \(S_{t-1}\)，似乎只能严格按照第 1、2、3……个 token 顺序计算。这种写法最适合解释推理时的数据流，但 GPU 更擅长一次并行处理大块矩阵，如果训练时完全逐 token 循环，硬件利用率会很差。

KDA 为此采用了专门的分块并行思路。大白话理解是：

逻辑上：每个 token 继续按顺序更新记忆
工程上：先把序列切成多个 chunk，在块内组织并行计算，再传递块间状态

可以把它类比成统计一本书的累计字数：

最直白的方法是逐字累加；
更适合并行的方法是让多人先分别统计每一章，再合并各章结果；
最终累计关系没有改变，但硬件不必真的一次只处理一个 token。

KDA 的实际块算法比“章节求和”复杂，因为它还包含衰减门和 Delta 修正，但目标相同：保留递推记忆的表达方式，同时尽量把训练改造成 GPU 擅长的块状矩阵计算。

还要注意，“随序列长度近似线性增长”不等于开销为零。KDA 只是避免为每对 token 都建立关系，状态矩阵本身的读写、门控计算和块间传递仍然需要算力。它主要优化的是上下文长度 \(n\) 增长时最昂贵的二次项。

KDA 到底保留了什么，又牺牲了什么？

到这里可以把 KDA 的取舍说得更精确：

它保留的不是每个历史 token 的原样副本，而是许多“地址特征 → 内容特征”的累计关联；
它擅长持续更新事实、追踪状态，以及从长历史中读取已经整理进状态的模式；
它的状态大小不会像完整 KV 历史那样随 token 数持续增长；
但有限大小的状态不可能无损容纳无限细节，相近地址可能干扰，罕见的逐字信息也可能被冲淡；
所以混合架构中的全局注意力层不是装饰，而是在关键层重新提供 token 级精确交互。

最后可以用一句口诀记住这些符号：

A：旧的留多少
β：新的写多重
k：写到哪里
v：写入什么
q：想查什么
S：整本记忆
y：查出的结果

7.3 普通残差与 Attention Residuals

传统残差连接

标准 Transformer 的残差连接可以简写为：

\[ h_l=h_{l-1}+F_l(h_{l-1}) \]

展开多层后，最终表示近似包含很多层输出的累加：

\[ h_L=h_0+\sum_{l=1}^{L}F_l(h_{l-1}) \]

它的优点是简单、稳定、容易训练。但问题是：每一层的历史贡献通常是固定加法，模型不能显式地说“第 12 层的信息比第 3 层更重要”。

Attention Residuals

K3 使用的 Attention Residuals 可以简化为：

\[ h_l=\sum_{i=0}^{l-1}\alpha_{i\rightarrow l}v_i \]

其中：

\[ \alpha_{i\rightarrow l}=\operatorname{softmax}_i\left(\frac{q_l^T k_i}{\sqrt d}\right) \]

并且满足：

\[ \sum_{i=0}^{l-1}\alpha_{i\rightarrow l}=1, \qquad \alpha_{i\rightarrow l}\ge 0 \]

这表示第 \(l\) 层会对前面层的表示进行一次“按内容检索”，再决定各层信息的混合比例。

对比项	普通残差	Attention Residuals
信息融合	主要是固定加法	对历史表示学习权重
历史层贡献	不容易区分重要程度	可以按输入动态选择
直观问题	信息可能逐层堆积、稀释	更像按需检索历史表示
代价	简单、便宜	需要保存和计算历史表示
K3 的取舍	不直接采用	使用更可部署的 Block AttnRes

K3 实际使用 Block AttnRes 来降低完整历史层注意力的内存成本。可以把完整形式理解为“查阅每一层笔记”，而 Block AttnRes 是“先把若干层整理成一章，再按章节检索”。

7.4 传统 Dense 模型、普通 MoE 与 K3 的 MoE

Dense 模型

如果一个 Dense Transformer 有 \(P\) 个参数，那么每个 token 基本都要经过全部参数：

\[ C_{\text{dense}}(x)\approx O(P) \]

其中 \(C\) 表示单 token 的计算量，省略了具体矩阵乘法常数。

Dense 模型的特点是结构简单，但模型容量和单次计算量绑在一起：模型越大，每次推理通常越贵。

MoE 模型

MoE 将参数分成 \(E\) 个专家，每个 token 只选择 \(k\) 个专家。路由器可以写成：

\[ p(x)=\operatorname{softmax}(W_rx) \]

选择概率最高的 \(k\) 个专家：

\[ \mathcal{T}(x)=\operatorname{TopK}(p(x),k) \]

专家输出为：

\[ y=\sum_{e\in\mathcal{T}(x)}p_e(x)\,f_e(x) \]

如果每个专家的参数规模为 \(P_e\)，单 token 的专家计算量大致为：

\[ C_{\text{MoE}}(x)\approx O(kP_e) \]

而整个模型可以拥有接近：

\[ P_{\text{total}}\approx O(EP_e) \]

这就是 MoE 的核心价值：总容量可以扩大，单 token 激活的专家数量却不必同比扩大。

K3 的具体含义

K3 约有 896 个路由专家，每个 token 选择 16 个专家。因此，从路由数量看：

\[ \text{激活比例}\approx \frac{16}{896}\approx 1.8\% \]

这个比例只是“路由专家数量”的直观比例，不等于完整模型的实际 FLOPs 比例，因为还要计算共享专家、注意力层、路由器和其他模块。

K3 的关键难点不是“只选 16 个”本身，而是要让不同专家收到的 token 尽量均衡。理想情况下，专家 \(e\) 的负载为：

\[ T_e\approx\frac{TK}{E} \]

其中：

\(T\) 是当前批次 token 数；
\(K\) 是每个 token 选择的专家数；
\(E\) 是专家总数；
\(T_e\) 是专家 \(e\) 实际收到的 token 数。

如果某个专家收到远多于平均值的 token，就会出现“最忙的 GPU 决定整体速度”的问题。MoonEP 的目标就是让各个并行 rank 的 token 负载尽量接近：

\[ T_1\approx T_2\approx\cdots\approx T_R \]

这也是 K3 能把极稀疏 MoE 扩展到超大规模的重要工程基础。

7.5 普通问答目标与 K3 的长程 Agent 目标

传统监督微调常用下一个 token 预测损失：

\[ \mathcal{L}_{\text{SFT}} =-\sum_{t=1}^{n}\log p_\theta(y_t\mid y_{<t},x) \]

它主要关心：给定输入 \(x\)，模型是否能生成正确答案 \(y\)。

对于 Agent 任务，模型不仅要生成文字，还要选择动作。例如：

\[ s_t\xrightarrow{\pi_\theta(a_t\mid s_t)}a_t \xrightarrow{\text{tool/environment}}s_{t+1} \]

其中：

\(s_t\) 是当前状态，包括对话、文件、工具结果和历史操作；
\(a_t\) 是模型采取的动作，例如搜索、执行代码或修改文件；
\(\pi_\theta\) 是模型的策略；
\(s_{t+1}\) 是工具执行后的新状态。

一个长程任务的结果不只由某一个 token 是否正确决定，而可以用最终奖励表示：

\[ R(\tau)=R(s_0,a_0,s_1,a_1,\ldots,s_T) \]

这里 \(\tau\) 是完整执行轨迹。强化学习希望最大化：

\[ J(\theta)=\mathbb{E}_{\tau\sim\pi_\theta}[R(\tau)] \]

这两种目标的区别可以简单理解为：

训练方式	更关注什么	典型结果
下一 token 预测 / SFT	当前句子是否生成得好	单轮回答、代码片段
Agent 强化学习	整条任务轨迹是否完成	搜索、执行、验证、修复

K3 的优势不只是模型会“写出一个看似正确的答案”，而是训练过程更关注最终任务是否完成。这解释了它为什么在长程代码和工具密集型任务中更有竞争力。

7.6 一个综合对比：为什么 K3 更适合长任务？

可以把传统模型和 K3 的计算路线简化为：

传统全注意力 Dense 模型

\[ \text{全部参数} \;+ \text{所有 token 两两交互} \;+ \text{固定残差累加} \;+ \text{短轨迹训练} \]

它的优点是结构成熟、行为相对容易理解；缺点是模型容量、长上下文成本和长程执行能力之间存在较强约束。

Kimi K3

\[ \text{KDA 长序列状态} \;+ \text{Gated MLA 全局校准} \;+ \text{AttnRes 跨深度检索} \;+ \text{稀疏 MoE 专家容量} \;+ \text{长程 Agent RL} \]

因此，K3 的“领先”可以理解为多个乘数共同作用：

\[ \text{最终 Agent 能力} \approx \text{架构能力} \times \text{训练数据与任务} \times \text{工具环境} \times \text{测试时计算} \]

这个公式不是严格的物理定律，而是一个帮助理解的框架。它说明：K3 的提升不是某一个公式单独带来的，而是模型结构、训练目标、Agent 环境和推理预算共同形成的结果。

9. 优势五：它训练的是“解决问题的过程”，而不只是答案

这是 K3 与很多普通聊天模型之间非常重要的差别。

9.1 普通训练更像做题

传统训练通常关注：

问题 → 正确答案

模型只要生成一个看起来合理的回答，就可能得到较高评价。

9.2 K3 更强调完整任务轨迹

K3 的强化学习环境更加接近真实工作：

提出假设
  ↓
调用搜索、终端或代码工具
  ↓
获得真实反馈
  ↓
检查结果是否正确
  ↓
修改方案
  ↓
继续执行

训练任务包括：

长时间软件工程；
代码仓库修改；
GPU Kernel 优化；
专业知识研究；
多步骤搜索；
网页开发；
视觉反馈和游戏开发；
科学计算和数据分析。

9.3 为什么这会提升 Agent 能力？

因为真实任务中，第一步通常不会直接成功。

一个好的 Agent 需要能够：

发现自己哪里错了；
读取工具返回的报错；
修改原来的方案；
记住之前做过什么；
避免重复犯同样的错误；
在很长的任务中保持最终目标。

K3 的训练过程专门强化了这些能力，因此它在长程编程和复杂 Agent 任务中表现突出。

10. 优势六：模型和 Agent 工具配合得比较好

模型能力并不完全等于最终使用效果。

同一个模型，如果配上不同的工具系统，实际表现可能差别很大。

K3 推荐配合 Kimi Code 使用。它会保留完整的：

历史思考内容；
工具调用记录；
工具返回结果；
多轮任务状态；
文件修改和测试结果。

这样模型可以知道：

自己之前尝试过什么；
哪个方案已经失败；
某个文件为什么被修改；
下一步需要验证什么。

通俗比喻

模型像一个工程师，Agent harness 像他的工作环境。

如果工程师没有电脑、终端、文件系统和测试工具，他只能提出建议。

如果给他一套完整的工作环境，他才有机会真正完成任务。

所以评价 K3 时，更准确的说法是：

K3 的优势来自“模型 + 长上下文 + 工具调用 + Agent 训练 + 执行环境”的整体组合。

11. 优势七：视觉、代码和工具能力可以组合起来

K3 不只处理文本，也支持视觉输入。

这意味着它可以把下面几类信息放在同一个任务中处理：

代码；
截图；
图片；
视频；
终端输出；
文档和表格。

例如在前端开发中，它可以：

阅读需求；
编写页面代码；
启动页面；
查看截图；
判断布局和样式问题；
修改代码；
再次截图验证。

这就是所谓的 vision in the loop，即“视觉参与执行闭环”。

传统代码模型主要根据代码文本工作，而 K3 可以结合实际页面效果进行判断，更适合：

前端开发；
游戏开发；
CAD 和图形任务；
文档理解；
视频编辑；
视觉问答。

12. 优势八：训练和部署阶段都做了系统工程优化

2.8T 参数模型不是只靠算法论文就能训练出来的，还需要大量工程优化。

K3 配套开源了若干基础设施项目。

10.1 MoonEP：让专家并行更均衡

MoE 的问题是不同 token 可能集中到少数专家，导致：

某些 GPU 很忙；
某些 GPU 空闲；
整体速度被最忙的 GPU 决定；
显存和通信效率变差。

MoonEP 会根据当前路由情况，动态复制热点专家，让各个 GPU 尽量处理相同数量的 token。

10.2 FlashKDA：让 KDA 真正跑得快

理论上高效的算法，如果 GPU Kernel 写得不好，实际速度仍然可能很慢。

FlashKDA 使用针对 GPU 的高性能实现，使 KDA 能够真正用于大模型训练和推理。

10.3 长程强化学习基础设施

百万 token 的 Agent 任务会产生很长的 KV Cache 和大量中间状态。

K3 使用了部分 rollout、外部 KV Cache 和可恢复 sandbox 等方法，尽量减少长任务对 GPU 显存和训练效率的影响。

因此，K3 的优势不仅来自论文中的网络结构，也来自：

算法设计 + GPU Kernel + 分布式通信 + 缓存管理 + 强化学习环境

13. 为什么 K3 能在一些榜单上领先很多？

综合来看，主要有以下几个原因。

原因一：它的模型容量确实很大

2.8T 参数意味着它拥有非常大的专家容量。MoE 让这些容量不必在每次推理时全部启用。

原因二：它针对长任务进行了专门训练

很多模型擅长回答单个问题，但一旦任务持续几十轮，就可能忘记目标或开始重复。

K3 的训练任务本身就包含长时间执行、多次工具调用和反复验证。

原因三：它支持很长的上下文

长程任务需要保存大量历史信息。K3 的 1M token 上下文可以减少频繁摘要和上下文丢失。

原因四：它在测试时愿意花更多计算

K3 默认启用思考，并且官方很多评测使用 max reasoning effort。

这意味着它可能：

思考更久；
输出更多 reasoning token；
进行更多轮工具调用；
花更多时间验证结果。

复杂任务的成功率会提高，但速度和成本也会增加。

原因五：评测任务本身更接近它的训练目标

现在很多新评测已经不再只是问答，而是要求模型：

修改真实代码；
操作终端；
浏览网页；
分析大量文件；
生成报告、表格和网页。

这些任务正好是 K3 重点训练的方向。

14. 但 K3 并不是所有方面都第一

介绍 K3 的优势时，也应该主动说明它的局限，这样汇报会更客观。

12.1 不是综合能力全面第一

Kimi 官方明确表示，K3 的总体表现仍然落后于部分最强闭源模型，例如 Claude Fable 5 和 GPT-5.6 Sol。

更准确的说法是：

K3 是目前最强的开放权重模型之一，并且在部分长程编程、工具调用和知识工作任务上达到前沿水平。

12.2 复杂任务的成本和耗时较高

第三方 Artificial Analysis 的 AA-Briefcase 评测显示，K3 在复杂知识工作任务中平均使用较多轮次和输出 token。

这说明它可能通过更充分的推理和工具调用获得更高成功率，但不是“又快又便宜”。

12.3 评测结果受到 Agent harness 影响

不同模型使用的工具系统、上下文管理方式和 Agent 框架并不完全相同。

因此，榜单成绩通常反映的是：

模型能力 + Agent 框架 + 工具配置 + 提示词 + 测试预算

不能把所有差距都归因于模型本身。

12.4 本地部署门槛很高

虽然模型权重开放，但 2.8T 参数模型对硬件要求非常高。官方建议使用大规模加速卡集群进行部署。

所以：

“权重开放”不等于普通电脑可以运行；
“可以下载”不等于部署成本低；
对大多数研究者来说，API 或合作算力更现实。

12.5 对思考历史比较敏感

K3 训练时保留了历史思考内容。在多轮对话和工具调用中，如果调用框架丢失 reasoning_content 或工具记录，模型质量可能明显下降。

15. 和普通大模型相比，K3 的差异是什么？

对比方面	普通聊天模型	Kimi K3
主要目标	回答问题	完成多步骤任务
上下文	较短或需要频繁压缩	支持约 100 万 token
模型结构	常规 Transformer 或普通 MoE	KDA + AttnRes + Stable LatentMoE
工具使用	可能只会简单调用	强调搜索、终端、代码和视觉闭环
训练任务	问题到答案	推理、行动、观察、验证、修正
代码能力	生成代码片段	修改项目、运行测试、持续调试
视觉能力	识别图片或回答问题	结合截图参与执行过程
推理成本	通常较低	复杂任务可能使用更多时间和 token
部署难度	相对容易	对集群和通信系统要求很高

16. 最适合使用 K3 的场景

K3 更适合以下任务：

14.1 大型项目代码分析

例如：

阅读整个代码仓库；
梳理模块关系；
定位跨文件 Bug；
执行测试并根据报错修复；
设计复杂重构方案。

14.2 长文档和资料研究

例如：

阅读多篇论文；
对比多份技术报告；
从大量 PDF 中提取信息；
生成带引用的研究报告；
对复杂主题进行长期分析。

14.3 多步骤数据分析

例如：

读取原始数据；
编写分析脚本；
生成图表；
检查异常值；
修改分析逻辑；
输出最终报告。

14.4 视觉和代码结合的任务

例如：

根据截图还原网页；
调整前端页面布局；
根据视频制作动画；
进行游戏原型开发；
分析图表和复杂文档。

14.5 需要持续执行的 Agent 任务

例如：

自动搜索资料；
调用多个外部工具；
长时间规划和执行；
反复验证结果；
生成最终可交付成果。

17. 组会汇报时可以这样总结

Kimi K3 的优势不是单纯把参数量做大，而是围绕真实的长程任务重新设计了整个系统。

在模型结构上，它用 KDA 降低长上下文的计算压力，用 Attention Residuals 改善深层网络的信息流，用 MoE 提高模型容量；在训练上，它重点训练模型进行长时间的推理、工具调用、观察、验证和修正；在工程上，它又通过 MoonEP、FlashKDA 和长上下文强化学习基础设施，把这些设计真正训练和部署起来。

所以 K3 在长程编程、复杂搜索和 Agent 知识工作中表现突出。它的领先更像是“架构、训练数据、强化学习环境、Agent 框架和系统工程共同形成的结果”，而不是某一个单独技术带来的奇迹。

18. 最后用一句大白话概括

普通模型更像一个回答问题的人，Kimi K3 更像一个可以带着资料、电脑和工具，连续工作很长时间的研究员或工程师。

它真正的优势是：

看得更多
记得更久
能调更多专家
能调用更多工具
能持续检查和修正

但代价也很明显：

训练和部署成本高
复杂任务耗时长
对 Agent 框架要求高
并不是所有任务都全面领先