学习目录 · 8 个单元

DEEPSEEK V4.1 · VISUAL READER

从 Transformer,
读懂 DeepSeek V4.1

模型怎样从已有文字生成回答?V4.1 怎样减少重复计算和缓存开销?从文字、位置和缓存出发,一步步看清这份报告。

选择阅读路线

完整计算图可视化

01 · 计算看懂位置、注意力与 Q / K / V 缓存

02 · 结构区分已有方法和这一代的主要变化

03 · 原因解释每项变化省去了哪些工作

按图找主题

从你感兴趣的图解开始

70 个图解入口

点击缩略图直达对应图解。先看核心主题,或筛选、搜索全部可视化。

网页作者仓库 · concentrate1/share ↗

01候选 → 选择 → 追加

学习单元 1 / 8

一轮回答是怎样完成的

给定一句开头,模型反复计算候选、选出下一项,再把它追加到已有文本。沿着这个循环,一句话逐步形成。

一个词怎样从候选变成下一轮的输入?

从较长的开头“午后,小猫趴在窗边,正在”出发,观察后面的整句怎样逐步形成。模型处理的文字小单位叫 token,图中的词块是为教学安排的切分。

已经给定的开头

已加入 0 / 6 个新 token
1计算候选2选出输出3加入输入
已有文字 · 输入按位置排列,新增项接在右端
位置 1午后位置 2位置 3小猫位置 4趴在位置 5窗边位置 6位置 7正在
准备处理 7 个已知位置候选概率 · 满长为 100%
点击下方“计算下一项候选”,这里会列出三个候选和各自的概率
本轮输出
位置 8
尚未选定

开头的 7 个位置已经给定。先根据这些输入,计算下一项的候选。

已经确定的文字

午后,小猫趴在窗边,正在

首轮逐步观察;熟悉后,可用“完成本轮/下一轮”依次完成该轮剩余动作。上方保留输入,问号表示本轮输出尚未选定。

词块切分、概率与选择结果均为教学设定。演示在句号处结束;真实生成由模型与请求设置共同决定停止条件。
把刚才这一轮放回全程

刚才循环里的已有 token 对应图的输入,选中并追加的 token 对应图的输出;中间的表示更新、历史复用和候选计算,会在后续单元逐章展开。

模型里,数字沿着一层层计算继续变化

每轮都使用同一组模型参数。注意力把不同位置的信息联系起来;前馈网络继续变换各位置的表示。

第一轮 · 已知输入午后,小猫趴在窗边,正在
  1. 1
    嵌入与位置处理每个文字 token 查表得到一条向量。V4.1 的嵌入向量有 5,120 个分量(5,120 维),如 h = [0.2, −0.4, …]。
  2. 2
    Transformer 层 · 逐层更新隐藏向量
    注意力汇总可见位置的信息前馈网络变换各位置的表示
    这样的层依次堆叠,持续更新向量的各个分量。主干中每路隐藏表示保持 5,120 维;注意力与前馈模块内部会使用其他维度。
  3. 3
    输出层末尾位置“正在”的最终隐藏向量 → 下一 token 的候选分布。
从候选中选出本轮输出睡觉接回输入,进入下一轮

向量就是按顺序排列的一组数;“维度”是这组数的个数。方括号展示前几个分量,省略号代表其余分量。后面会展开 V4.1 如何让同一位置同时保留四路这样的向量。

这组负责语言计算的层,统称语言主干。图中省略多头注意力内部、归一化与残差细节;先在输入表示中分清内容与位置,再到注意力路径放大一个头,并观察多个头如何合并。
生成循环与逐 token 输出的依据

Token 是模型处理序列的单位,与汉字、词语的边界可能不同。图中选词用于演示生成流程;实际采样还受温度、top-p 等设置影响。

报告 §2.1 · 第 7 页
从候选回到下一轮

末端表示怎样变成下一个 token?

推进一次,观察候选分数如何变成一个新 token,并重新接回输入端。

展开:参考实现中的精确末端链路

编号 39 的最后一层完成前馈网络(FFN)写回后,最终汇合用这个 FFN 产生的混合系数,把同一位置的四路 mHC 隐藏状态加权为一条向量。RMSNorm 随后稳定它的尺度;独立的输出头读取最后一个位置,给词表中的 129,280 个候选各产生一个 FP32 logit。

采样温度 T 大于 0 时,参考生成器先计算 softmax(logits / T) 再采样;T 等于 0 时直接取最大 logit。选中的 token 写入序列,当前位置向前推进,下一轮只处理这个新增位置。

四路状态Σ AjXjRMSNorm129,280 个 logitssoftmax 概率(T > 0)/ 直接 argmax(T = 0)选中 token追加 token下一轮

这一链路对应公开参考实现的普通逐 token 生成。DSpark 的服务端验证、采用与缓存提交循环没有随参考生成器公开,因此在候选验证单元按报告披露范围单独说明;tokenizer 解码也在模型前向之外完成。

是什么让这一轮接到下一轮?

本轮选中的 token 追加到序列末尾,成为下一轮新增位置的输入;生成过程由“选择并追加”接回“读入”。

继续下一单元
02输入位置 → 初始向量

学习单元 2 / 8

输入怎样成为表示

上一轮追加的 token,进入模型后怎样参与计算?

以“小猫正在睡觉”为例:三个位置先取得初始表示,左侧上下文再更新这些表示;图片也会沿自己的支路形成视觉 token。

输入序列中的每个位置先取得一条数值向量

以“小猫 正在 睡觉”为例:位置 1、2、3 先标出次序;每个位置的 token 身份决定查词嵌入(embedding)表中的哪一行,得到的整行数值就是该位置的初始向量。

用户已提供小猫正在睡觉

将鼠标移到词块上,查看这个位置对应的数字。触屏可点按,键盘可聚焦。

位置 1 · 小猫这个位置对应的嵌入向量

括号里是这组向量的数值,包含正数和负数。这里只展示前 4 个维度;位置处理还会帮助注意力区分先后顺序。

数字为教学示意;词义通常由多个维度共同表达,真实向量包含更多维度。

词的身份进入模型后,表示会随上下文继续更新

输入先确定每个位置的词身份。因果 Transformer 随后用当前位置及其左侧内容更新这个位置的表示,并用更新结果预测下一项;可参考的范围由因果遮罩规定。

本图的输入已经给定
位置 1小猫位置 2正在位置 3睡觉

点选一行,观察该位置能参考哪些输入。

每一行计算一个位置的表示;每一列是可供参考的输入。
正在更新
哪个位置?
参考位置 1小猫参考位置 2正在参考位置 3睡觉参考位置 4待加入
××
×
● 可以参考× 被因果遮罩挡住— 尚未加入

把句号加入后,位置 2 原来允许参考的两个位置保持不变。

完整已知句子可以在训练中一起处理,但每个位置仍遵守同样的因果限制。推理时尚未生成的未来文字自然还未进入输入。
与 Transformer 原始结构的关系

相同的部分:V4.1 仍是一摞因果自注意力层——每层先读上下文、再逐位置加工;同一层里已知位置可以一次算完,而每个位置只允许参考它自己和左边。这一套来自原始 Transformer,本教程前面算的那一次注意力就是它。

不同的部分:原始结构里,每层各自算出自己的一整套 K/V,注意力读取全部历史。V4.1 改的正是这两件事:后 20 层的主 K/V 只算一次——第 21 层把第 20 层的输出乘上本层的 K/V 投影矩阵,得到一份;第 22–40 层直接读这一份,不再各算各的(CED),每次注意力又只读索引器选中的少量条目,外加最近 128 个位置(CSA²)。层的排布和因果限制没有变,变的是 K/V 从哪里来、每次读多少。

原始 Transformer 论文 §3.1 ↗Transformer Explainer ↗
再沿图片支路前进

图片内部与语言序列,是两种可见范围

图片还在视觉编码器里:各个图像位置可以彼此交换信息,先形成带上下文的视觉表示。

图片表示进入语言主干后:它们与文字一起排进序列,后续位置按因果顺序读取已经出现的位置。

下面沿 patch(把图片切成的固定大小方块)、视觉编码、九邻域拼接与对齐走到视觉 token;Q、K 怎样得到匹配分数,会在下一单元的一层运算中展开。

图片先经过视觉编码器,再与文字一起进入语言主干

“编码器”描述的是一段网络的职责。在 V4.1 中,视觉编码器把图片变成视觉特征因果编码器是语言主干的前 20 层,继续处理已经合流的图文表示。图中的 DeepSeek-ViT 就是这套视觉编码器(ViT 即 Vision Transformer,视觉 Transformer);MLP(多层感知机)是一小段全连接网络,这里负责把拼好的长向量映射到主干需要的维度。

1A

文字支路

文字输入请描述图片
词嵌入把文字 token 转成向量
输出向量直接向下传递
文字嵌入
1B

图片支路

图片输入待描述的图片
视觉编码器 · DeepSeek-ViT32 层,得到空间特征网格
拼成一条长向量
MLP
映射维度
9 × 1,024 维 → 9,216 维 → 5,120 维展开拼接图示 ↗
视觉嵌入
2合成一条输入序列
文字文字
本图 · 1本图 · 2

视觉嵌入放在图像标记对应的位置,与文字嵌入一起交给下游网络。

3语言主干 · 共 40 层
因果编码器第 1–20 层

逐层处理图文表示,形成第 20 层的输出 H20

每层前馈:MoE(专家混合)第 2、15 层:Engram(记忆模块)
解码器第 21–40 层

继续更新表示;主注意力读取由 H20 构建的主 K/V。

每层前馈:MoE(专家混合)输出下一文本 token 的分布

32 层与 40 层分别属于两套网络。视觉编码器位于图文合流之前;因果编码器位于合流之后,占语言主干的前一半。

图片支路先形成网格,再缩减位置数。DeepSeek-ViT 更新每个图像小块的特征;其后的对齐模块将相邻九个位置的向量拼接,再映射成语言主干接收的一条向量。下方用 3 × 3 小网格展开。

依据:V4.1 报告 §2.1.1§4.2.1;Engram 位置见 §2.4.2。合流序列为位置示意,实际文字 token 数与视觉位置数由输入决定。完整模型还包含视觉训练与多模态专家负载均衡,本节聚焦网络中各部分的位置。
DeepSeek-ViT:专门处理图像的 Transformer 网络。

它先把图片切成小块,给每块产生一条向量,再用注意力和前馈网络更新这些向量。输出仍是一张带有空间位置的特征网格,随后由对齐模块转成语言主干接收的视觉嵌入。

一张图片,从像素到视觉 token

14 × 14 像素是 V4.1 固定的 patch 大小。调整输入图片尺寸,观察缩放后的像素、ViT 网格和进入语言主干的 token 数怎样变化。

单张图片 · 估算968 token
① 原图 → 预处理
同一张图片
1,920 × 1,080 → 1,708 × 966 px按 token 上限缩小并对齐网格;patch 大小保持 14 × 14。
② ViT 处理特征网格
69 行 × 122 列 = 8,418 个 patch细格:14 × 14 像素的一个 patch
粗格:稍后拼接的 3 × 3 特征组
灰边:补齐整组的位置
③ 拼接 + MLP → 视觉嵌入
23 行 × 41 列 = 943 个视觉内容 token每格是一条 5,120 维视觉向量
一格 = ② 中的一个 3 × 3 粗格
本图中的全部格子来自同一张图片
23 × 41 + 23 + 2 = 968 token视觉内容 943 + 行末标记 23 + 图片起止标记 2;特征网格边缘补齐到 3 的倍数。

以上全部来自同一张图片。图片序列按行排列,包含视觉内容、每行的换行标记,以及图片起止标记。单图最多 1,024 token;小图会放大,大图会缩小,边缘按网格对齐。

官方图片 token 计算器的 V4.1 规则计算(核对于 2026-09-11);网格与标记结构对照公开预处理实现。本演示使用普通图片尺寸估算,实际用量以 API 返回为准。

从上面的特征网格到视觉 token:每九个邻居拼成一条

DeepSeek-ViT 把每个 14 × 14 像素块投影到 1,024 维,经过 32 层视觉 Transformer 和二维位置编码后,输出仍是每位置 1,024 维的特征网格。取其中相邻的 3 × 3 个位置。先把九条向量的数值排在一起,再交给 MLP。例如 A = [1, 2]、B = [3, 4] 时,拼接就是把 1、2、3、4 等分量保留到同一长向量中。图中一个字母代表一整条向量,数值例子仅用于说明拼接:

ABCDEFGHI
九个位置 → 一个位置的长向量[A 的数值,B 的数值,…,I 的数值]9 × 1,024 = 9,216 个分量;此时只重排数值。
再经过两层 MLP 投影9,216 维 → 5,120 维视觉嵌入MLP 在这一步学习怎样组合、变换九个邻居的信息。

网格上各个不重叠的 3 × 3 邻域同样处理,位置数约为原来的 1/9。字母顺序用于说明拼接;实现按固定的通道与空间顺序排列。V4.1 的层数、维度与对齐结构依据报告 §2.1.1§4.2.1

空间实验 · 图片怎样变成视觉 token

九个图像小块,合成一条让语言主干读取的表示

图像进入视觉编码器后,每个图像小块(patch)的位置保存一条 1,024 维特征向量。模型把相邻九个位置合成一组,再用两层学得的变换生成一个 5,120 维视觉 token。下面用一张 84 × 84 像素照片和完整的五维教学数值,逐步看清对象、拼接和来源关系。

教学输入 · 84 × 84 像素
一只橘白猫的照片,图片上覆盖六行六列的可选网格

第 2 行,第 2 列
像素行 15–28,列 15–28
一块 = 14 × 14 像素

照片实际缩为 84 × 84 像素后显示;每框是一块 14 × 14 像素的 patch。

照片:Fir0002/Flagstaffotos · GFDL 1.2,已缩放并作局部放大。

6 × 6 × 5 · 教学特征张量
拖动 / 方向键旋转 · 点击小格选择整条向量竖直深度确实表示向量的五个特征分量
第 2 行,第 2 列教学向量 · 5 维

真实对象:每位置一条 1,024 维向量
教学对象:每位置一条 5 维向量

五个有顺序的数合在一起,才是这个位置的一条向量。选中位置时,五个分量会一起高亮。

6 × 6 个位置,各有 5 个分量
教学张量共 180 个数

选择照片中的一块,再拉出它对应的完整教学向量。

真实尺寸、拼接顺序与来源

照片先按 14 × 14 像素切成图像小块。每块有 14 × 14 × 3 = 588 个 RGB 颜色数值,经可学习的线性投影进入 1,024 维视觉空间,再由视觉编码器结合整张图的信息更新。这里的五维教学向量是为解释张量结构而设的固定数值,不是从照片算出的特征,也不是实际向量的前五项。

每个分量段都按从上到下、从左到右的次序收集九个位置:

    官方 vision.py 先把视觉网格从 [高, 宽, 特征] 调整为 [特征, 高, 宽],再用 PyTorch unfold 取 3 × 3 区域。因此 9,216 维输入按特征分量优先排列:第 1 个分量的九个空间位置在前,然后是第 2 个分量的九个位置,直到第 1,024 个分量。上面的 5 × 9 教学打包与这个顺序一致。

    Aligner 在边缘不足时先补齐,再执行 Linear(9,216→5,120) → GELU → Linear(5,120→5,120)。输出与语言隐藏维度相同,可作为视觉 token 写入输入序列。真实视觉特征会融合其他位置的信息,因此“来自九块”描述的是重排时直接收集的九个位置,并不把特征的感受范围限制在这 42 × 42 像素内。

    84 × 84 与 6 × 6 是缩小教学输入,不代表模型固定分辨率。尺寸依据:官方配置官方 vision.py · Aligner技术报告 §2.1.1

    同一位置的一条向量

    从教学的 5 项,到实际的 1,024 项

    维度就是一条向量包含的分量数。下面每格宽度相同:1,024 项的长度是 5 项的 204.8 倍。这里比较的是分量的个数,格子里不放数值——真实模型的这 1,024 个数由输入决定,本页不引用某一次具体运行的结果。

    教学 · 5 项
    实际 · 1,024 项横向滚动,或用下方滑块定位
    全长:第 1–1,024 项当前窗口

    两条横条用同样宽的格子:上面 5 格,下面 1,024 格,横向拖动就能看出后者有多长。五维教学向量是独立算例,数值不对应实际向量的前五项。

    V4.1 的两段注意力:视觉编码器双向,语言主干因果

    同一张图片先经过视觉编码器,再以视觉嵌入进入语言主干;两段使用不同的可见范围。下图以三个位置说明连接规则。行发起查询,列提供信息;● 表示允许直接读取,— 表示本行不可读。

    ① ViT 内部:同图位置双向互看

    同一图像的三个特征位置
    查询 / 读取块 A块 B块 C
    块 A
    块 B
    块 C

    各位置结合整图信息,输出视觉特征;随后经过九邻域拼接与 MLP,形成视觉嵌入。

    ② 语言主干:按因果范围读取

    同一张图片的三个视觉嵌入 · 位于局部窗口内
    查询 / 读取本图 · 1本图 · 2本图 · 3
    本图 · 1
    本图 · 2
    本图 · 3

    局部分支读取自身与左侧窗口;全局分支在因果允许的历史条目中筛选,再计算注意力。

    两个表都跟随同一张图片,展示其不同阶段的连接规则,位置之间经过对齐模块转换。例如“本图 · 1”在语言层只直接读取自身及可见前文,但它的输入向量已经包含 ViT 融合的整图信息。

    与 V4-Flash-Vision-Exp 的区别:两者的 ViT 都采用同图双向注意力。实验版还在语言主干的局部分支扩展图像范围,让同图右侧位置可见;V4.1 公开参考实现使用上图的因果窗口。图像标记在 V4.1 中另用于视觉 MoE 路由偏置,并让视觉位置跳过 Engram。

    核对依据(2026-09-11):V4.1 vision.py:ViT 与对齐模块model.py:局部窗口、压缩索引及图像标记;对照 实验版图像可见范围实现。上述对比针对官方发布的参考代码。

    文字与图片最后以什么形式进入语言主干?

    文字经过 embedding,图片经过 patch、视觉编码和对齐;两条支路最后都形成按位置排列的向量,并保留各自的位置身份。

    继续下一单元
    03读取上下文 → 加工当前位置 → 写回

    学习单元 3 / 8

    一层怎样更新表示

    一个位置怎样先读取上下文,再继续加工并写回?

    Q、K、V 决定注意力怎样取信息;在这之上还有位置旋转、多头合并和专家加工。这些局部清楚以后,完整一层与层内的写回路径就有了落点。

    阶段 1 / 4

    从 Q、K、V 得到多头注意力输出

    一次查询走完匹配、权重与汇总,随后是位置旋转和多头合并;同一层的 K/V 会追加接回生成过程,三维向量则显示方向怎样改变匹配。

    Q、K、V 怎样连接不同位置?

    Q 是查询,K 是参与匹配的键,V 是被汇总的值。下面是它们怎样连接,随后用三个位置的具体数字完成一次计算。

    下面几张 Q / K / V 图解的用色蓝:查询 Q紫:键 K青绿:值 V琥珀:本轮新增
    通用基础 · 后续创新的起点

    注意力怎样汇总不同位置的信息?

    这次输入已经完整给定:“小猫 正在 睡觉”。这一次要算的是位置 3 的内部表示;它经过后续层和输出层,才能用于预测“睡觉”后面的内容

    这里放大的是一个注意力头。多头注意力(Multi-Head Attention)会并行执行多组查询与汇总,再合并结果。下面只沿其中一个头计算,末尾再看怎样合并。

    本次已知输入
    位置 1小猫位置 2正在位置 3睡觉
    本节跟踪位置 3 的计算
    一个注意力头的完整计算路径连线总览 · 四步算例

    输入 H 的每一行对应一个位置。三组投影分别产生 查询 Q键 K值 V;查询与键决定权重,权重再用于汇总值。

    详解
    详解
    详解
    详解

    全图:从 H 的三组投影开始,沿连线追踪到输出 Z。

    图内可以横向滑动,查看右侧的权重与输出。
    H 经三组投影产生 Q、K、V,计算权重后汇总 V,得到 Z 本图同时包含三个已知位置,每个矩阵的三行分别对应小猫、正在、睡觉。H 分别乘查询、键和值的投影矩阵,得到 Q、K、V。Q 乘 K 的转置得到分数 S。分数除以键维数的平方根,遮住未来位置,再对每行做 softmax(把一行分数换成总和为 1 的权重),得到权重 A。A 乘 V 得到该头输出 Z。下方算例追踪第 3 行。 ① 三组投影② 查询与键匹配 该层输入H=h1h2h3每行一个位置 WQ查询投影WK键投影WV值投影 Q=q1q2q3各位置的查询K=k1k2k3各位置的键V=v1v2v3各位置的值 矩阵相乘S = QKT每个查询 × 各个键 KTS ③ 分数变成权重除以 √dk未来位置设为 −∞每行做 softmaxdk 是每个键的维数 注意力权重 A每行权重总和为 1 未来位置的权重为 0可见位置的 V 按权重相加 A × V④ 加权汇总 Z输出 V

    图中三个位置同时保留:矩阵 HQKVZ 的第 3 行都对应“睡觉”。A 的第 3 行给出它读取各位置的权重。下方追踪这一行的具体数字。

    Rotary Position Embedding(旋转位置编码,RoPE)把一条向量的分量两两配对,按它所在的位置旋转。旋转不改变每一对分量的长度,只让两个位置的相对距离影响后面的点积——所以它必须发生在投影之后、打分之前。V 不旋转,输入处的 embedding 也不因此改变;每一层都重做一次,因为每层都有自己新算出的 Q 和 K。V4.1 里每个头的 512 维只有末 64 维参与旋转,其余分量原样参加点积;索引器另有一套自己的 Q、K,同样在打分前旋转末 64 维。

    1

    同一个位置,生成三种用途的数字

    该层输入 H 每个位置占一行。分别乘三组矩阵,就得到查询 Q、键 K、值 V;这个乘法叫投影

    Q=H×WQ
    K=H×WK
    V=H×WV
    沿一列看同一位置位置 1小猫位置 2正在位置 3睡觉
    H这一层的输入表示h1=[1,0]h2=[0,1]h3=[1,1]
    Q查询:与各位置的键匹配q1=[1,0]q2=[0,0.5]q3=[1,0.5]
    K键:参与匹配,得到分数k1=[0.5,0]k2=[0,1]k3=[0.5,1]
    V值:提供被加权汇总的内容v1=[1,0.2]v2=[0.1,1]v3=[1.1,1.2]

    大写 H、Q、K、V 表示包含所有位置的矩阵;小写 h₃、q₃、k₃、v₃ 表示其中位置 3 的那一行。等号右侧的方括号列出向量分量。为便于核算,本例只用 2 维教学数字,各维共同构成数值特征。

    查看本例使用的三组矩阵

    W 是训练得到、推理时使用的参数。下列数字仅用于这个算例,乘法在每个位置上都相同。

    WQ=[1000.5]
    WK=[0.5001]
    WV=[10.20.11]
    2

    位置 3 的查询,分别与三个键匹配

    继续使用上表的 q3。因为三个位置都在它的可见范围内,这次得到三个匹配分数。

    q3=[1,0.5]同一个查询,参与下面三次匹配
    位置 1 · 小猫
    k1=[0.5,0]
    q3·k12
    0.354匹配分数
    位置 2 · 正在
    k2=[0,1]
    q3·k22
    0.354匹配分数
    位置 3 · 睡觉
    k3=[0.5,1]
    q3·k32
    0.707匹配分数

    向量点积得到分数,再除以 √2(本例每个键有 2 维)。如果计算位置 2,位置 3 属于未来,它的分数会被遮罩为 −∞,最终权重为 0。

    3

    把三个分数变成总和为 1 的权重

    softmax 是这里的归一化计算:分数越高,分到的权重越大。每条轨道的全长都代表 100%,蓝色填充的长度表示这一项权重。

    位置 1 · 小猫分数 0.354
    0%100%
    29.2%注意力权重
    位置 2 · 正在分数 0.354
    0%100%
    29.2%注意力权重
    位置 3 · 睡觉分数 0.707
    0%100%
    41.6%注意力权重
    三个权重相加 = 100%
    4

    按权重汇总三个值,得到新的表示

    回到上表的 v1v2v3。每个值先乘自己的权重,再把结果相加。

    位置 1 · 小猫
    v1=[1,0.2]
    0.292×v1
    [0.292,0.058]
    这一位置的加权结果
    位置 2 · 正在
    v2=[0.1,1]
    0.292×v2
    [0.029,0.292]
    这一位置的加权结果
    位置 3 · 睡觉
    v3=[1.1,1.2]
    0.416×v3
    [0.457,0.499]
    这一位置的加权结果
    三个加权结果相加z3[0.779,0.85]

    位置 3 得到一次注意力计算的输出。它汇入该位置的后续计算;此处输出的是数字表示

    显示数字经过四舍五入,实际计算使用未舍入值,所以这里用 ≈ 表示近似。这仍是一个注意力头的局部输出;它还要与其他头合并,再经过后续网络。

    空间实验 · 单头注意力

    改变查询 Q,看哪一个位置得到更多注意力

    图中最粗的一支箭头是位置 3 的查询 q,另外三支是位置 1–3 的键 k₁、k₂、k₃;每支箭头的颜色见图下图例。先让 q 朝向一支 k,再看右侧哪条权重变大。

    同一组权重连接两个空间
    改变蓝色查询 Q下面三项只改 q 的方向或长度
    方向预设
    观察哪条权重变大选择一个方向预设,比较右侧三条权重。
    匹配空间 · q 与 k观察视角 · 不改变 Q/K/V 数值
    向量坐标、匹配分数、权重和输出均列在旁边的数值区。
    拖动画布 / 方向键:只改变观察视角

    分数 sᵢ = q · kᵢ / √3
    权重 α = softmax(s)

    当前完整查询向量 q

    键向量 kᵢ分数 sᵢ权重 α
    V 空间的汇总向量 zz = α₁v₁ + α₂v₂ + α₃v₃

    每支箭头表示一条完整三维教学向量;旋转画布只帮助观察,不会改动计算。

    三维图、数值与公式怎样对应?

    本实验追踪位置 3 的一次标准注意力计算,位置 1「小猫」、位置 2「正在」、位置 3「睡觉」均可见。它使用固定的三维教学 k、v,并独立调整 q;这些数字用于说明几何与公式,不是模型内部 latent 的前三项。

    一个箭头对应一个完整的三维向量;[a, b, c] 列出这个箭头的三个分量。方向预设根据目标 k 的三个分量计算 q 的方位角和仰角,因此 q 会与该 k 平行;q 的长度仍由“查询 Q 的长度”控制。

    汇总视图中,淡色虚线是原始 v,实线是 αᵢvᵢ。把加权向量首尾相接只改变画在何处,三个分量保持不变;原点到链条终点的深色箭头就是 z。

    标准公式依据:Attention Is All You Need · §3.2

    多个注意力头怎样合成一次输出?

    同一层的输入同时送入多个头。各头可以得到不同的权重与汇总结果,再把这些结果拼接,经过输出投影。

    注意力头 1查询 → 匹配 → 汇总得到本头结果 Z(1)
    注意力头 2查询 → 匹配 → 汇总得到本头结果 Z(2)
    注意力头 3查询 → 匹配 → 汇总得到本头结果 Z(3)
    拼接各头结果,再做一次矩阵乘法O=Concat(Z(1),Z(2),)×WO

    上标 (1)、(2) 表示头编号;每个大写 Z 都是一整个头的结果矩阵,其中每行仍对应一个位置。这里用 3 个头示意多头计算。多个查询头也可以共享 K/V;这与后文的跨层缓存共享是两种不同的共享关系。

    把上面的计算接回逐步生成

    同一层为什么只需为新位置追加 K/V?

    现在回到生成场景:最初只提供“小猫 正在”。模型算完这两个位置,选出“睡觉”;随后把刚选出的词送回模型,为预测后面的内容做准备。

    沿时间向下看位置 1小猫位置 2正在位置 3即将新增的位置
    A处理完输入下一项的分布已得到k1v1已保存k2v2已保存下一项尚未选出
    B选出“睡觉”文字已经确定k1v1保持原样k2v2保持原样睡觉自己的 K/V 待下一轮计算
    C处理“睡觉”预测再下一项k1v1沿用已有结果k2v2沿用已有结果k3v3由新位置计算
    本轮新算 q3

    仍按上面的四步:与 k1k2k3 匹配,再汇总 v1v2v3

    旧位置的前文保持相同,因此旧 K/V 可以继续用。

    右侧加入“睡觉”后,位置 1、2 仍只能读取原来的前文。新一轮需要新的查询 q3,这次匹配由新查询发起。

    这里展示标准因果自注意力的一层。不同层通常各有自己的缓存;DeepSeek 对哪些层共享、保存哪些形式的状态作出的改动,将在后文单独标出。KV 缓存本身是沿用的通用技术。

    基础公式参考:Attention Is All You Need · §3.2

    注意力计算与 K/V 复用的依据

    “缓存”避免历史 K/V 的重复计算,但保存、读取和传输缓存本身仍有代价。长上下文与高并发都会放大这种代价。V4.1 将保存长历史的数据,与保存最近窗口的数据分开组织和存储;CED 的层间分工将展开这两条路径。

    报告 §2.1 · 第 7–8 页;§3.2 · 第 18–20 页
    阶段 2 / 4

    读完上下文之后,少量专家继续加工当前位置

    注意力先把可见位置的信息汇到当前位置。Mixture of Experts(专家混合,MoE)再计算路由分数,选出少量专家分别加工,并按权重合并结果。

    沿用 DeepSeekMoE · 每个位置选择部分专家

    同一层有很多专家,一个位置只调用其中几个

    MoE 是 Mixture of Experts,中文常称混合专家。一个专家是一套前馈网络;路由器根据当前位置的输入表示,决定这次使用哪些专家。

    观察一层 MoE,切换它正在处理的位置三个位置均已给定 · 路由与数字为教学设置
    本层正在处理位置 1 · 小猫该位置的一份输入表示
    路由器给 384 个路由专家打分选出本次参与的 6 个
    输入送给选中的 6 个专家同一份输入也送给共享专家
    384 个路由专家6 个本次参与
    每格 = 1 个专家;蓝色 = 本次参与悬停或用方向键查看编号
    #12#57#103#188#241#366
    1 个共享专家
    本次也参与

    每个位置都会经过它。

    共享专家输出
    6 个专家输出按权重相加同一专家可被多个位置调用
    共享专家输出随输入一起计算
    合并结果得到这个位置的 MoE 输出教学示例的一维结果:3.02

    位置 1 · 小猫:选中 #12、#57、#103、#188、#241、#366,另加共享专家;共 7 个专家参与。

    看一次数值合并:六份输出怎样变成一份?

    每位专家输出一条 5,120 维向量;方括号展示前两个分量,其余以省略号表示。权重乘整条向量,再逐分量相加;共享专家的向量另行加入。这里设置六个合计为 100% 的教学权重。

    专家 #12
    输出向量[1, 0.2, …]
    合并权重30%
    相乘后贡献[0.3, 0.06, …]
    专家 #57
    输出向量[2, 0.4, …]
    合并权重25%
    相乘后贡献[0.5, 0.1, …]
    专家 #103
    输出向量[3, 0.6, …]
    合并权重18%
    相乘后贡献[0.54, 0.108, …]
    专家 #188
    输出向量[4, 0.8, …]
    合并权重12%
    相乘后贡献[0.48, 0.096, …]
    专家 #241
    输出向量[5, 1, …]
    合并权重10%
    相乘后贡献[0.5, 0.1, …]
    专家 #366
    输出向量[6, 1.2, …]
    合并权重5%
    相乘后贡献[0.3, 0.06, …]
    路由专家加权和[2.62, 0.524, …]
    共享专家输出向量[0.4, 0.1, …]
    MoE 输出向量[3.02, 0.624, …]

    这是可核算的教学算例。真实路由还涉及归一化与缩放等配置;负载均衡的校正偏置用于选择专家,所选专家的输出权重仍取自原始路由分数。

    把这一层放回整网:前 20 层因果编码器与后 20 层解码器都使用 MoE 前馈网络;40 层各自拥有专家和路由器。图中的 384 个路由专家与 1 个共享专家属于其中一层。

    每个专家编号对应一套前馈网络权重。训练会形成各专家的分工;这里用位置切换展示路由变化。配置依据:DeepSeek-V4.1 报告 §2.1.1§4.2.1

    阶段 3 / 4

    注意力与专家加工,合起来是完整的一层

    每个子模块前用均方根层归一化(Root Mean Square Layer Normalization,RMSNorm)稳定数值尺度,结果经残差路径写回。

    基础连接

    注意力与 MoE 在完整一层中的位置

    注意力从可见位置汇总信息;前馈网络继续变换每个位置的表示。在 V4.1 中,MoE 承担前馈网络的工作。

    通用 pre-norm Transformer 层 · 理解连接的教学对照每个子模块前先归一化,再把计算结果加回原表示。图中跟随同一个位置,小写 h、u 表示该位置的向量。
    1

    注意力更新

    当前输入h
    归一化
    注意力计算 Q/K/V,汇总可见信息
    保留 h
    原表示 + 变换结果u
    2

    前馈网络 / MoE更新

    当前输入u
    归一化
    前馈网络 / MoE路由专家,合并专家的输出
    保留 u
    原表示 + 变换结果h′

    残差相加:保留原表示,并加回子模块提供的更新。

    归一化:稳定输入的数值尺度,便于后续计算。

    一层输出 h′ 再进入下一层。V4.1 用下面的 mHC(流形约束超连接)组织残差连接,将这一条保留路径扩展为四路,并学习怎样混合它们。

    阶段 4 / 4

    写回时,怎样既保留已有状态又加入新结果

    上一阶段里,每个子模块的结果都沿一条残差路径写回。Manifold-Constrained Hyper-Connections(流形约束超连接,mHC)把这一条路径扩展成并行的四条,本文称为四路状态:同一个位置同时保留四条向量,新结果写入其中时,仍按学到的系数与已有信息混合。

    沿用 mHC · 本代改进 Single-Pass

    四路表示怎样经过一个子模块?

    mHC(流形约束超连接)让同一个 token 保有四份可分别更新的隐藏表示。这些表示沿深层网络保留、交换信息;每个计算模块可以重新组合它们,获得适合本次计算的输入。受约束的混合帮助维持深层信息传递的稳定。

    从文字 embedding 开始,追踪同一位置的向量

    V4.1 的一个文字 token 查嵌入表,得到 5,120 维向量 h。进入主干时,这条向量复制为四路;起点相同,随后各路按学到的连接分别更新。四路让深层网络保留多份中间表示,并在每次注意力和 MoE 计算前重新组合信息。

    文字 embedding
    1 × 5,120
    四路残差状态
    4 × 5,120
    子模块输入 / 输出
    1 × 5,120
    更新后的四路
    4 × 5,120

    5,120 是语言主干的隐藏宽度 d。注意力与 MoE 的输入、输出以及每路残差保持这个宽度;模块内部的 Q/K/V 投影、专家中间层等使用各自的维度。最后再把四路混成一路,由输出头映射到词表分数。

    注意力和前馈 / MoE 两次更新都使用四路连接。一个完整 Transformer 层依次完成这两个块;其中注意力汇总可见位置的信息,MoE 变换当前位置的表示。

    X当前 token 的四行向量组成的状态,形状为 4 × d。

    ℓ(ell)子模块块的顺序编号。ℓ+1 是下一块;“40 层”则数完整语言层。

    A / B / C三种连接职责:A 合成模块输入;B 混合保留路径;C 将模块输出分配回四路。下面是它们各自怎样作用,随后展开矩阵的尺寸和来源。

    四条向量经过一个块时:A 决定怎样合成模块输入,B 处理保留路径,C 把模块输出分配回四路。下图分别观察注意力与 MoE 的更新。

    先看作用:A 混合输入,B 保留并混合原状态,C 分配更新每个方括号都是 5,120 维向量;只展示前两个分量,其余以省略号表示。
    四路输入四路进入下一层
    1 / 4 · 观察当前输入

    普通残差 · 一行

    h = [4, 0.6, …]注意力保留 h等待更新

    mHC · 同一位置的四行 X

    [1, 0, …][3, 0.4, …][5, 0.8, …][7, 1.2, …]用前一块 A 混合四路F · 注意力C · 更新分给 4 路B · 保留并混合 4 路

    四路已在前面的计算中产生差异;本例从这个中间状态开始观察。

    教学向量与系数用于追踪连接:A 取四路平均,B 原样保留,C 把模块输出分别加到四路。F 包含归一化及注意力 / MoE 的内部计算;实际向量和系数由模型计算。

    四路怎样连接相邻的块?

    对照同一连接:输入混合 A 从哪一个块取得?A 负责送入子模块,B 负责混合保留路径,C 负责把新结果分配回四路。
    同一位置的输入 X4 路 × 每路 d 维
    第 1 路x(1)d 个数第 2 路x(2)d 个数第 3 路x(3)d 个数第 4 路x(4)d 个数
    A · 输入混合4 路加权组合成 1 路A:来自当前块
    F · 当前子模块注意力或 MoE
    1 路输入 → 1 路结果
    C · 输出分配把 F 的结果分配回 4 路
    B · 保留路径混合4 路 → 4 路
    各路之间也可交换信息
    保留路径
    的结果
    两条路径,按对应的流相加
    第 1 路x′(1)d 个数第 2 路x′(2)d 个数第 3 路x′(3)d 个数第 4 路x′(4)d 个数
    更新后的 Xℓ+1仍然是 4 路

    Single-Pass 改变 A 的来源

    前一个块已经产生Aℓ−1本模式使用当前块的 A
    读取当前四路 X,预测系数A、B、C等待跨维度汇总完成,A 才可使用

    当前块先汇总 X 的各个维度,算出 A,再读取 X 做输入混合。这条先后依赖带来额外的读取。

    两种模式中的 B、C,都由当前四路状态产生;当前子模块 F 的计算仍然保留。

    ℓ 是当前子模块块的序号;ℓ−1 指前一块。一个完整语言层包含注意力块和 MoE 块。

    Single-Pass 改变的是数据依赖,收益体现在部署时的读写。

    输入混合直接使用前一块已产生的 A,当前数据块到达后便可立即参与混合,同时累积新的系数。部署内核 Mega-mHC 因而能把残差更新、输入混合、系数预测合在一次遍历中。

    再看来源:A、B、C 是怎样算出来的?

    下面的 A 表示第 ℓ 块为当前 token 产生的系数矩阵;ℓ 是块的编号。固定观察一个位置时,省略位置下标。

    跟随同一个 token:本块读取它的四路向量,用训练得到的参数算出三组混合系数。新 token 带来新的状态,同一套参数据此算出新的系数。

    输入:当前 token 的四路状态随位置与计算进度变化
    x₁ = [1, 0, …]x₂ = [3, 0.4, …]x₃ = [5, 0.8, …]x₄ = [7, 1.2, …]

    每路 5,120 维 → 拼成 20,480 维 → 归一化

    本块的模型参数训练得到;生成时固定

    投影权重 W
    一个 24 行 × 20,480 列的矩阵

    另有训练得到的缩放和偏置;注意力块与 MoE 块各有自己的一套参数。

    线性投影,得到 24 个原始分数每个分数来自整条 20,480 维输入与 W 的对应行;再按三组分别缩放、加偏置并施加约束。
    4 个分数 → A16 个分数 → B4 个分数 → C
    A · 输入混合系数单个矩阵:1 行 × 4 列

    4 个分数 → sigmoid + 稳定项

    交给下一块四个系数分别乘下一块的四条输入向量,再相加成一条向量。
    B · 保留路径系数单个矩阵:4 行 × 4 列

    16 个分数 → Sinkhorn 行列归一化

    用于当前块每一行组合原来的四条向量;四行分别得到四路保留结果。
    C · 输出分配系数单个矩阵:4 行 × 1 列

    4 个分数 → 2 × sigmoid

    用于当前块四个系数分别缩放本次模块输出,再加回 B 得到的对应路。

    系数与向量怎样区分?a₁ 是一个系数,x₁ 是一条 5,120 维向量。a₁ × x₁ 会缩放向量的每个分量;四项相加的结果仍是 5,120 维向量。

    为什么 A 指向下一块?V4.1 的 Single-Pass 连接让本块使用前一块给出的 A;本块新算的 A 继续向后传。B、C 则直接用于本块的四路更新。ℓ 是产生这些系数的子模块编号。

    向量数值为教学示例;矩阵中的小写字母标记各个系数。实现依据:系数预测与混合缩放、偏置与约束

    进一步核对:连接公式与读写量
    原 mHC

    Xℓ+1 = BX + CF(AX)

    Single-Pass mHC

    Xℓ+1 = BX + CF(Aℓ−1X)

    A 为 1 × 4,B 为 4 × 4,C 为 4 × 1;各系数由预测器根据 token 的状态产生。混合矩阵受到流形约束;具体构造见报告引用的 mHC 论文。上图展示这些矩阵在网络中的连接职责。

    相关实现读写的数据元素数
    原多核 mHC(含 F 的输入预归一化)(4n + 4)d = 20d
    Mega-mHC 执行普通 mHC(3n + 2)d = 14d
    Mega-mHC 执行 Single-Pass mHC(2n + 2)d = 10d

    这里 n = 4,d 是每一路的维数。20d → 10d 衡量上述残差处理与输入预归一化涉及的激活读写量。整模型耗时还包含注意力、MoE、通信等计算;报告在预训练中仍采用多核实现,在部署中使用融合内核。

    依据:V4.1 技术报告 §2.4.1,式 (2)–(6);4 路配置见 §4.2.1。完整层图为通用 pre-norm 教学结构,V4.1 的残差组织以上述 mHC 图为准。

    空间实验 · mHC 四路连接

    四路状态怎样送进子模块,再带着新结果继续向后?

    同一个 token 同时保留四条完整状态。先把四路组合成一次计算的输入,子模块产生一条新结果;随后四路旧状态彼此混合保留,再分别加入这条新结果。

    四个完整向量首尾相加,得到一次计算的输入
    100%
    完整数值见相邻结果与展开明细。
    拖动 / 方向键旋转 · +/- 缩放 · Home 恢复淡色箭头是四路 X;实色首尾链是 A₁X₁ 到 A₄X₄;深色 u 是合成结果
    阶段 1 / 4A 怎样把四路变成一条子模块输入?
    跟随哪一路

    u=A前一块X=j=14AjXj

    用前一个块给出的 A 缩放四条完整向量,再把四项相加。

    查看四路输入与贡献
    来源完整向量 XjAj贡献 AjXj
    合成后的子模块输入 u

    展开:教学数值、真实维度与系数约束

    本图是完整三维算例。每个箭头的三个分量都参加缩放与相加;它不是从真实 5,120 维向量截出的前三项。真实模型中 X 的形状是 4 × 5,120,u、y 的形状都是 1 × 5,120,更新后仍是 4 × 5,120。

    本图的 X、A、B、C、y 都是固定教学数值。真实模型则把当前 token 的四路 X 拼成 20,480 个数,用训练得到且推理时固定的投影参数,动态算出本次 A、B、C。A = sigmoid(·) + εhc;C = 2 sigmoid(·);B 先做行 softmax 并加入 εhc,再进行 20 次 Sinkhorn 行列归一化。

    主干第一块还没有“前一个块”,公开实现用 [1, 0, 0, 0] 作为起始 A,只取第一路;从后续块开始,才使用前一个块动态算出的 A。本图的平均 A 用来展示四条贡献向量怎样相加。

    混合程度控件沿 B(λ)=(1λ)I+λB教学 变化。λ = 0 时只保留各路自己;λ = 1 时使用完整教学矩阵。这条路径的行和、列和都保持为 1。A 与 C 不要求和为 1。

    依据:V4.1 报告 §2.4.1公开模型实现 Block.hc_mixes公开 hc_split_sinkhorn 内核回看相邻块怎样传递 A

    继续探索完整模型

    注意力、专家加工与整层写回已经连成一条路径;下面可以继续查看图像输入、记忆和训练怎样接入同一个模型。

    注意力与专家混合各自怎样更新当前位置?

    注意力跨可见位置汇总信息;专家混合在当前位置选择少量前馈专家继续变换。两者的输出都沿本层写回路径更新隐藏表示。

    继续下一单元
    04保存历史 → 按位置读取 → 跨层复用

    学习单元 4 / 8

    四十层如何协作

    哪些结果重新计算,哪些结果可以跨层复用?

    一层已经能读取并加工当前位置。接下来是同一份长历史上,40 层怎样分工建立、筛选和复用历史信息。

    阶段 1 / 4

    保存的内容,和筛选用的位置

    一个新位置会遇到三件事:历史为何增长、怎样筛选,以及最后读取哪一份数据。

    先抓住三个压力

    为什么要改变层与层之间的协作?

    历史越来越大

    输入越长,可供注意力读取的历史位置越多,保存和读取它们都会增加开销。

    筛选反复发生

    相邻层若一次次为同一段历史重做候选筛选,会重复付出相近的索引工作。

    状态需要恢复

    会话返回或缓存缺失时,系统还要决定哪些状态长期保存、哪些可以从尾窗近似重建。

    沿同一个新位置追踪

    历史很长时,先找到位置,再读取内容

    1. 保存内容

      已经处理过的位置留下主 K / V,供后面的注意力读取。

    2. 给历史打分

      新位置的索引查询与每个位置的 Indexer K 匹配,得到用于筛选的分数。

    3. 留下位置编号

      Top-K 是分数最高的少量历史位置编号,指明接下来去哪里取信息。

    4. 读取对应内容

      注意力按这些编号读取主 K / V,完成真正的匹配与汇总。

    主 K / V 保存可读取的内容,Indexer K 服务位置筛选,Top-K 保存筛选结果。下一步再看 40 层怎样建立和复用这三类成果。

    阶段 2 / 4

    哪些是沿用的,哪些是这一代的改变?

    刚才这套保存与筛选的分工,前几代已经各自解决过一部分。对照沿革就能认出这一代真正改动的四处:其中两处在后面两个阶段展开,另外两处留到第 5、6 单元。

    KV 缓存、稀疏选择、多 token 预测都已有技术基础。V4.1 的重点,是在这些基础上重新安排跨层依赖与执行方式。

    前代各自解决了哪一类开销

    每一代只摘出与后续章节直接相关的机制;不同版本的具体配置仍应分别核对。

    V2

    把历史表示存得更紧凑

    MLA(多头潜在注意力)用低维潜在表示压缩 KV,让所有头共用同一条历史条目,把每个位置要存的条目本身变小;DeepSeekMoE(混合专家)让每个 token 只调用部分前馈专家。

    官方架构资料 ↗
    V3

    继续改进训练,并探索多 token 预测

    继承 MLA 和混合专家;MTP(多 token 预测)增加预测后续多个 token 的训练目标;后续预测模块按顺序衔接,也可用于先提出候选、再由主模型验证的推测解码。

    官方架构资料 ↗
    V3.2

    先筛选,再做主注意力

    DSA(DeepSeek 稀疏注意力)在 MLA 上加入索引器(负责筛选历史条目的轻量模块),让主注意力只处理选中的位置。

    官方架构资料 ↗
    V4

    压缩历史条目,再结合远近信息

    CSA(压缩稀疏注意力)与 HCA(强压缩注意力)处理长历史,搭配局部窗口;多 token 预测沿用前代。

    官方架构资料 ↗
    V4.1

    改变来源、增加共享、降低恢复成本

    CED(因果编码器—解码器)改变后半段主 KV 的来源;CSA²(第二代压缩稀疏注意力)复用缓存与部分筛选结果;主 KV 用 FP4(4 位浮点格式)近似保存数值。局部状态缺失时,只重算有限的近期窗口,近似补回缺失状态,这称为有界重放。跨头共享则做到只剩一条:一条 KV 就是一条 512 维向量,64 个查询头共用。

    所附 V4.1 报告 §2–3

    本教程重点追踪四项本代变化

    “本代变化”指报告采用或推进的具体设计,相关思想可能已有前作。

    01 · CED

    改变后半段 KV 来源

    长输入的大多数位置可以省去后半段的完整计算。受 YoCo(You Only Cache Once,只缓存一次)等前作启发。

    02 · CSA²

    在层之间共用数据与选择

    把 KV 共享、部分索引结果复用与分层检索组合起来。

    03 · 缓存方案

    主 KV 更小,局部状态可恢复

    主 KV 用更少的位保存近似数值;局部状态过期后,重放近期窗口来近似补回。

    04 · DSpark

    较小模块起草,主模型批量验证

    在已有多 token 预测和推测解码思路上,采用并行草稿与调度设计。

    架构沿革与本代变化的依据

    本次核对的阅读范围

    V2 官方架构说明V3 报告 §2.1–2.2、§5.4.3V3.2 报告 §2V4 报告 §2、§3.5。本导读以这些相关章节为前作比较的依据。

    V3.2 用稀疏主注意力减少历史读取,索引器负责筛选要读的位置。V4.1 进一步通过跨层复用,减少重复筛选;具体连接按各代配置区分。

    V4 已支持只持久保存全局缓存、按需重建局部 SWA 状态;当时恢复需要更长重算。V4.1 用有界近似重放缩小恢复范围。

    V4 报告版本与 V4.1 表中的 V4-Flash 对照版本应区分;本页只借前者说明机制沿革,不混用参数与成绩。

    报告 §2.2–2.3 · 第 9 页
    阶段 3 / 4

    前 20 层建立表示,后 20 层从同一边界读取

    Causal Encoder-Decoder(因果编码器—解码器,CED)把 40 层分为前后两段。前段逐层形成边界表示,后段的全局主 K / V 从这份边界表示建立。

    CED 怎样改变 40 层的分工?

    CED 全称 Causal Encoder–Decoder,意为因果编码器–解码器。理解它,需要同时看“层的职责”和“历史 K/V 从哪里来”。

    01 · 信息怎样组织

    同样是中文输入、中文输出,可以走两种路径

    用同一项任务比较:读一段中文,再用一句中文概括。关键在于输入与输出是否分别组织成两条序列,以及输出从哪里获得输入的信息。

    共同任务 · 概括这段话

    小猫趴在窗边,听见响声后睁开眼睛。

    两种架构都已经输出「小猫」,现在预测后面接什么。
    已有架构编码器–解码器源序列与输出序列分别处理
    源序列 · 已给定的资料小猫趴在窗边,听见响声后睁开眼睛。
    先处理源序列编码器
    经典 Transformer 中,每个源位置可以利用整个源序列。
    源侧 · 供解码器反复参考编码器输出 → 交叉注意力的 K/V
    输出序列 · 作为解码器的输入已有输出 小猫
    解码器
    1. 用因果自注意力处理已有输出。
    2. 由输出侧状态产生 Q,与上方源侧 K 匹配,再汇总源侧 V
    这一步跨越两条序列,叫作交叉注意力
    选出下一项 · 继续输出中文醒了
    两条序列、两组层:资料由编码器处理;已有输出由解码器处理,并读取编码器的结果。
    已有架构仅解码器 · decoder-only资料、指令与已有输出排成一条序列
    序列前段 · 任务与资料概括:小猫趴在窗边,听见响声后睁开眼睛。
    序列末尾 · 已有输出小猫
    处理同一条序列因果 Transformer 层
    每个位置利用自己及其之前的内容。输出位置通过自注意力,直接参考前面的任务、资料和已有输出。
    末尾位置完成各层计算得到输出「小猫」的上下文表示经输出层转换,得到下一项的候选分布。
    选出下一项 · 继续输出中文醒了
    一条序列、一组层:资料与输出共用这些层。自注意力的 Q 与 K/V 来自同一条序列。

    这两种架构都可以完成同语言任务。经典编码器–解码器的特点是分别组织源序列与输出序列,再用交叉注意力连接。V4.1 的 CED 则是在同一条因果序列内部重新分配前后两段的职责。

    原始 Transformer 论文 §3.1、§3.2.3 ↗;“醒了”为教学选词。这里只比较信息路径,完整层结构还包括前馈网络、残差连接等。

    02 · 本代改动

    编码器的作用:先把长历史准备成后面能直接使用的 K/V

    阅读长资料时,较早位置提供历史 K/V,序列末尾的位置负责预测下一项。CED 让前 20 层形成的历史表示,直接成为后 20 层主 K/V 的来源。

    V4.1 的语言主干总计40 层
    处理全部输入,准备历史状态前 20 层 · 因果编码器
    利用历史,继续形成输出后 20 层 · 解码器

    这里的前 20 层仍采用因果计算:位置 i 只能利用它自己及其之前的内容。读入长输入时,前 20 层处理全部位置,准备历史状态;后 20 层利用这些历史,只继续处理输入末尾的一小段。开始逐步生成后,每个新增位置都经过全部 40 层。经典源编码器通常可以利用整个源序列。

    主 K/V · 保存长历史,按需选择

    保存长历史中的主 K/V。每次注意力计算再从中选取部分条目;本次未选中的条目仍留在缓存中,供后续使用。

    局部 K/V · 保留最近窗口

    保存靠近当前位置的 128 个位置。这条局部路径称为 SWA,即 Sliding-Window Attention(滑动窗口注意力)。

    CED · 改变来源后半段主 K/V 由第 21 层从第 20 层的输出投影得到。

    CSA² · 压缩、共享与筛选安排每组包含几个位置、哪些层共用缓存,以及本层选用哪些条目。查看 CSA² 的实际层配置

    同深度教学对照普通逐层构建 K/V用 40 层保持比较条件相同
    第 1–20 层逐层更新各位置
    1234567891011121314151617181920
    H20每个位置完成第 20 层后的表示
    第 21 层 K/V历史位置的 H20 → K/V21
    先完成第 21 层计算这个历史位置才能得到 H21
    第 22 层 K/V历史位置的 H21 → K/V22

    同样的依赖继续到第 40 层。

    较早位置即使已经不负责输出,也要继续计算,才能准备各个高层要用的历史 K/V。
    V4.1 · CED后半段主 K/V 从 H20 投影建立Causal Encoder–Decoder · 因果编码器–解码器
    第 1–20 层 · 因果编码器形成历史表示
    1234567891011121314151617181920
    H20每个位置完成第 20 层后的表示
    乘训练确定的矩阵,构建并保存后 20 层共用的主 K / V历史位置完成到第 20 层,就能建立这份主 K/V。
    第 21–40 层 · 解码器继续计算当前需要输出的位置
    2122232425262728293031323334353637383940
    后 20 层需要的历史主 K/V 已经准备好。较早历史位置可以在这里结束完整计算,当前输出位置继续向下。

    改接主 K/V 的来源,让较早历史省去后半段的完整计算。CED 让历史主 K/V 不再依赖后半段的逐层状态;CSA² 再安排多层共享这些 K/V。输入末尾仍需准备局部窗口,新生成位置仍会经过全部 40 层。

    编码器与解码器的连接细节对照具体层的 Q、主 K/V、局部 K/V 与投影公式展开收起

    把区别落实到一层里的连接:Q 从哪里来,主 K/V 又从哪里来?

    X 为第 ℓ 层的输入,H20 为编码器最后一层的输出;两者都包含各个位置的数字表示。下面选择两个实际的层作对照。前面 mHC 一节的 X 指一个 token 的四路状态(四条各 5,120 维),与这里按位置排列的层输入 H 不是同一个对象;报告也分别记作 X 与 H。

    前 20 层 · 因果编码器第 9 层:建立一份主 K/V
    本层的输入X9
    本层 Q9以及本层的局部 K/V
    主 K/V 的来源X9同样取自本层输入
    生成主 K/V每 2 个位置聚合成 1 条建立缓存 E2,供第 9–14 层使用CSA² 压缩与共享配置
    第 9 层的主注意力Q9 匹配选中的主 K 与局部 K
    按得到的权重汇总两组 V
    主 K/V 候选及聚合权重分数C9=X9W9KVZcomp,9=X9W9Z
    后 20 层 · 解码器第 25 层:读取编码器准备的主 K/V
    本层的输入X25
    本层 Q25以及本层的局部 K/V
    主 K/V 的来源H20改接编码器的输出
    共享的主 K/V每个位置对应 1 条由第 21 层建立 D1,第 21–40 层共用CSA² 压缩与共享配置
    第 25 层的主注意力Q25 匹配选中的主 K 与局部 K
    按得到的权重汇总两组 V
    共享主 K/V 在第 21 层建立时C21=H20W21KVZcomp,21=H20W21Z

    C 是主 K/V 的候选数值;Zcomp 是聚合用的权重分数,对应报告式(1)中的 Z,与前文注意力输出 Z 区分。编码器这里每 2 个位置组成一组;解码器每组只有 1 个位置。W 是训练得到的转换矩阵,E2、D1 是两份缓存的名称。这里的 C 只表示主 K/V 的候选数值,与前面 mHC 一节把模块输出分配回四路的连接系数 C 不是同一个量;报告的两个式子都写作 C,本文沿用原记法。

    两边都继续做的计算从本层输入生成 Q 和局部 K/V因果注意力:只使用自己及之前的位置各层自己的后续前馈与残差计算

    关键改动是主 K/V 投影式里的输入来源。对同一个历史位置,后 20 层使用由它的 H20 生成的共享主 K/V;各层的 Q 和局部 K/V 继续来自本层输入。较早历史因此可以省去后半段的完整计算。每个新位置仍经过全部 40 层:局部状态逐位置更新,主缓存按各自的分组规则更新;输入末尾的局部状态另需有界重放,后面将展示这部分工作。

    第 9 层被选作编码器的建缓存示例;编码器的其他建缓存层为第 3、15 层。第 25 层用已共享的 D1 重新筛选位置,随后计算自己的注意力。前两层只有局部 SWA。完整层配置压缩分组过程在后续章节展开。式子按报告 §2.2 式(1)及 §2.3.1 的缓存共享规则表示;为突出数据来源,图中省略归一化、位置编码等细节。

    V4.1 报告 §2.2§2.3.1(第 9–11 页),40 层配置见 §4.2.1(第 21–22 页)。左图是同深度的教学对照,不代表前代 DeepSeek 的实际层数。

    03 · 建立、保存、使用

    历史 K/V 可以共用,各层继续计算自己的 Q 和输出

    沿着一个已经给定的长输入观察:有 1,536 个 token,每个位置都有自己的 H₂₀。先把这些表示转换成可供后半段使用的状态。

    先建立一次,后面多层使用同一份数据。
    第 20 层的输出 H20
    位置 10.2 −0.4 …
    位置 20.7 0.1 …
    位置 1,536−0.1 0.6 …
    训练已经确定矩阵中的数值做矩阵乘法,把表示转换成主 K/VC=H20WKVC 是得到的主 K/V,Wᴷⱽ 是转换矩阵。“投影”就是前文 Q/K/V 中用过的线性转换。
    保存对象 · 后半段所有层共用位置 1 位置 2 … 位置 1,536
    K / VK / VK / VK / VK / VK / VK / VK / V
    只画部分条目;数字、向量均为教学示例。
    报告中还计算压缩权重;这里聚焦主 K/V 的来源。后半段配置的压缩率为 1,因此可以先按“每位置一条主 KV”理解。
    同一条 1,536-token 历史,分成 12 段。每个矩形 = 128 个位置。紫色小点 = 一个被选中的示意位置;绿色整段 = 保留该段的全部 128 个位置。
    主 K/V:保存可见历史,选出其中一部分
    示意选中位置 1、768、1,536,分别落在第 1、6、12 段。
    局部 K/V:保留最靠右的一整段
    位置 1,409–1,536 · 最近 128 个位置全部保留。

    紫色小点只表示少数被选中的条目,周围浅紫色矩形表示其所在区段;深绿色矩形则代表局部窗口的完整覆盖范围。

    两种 K/V 在全部 40 层中的分布

    局部窗口存在于每一层;主 K/V 的来源和共享范围随层的位置变化。

    层的位置主 K/V局部 K/V
    第 1–2 层这两层只使用局部注意力每层分别计算和保存自己的最近 128 个位置
    第 3–20 层
    因果编码器
    来自前半段自身计算,并在前半段内部按组共享
    第 21–40 层
    解码器
    共用第 21 层从 H₂₀ 投影建立的同一份主 K/V

    在使用主 K/V 的层,选中的主 K/V 与该层的局部 K/V 拼接后,进入同一次主注意力计算

    观察哪一层使用这份主 K/V?

    这里 Q 的上标是层号;查询始终对应同一个位置 1,536。切换层号,观察哪些对象改变、哪些保持相同。

    现在观察第 21 层 · 位置 1,536本层输入 × WQ → Q⁽²¹⁾
    历史主 K/V本层从 H₂₀ 建立
    要读取的位置本层进行筛选
    ① 从共享历史中取得选中的条目同一份主 K / V

    下面的编号由本层筛选。 本例解码器缓存每个位置保留一条,因此条目编号对应原位置。

    条目#1K / V条目#768K / V条目#1,536K / V
    ② 加入本层自己的局部数据第 21 层的局部 K / V

    位置 1,409–1,536,共 128 个位置。

    1,4091,536
    两组 K/V 合在一起
    Q⁽²¹⁾ 匹配 K,得到权重;按权重汇总 V执行一次主注意力,得到第 21 层新的输出表示。

    第 21 层建立主 K/V,并筛选本层要用的位置。 三种职责在下一章对应 Full、Reindex、Reuse。编号为教学设定。

    “共用”指 多层指向同一份已保存的 K/V;“读取”指 本层 Q 与选中的 K 匹配,再按权重汇总 V。两者分别回答“数据放在哪里”和“这一层怎样利用数据”。

    V4.1 报告图 4、§2.3.1(第 10–11 页)、§4.2.1(第 21–22 页)。选中位置是教学设定,不是真实模型的注意力结果;下一章解释哪些层重新选择、哪些层沿用选择。

    04 · 为什么能少算

    历史很长,生成刚刚开始

    假设用户刚提交一段 1,536 token 的资料,缓存尚未命中。旧输入已经全部给定;模型先准备这些位置的状态,再预测第 1,537 个 token。

    怎样读这张图:矩形每格是 128 个输入 token 经过一层,右侧一个小点是 1 个新增 token,虚线框始终框住 128 个位置。蓝色是已完成的原始输入,淡金色是本阶段已生成的 token,深金色是当前 token。下面的累计值按 token·层 计:一个 token 经过一层记 1,用来比较两条路径各自处理了多少个位置。

    位置 1,537 · 0 / 40 层

    输入阶段:准备 1,536 个位置的历史状态,再预测回答的第一个 token。

    教学续写“小猫正在窗边安静地睡觉”,共 6 个演示 token。词块与选择结果为教学设定。

    待处理淡金点:本阶段已生成蓝格:已完成输入灰格:省去完整计算深金点:当前 token
    普通逐层路径同为 40 层的教学对照
    最初输入 · 1,53612 列,每列 128 个新增位置每点 1 个 token
    第 1 层第 20 层第 21 层第 40 层
    输入 1–1,536
    回答尚未开始
    当前尾段 · 1,409–1,536
    输入准备 · 已完成61,440
    生成阶段 · 累计0
    累计 token·层61,440

    输入目标:1,536 × 40;新位置:尚未加入

    V4.1 · CED后半段主 K/V 从 H20 投影建立
    最初输入 · 1,53612 列,每列 128 个新增位置每点 1 个 token
    第 1 层第 20 层第 21 层第 40 层
    输入 1–1,536
    回答尚未开始
    当前尾段 · 1,409–1,536
    输入准备 · 已完成33,280
    生成阶段 · 累计0
    累计 token·层33,280

    输入目标:1,536 × 20 + 128 × 20;新位置:尚未加入

    CED 省去较早 1,408 个位置在后 20 层的完整计算。

    普通路径为 61,440 token·层,CED 为 33,280 token·层,减少 28,160 token·层。CED 仍处理输入末尾 128 个位置,近似准备后半段局部 K/V。点第二步,观察新 token 怎样接着计算。

    这张图的画法与计数口径

    阶段①把 1,536 个位置按 12 列等宽排列;阶段②先把末尾 128 个位置放大到绘图区的三分之一,较早的历史压缩显示,新增点及其位移再放大一次,便于逐个观察——实际范围以图中编号为准。token·层只计完整层处理的位置数,K/V 投影和稀疏选择另有计算开销;尾段移出窗口后,先前完成的计算仍留在累计值里。

    本代减少的主要是长输入的准备工作。较早历史的主 K/V 由第 21 层从 H₂₀ 一次投影得到;后半段局部状态通过末尾窗口的有界重放近似恢复。重放范围外的更早局部依赖被截断,因此恢复的 K/V 可能与完整计算不同;已有全局 KV 继续使用。

    CED 分工与计算口径的依据

    本节的 1,536-token 算例按报告的 N·L/2 + 128·L/2 计算路径绘制;报告把这种只重放末尾窗口的做法称作 Decoder SWA Bounded Replay。

    报告中总层数 L=40,局部窗口 W=128;长输入成本近似从 N×L 变为 N×L/2 + W×L/2。这个计数用于比较完整层处理的位置数量;投影、通信和硬件执行还会产生额外开销。

    Decoder Full 层的全局 KV 取自编码器末层表示;Reindex / Reuse 的共享规则由 CSA² 决定。局部 SWA KV 仍基于各层自己的隐藏状态。

    有界重放截断更早局部依赖,因此不是严格等价状态。报告称实验质量影响很小,同时承认未测试边界可能退化。

    报告 §2.2 · 第 9 页报告 §3.2.2 · 第 20 页
    阶段 4 / 4

    不同层怎样共享缓存与筛选结果

    Compressed Sparse Attention 2(第二代压缩稀疏注意力,CSA²)规定哪些层建立主 K / V 和索引结果,哪些层重新筛选,哪些层直接复用。

    CSA² 怎样减少跨层重复?

    一层保存的数据可以供其他层使用。选择哪些历史位置、给它们多少注意力权重,则是另外的工作。

    V4.1 的本代设计

    一份缓存,可以被不同层以不同方式使用

    CSA² 是第二代压缩稀疏注意力(Compressed Sparse Attention 2)。它管理两种对象:保存下来的数据,以及这一次选中哪些数据。

    保存的数据每个条目里有 K 和 V;#1–#8 是这份缓存中的条目编号。
    #1KV缓存条目#2KV缓存条目#3KV缓存条目#4KV缓存条目#5KV缓存条目#6KV缓存条目#7KV缓存条目#8KV缓存条目
    本次选中的条目编号

    例如条目 #1、#4、#7。

    #1#4#7
    原序列用“位置 1”,缓存条目用“#1”,缓存副本用 E1 / D1,Engram 查表用“地址”。条目编号在各自缓存内有效;主 K/V 数值保存在原处。这里用 8 个条目、选择 3 个缩小示意;实际条目可来自压缩后的历史位置。

    索引器查询与索引器 K每个主 K/V 条目还对应一组筛选用的键,叫索引器 K。本层的索引器查询与它们匹配,先选出要读的条目。

    主查询 Q用于真正的注意力:与选中的 K 匹配,得到汇总 V 的权重。

    索引器怎样筛选历史条目?从主 K/V 转换筛选用的键,再按编号取回信息展开收起
    先筛选条目,再用主注意力汇总信息。索引器是负责筛选的轻量组件。它使用自己的一套 Q、K,回答“这次应取哪些历史条目?”

    1筛选用的向量从哪里来?

    当前要计算的位置该位置的状态
    乘查询转换矩阵
    索引器 Q
    历史中每一个主 K/V 条目主 K/V:#1 #2 #3 #4
    各条目分别乘键转换矩阵
    索引器 K:#1 #2 #3 #4

    转换矩阵的数值由训练确定。原主 K/V 仍然保留,额外生成的索引器 K 用于筛选。

    2按分数,选出条目编号

    索引器 Q 与各条目的索引器 K 匹配,得到筛选分数。

    条目筛选分数本次选择
    #10.9选中
    #20.2
    #30.4
    #40.8选中
    选取最高的 2 个 · Top-2条目编号 #1、#4

    Top-K 中的 K 是“选几个”的数量;与向量名称 K 含义不同。此处只取 2 个作示意,报告配置为 Top-512。

    3取回原数据,计算输出

    当前状态另行转换主注意力 Q
    按编号取回原主 K/V:#1、#4
    本层最近窗口局部 K/V
    主 Q 与这些 K 匹配得到注意力权重,按权重汇总 V
    本层新的输出表示

    筛选分数决定选谁;主注意力重新计算权重,决定怎样汇总。两种分数承担不同职责。

    主 K/V 怎样转换成索引器 K?

    索引器 K = 主 K/V 条目 × 键转换矩阵。用 3 个数表示一条主 K/V;把它乘一个 3 × 2 的矩阵,得到含 2 个数的索引器 K。

    原主 K/V 条目 #1 的向量 c1[1,2,0]
    键转换矩阵 W索引 K[100111]
    额外生成的索引器 K[1,2]

    #1、#2、#3、#4 应用同一个矩阵,可批量转换;每个索引器 K 都能对应回原来的主 K/V 条目。筛选得到编号后,主注意力按这些编号取回原数据。

    分数、维数、矩阵均为教学设定,用于说明数据来源;矩阵算例与上方筛选分数相互独立。报告将主 K/V 与对应的索引器 K 合称为全局缓存;跨层共享规则在下一章展开。依据:V4.1 报告 §2.3§2.3.1(第 10–11 页)。

    同一组历史,三种层职责有什么区别?

    按分数选出最高的 K 个条目,称为 Top-K;名字里的 K 表示数量。本例选择 3 个条目,报告的配置选择 512 个。

    三个对照按同一顺序阅读:“缓存 → 选位置 → 主注意力”。观察数据是否新增、索引是否重算、注意力是否继续。

    01

    Full建立缓存,并选出位置

    保存新数据

    ① 缓存

    建立并保存
    #1KV#2KV#3KV#4KV#5KV#6KV#7KV#8KV

    缓存 S · 主 KV + 索引器 K

    ② 用索引器选择位置

    本层重新计算
    9#1
    3#2
    2#3
    8#4
    4#5
    1#6
    7#7
    5#8

    柱高:索引分数 · 0–10 示意轴
    选择分数最高的 3 项

    #1#4#7

    ③ 本层继续做注意力

    新的主查询 Q
    #133%
    #422%
    #715%
    局部30%

    条长表示权重 · 0–100%
    主 KV 与局部 KV 的权重合计 100%。

    建立主 KV 与索引器 K,供本层以及后面的层共用,直到下一个 Full 层为止;本层索引器给各条目打分,选出 #1、#4、#7。

    02

    Reindex共用缓存,重新选择位置

    改变选择

    ① 缓存

    沿用 Full 的同一份
    S
    引用上面的缓存 S数据仍放在原处
    这里不另存一套

    共用 Full 层建立的主 KV + 索引器 K

    ② 用索引器选择位置

    本层重新计算
    3#1
    9#2
    2#3
    8#4
    4#5
    1#6
    5#7
    7#8

    柱高:索引分数 · 0–10 示意轴
    选择分数最高的 3 项

    #2#4#8

    ③ 本层继续做注意力

    新的主查询 Q
    #216%
    #436%
    #818%
    局部30%

    条长表示权重 · 0–100%
    主 KV 与局部 KV 的权重合计 100%。

    主 KV 和索引器 K 保持原样;本层产生新的索引器查询,重新打分后改选 #2、#4、#8。

    03

    Reuse共用缓存,也沿用选中位置

    接续选择

    ① 缓存

    沿用 Full 的同一份
    S
    引用上面的缓存 S数据仍放在原处
    这里不另存一套

    共用 Full 层建立的主 KV + 索引器 K

    ② 用索引器选择位置

    省去本层索引器计算

    从上面的 Reindex 层
    直接接续 #2、#4、#8

    这里没有再次打分

    #2#4#8

    ③ 本层继续做注意力

    新的主查询 Q
    #232%
    #414%
    #824%
    局部30%

    条长表示权重 · 0–100%
    主 KV 与局部 KV 的权重合计 100%。

    保留 #2、#4、#8,省去索引器查询、打分和 Top-K 选择;本层主查询仍会产生新的注意力权重与输出。

    Reindex 改的是选中位置;Reuse 省的是再次选择。

    两者都可以使用同一份 KV。即使 Reuse 沿用 #2、#4、#8,本层的主查询不同,注意力权重仍可改变。各层自己的局部 SWA KV、注意力与后续计算也继续执行。

    条目、索引分数与注意力权重为教学示例。右栏“局部”一行合计多个局部条目的权重;真实模型把选中的主 KV 与局部 SWA KV 拼接,统一计算注意力。索引分数决定“选谁”,注意力权重决定“选中后怎样汇总”。Full 表示这一层承担完整组件职责,它仍然使用稀疏注意力。报告 §2.3.1、图 4。

    深入:把三种职责放回真实的 40 层配置
    报告中的实际配置

    把三种职责放回真实的 40 层

    编码器有三份共享全局缓存;解码器五个索引组共同读取 D1。每层自己的局部 KV 均保留。

    Full 建立缓存并筛选Reindex 共用缓存、重新筛选Reuse 沿用缓存与筛选结果

    层按箭头串联:每行从左向右,再接下一行;每个完整层各执行一次注意力与 MoE 更新。

    主干分段层号 · 职责全局缓存 / 条目聚合沿用哪次选择
    起始第 1–2 层
    1 SWA2 SWA
    仅局部 SWA
    各自的局部窗口
    编码器第 3–8 层
    3 Full4 Reuse5 Reuse6 Reuse7 Reuse8 Reuse
    E12 个位置 → 1 条
    I3第 3 层选出
    编码器第 9–14 层
    9 Full10 Reuse11 Reuse12 Reuse13 Reuse14 Reuse
    E22 个位置 → 1 条
    I9第 9 层选出
    编码器第 15–20 层
    15 Full16 Reuse17 Reuse18 Reuse19 Reuse20 Reuse
    E32 个位置 → 1 条
    I15第 15 层选出
    解码器第 21–24 层
    21 Full22 Reuse23 Reuse24 Reuse
    D11 个位置 → 1 条
    I21第 21 层选出
    解码器第 25–28 层
    25 Reindex26 Reuse27 Reuse28 Reuse
    D11 个位置 → 1 条
    I25第 25 层选出
    解码器第 29–32 层
    29 Reindex30 Reuse31 Reuse32 Reuse
    D11 个位置 → 1 条
    I29第 29 层选出
    解码器第 33–36 层
    33 Reindex34 Reuse35 Reuse36 Reuse
    D11 个位置 → 1 条
    I33第 33 层选出
    解码器第 37–40 层
    37 Reindex38 Reuse39 Reuse40 Reuse
    D11 个位置 → 1 条
    I37第 37 层选出
    E1–E3、D1 是四份全局缓存,各含主 KV 与对应的索引器 K;E1、E2、E3 分别由第 3、9、15 层建立,D1 由第 21 层从 H20 建立。I + 层号 表示该层这一次选出的条目编号,后续层沿用到下一次 Full / Reindex。第 j 层的局部缓存为 Lⱼ,共 L1–L40 四十份,窗口上限 128;所有层继续计算自己的主查询和注意力输出。报告 §2.3.1§4.2

    筛完之后,一个查询实际要读多少条?

    把这一章的配置合起来:在使用主 KV 的层上,一次主注意力读选中的 512 条主 KV,再加上局部窗口的 128 个位置。历史再长,这两个数字都不变。放到常见做法之间,位置是这样的。

    1. 稠密注意力最直接的做法

      N

      每个查询与全部可见位置逐一匹配,历史有多长就读多长。

      读取量随历史线性增长

    2. V4.1 · 稀疏注意力本章讲的做法

      512 + 128

      仍是同一种 softmax 注意力,只是每次少读一些:主 KV 只取选中的 512 条,局部窗口另算 128 个位置。

      N 超过 512 之后不再增长

    3. 线性注意力另一类改写

      1份状态

      不再逐条保留历史 K/V,而是把历史压进一个大小固定的状态,注意力的算式也随之改写。

      与历史长度无关

    V4.1 落在中间一档,不是线性注意力:它按位置或位置组保留主 K/V 条目(编码器每两个位置合成一条,解码器每个位置一条),读到的是真实的历史条目,缓存规模仍随历史长度增长,只是每次少读一些——所以缓存可以长期保存、可以命中、可以重放。代价也在这里:挑出那 512 条本身要花时间。Full 层仍要给全部可见位置打分,这笔计算同样随历史增长,下一节就在算这笔账。

    V4.1 的本代设计

    还要重新选择时,搜索范围也能缩小

    长历史里,给所有位置反复打分也很费计算。解码器的首个 Full 层先看完整的可见范围,圈出候选区域,后续 Reindex 层在这些区域内重新选择。

    1

    首个 Full 层:扫描完整可见历史

    先看一个可数清的小例子64 个位置 → 8 个块 → 选择 2 块

    每个小方格代表 1 个位置,8 格组成一个块。每块用其中最高的索引分数参与比较;这个例子选择分数最高的两个块。

    位置 1–8
    块分数 1留在池外
    位置 9–16
    块分数 4留在池外
    位置 17–24
    块分数 9✓ 进入候选池
    位置 25–32
    块分数 3留在池外
    位置 33–40
    块分数 5留在池外
    位置 41–48
    块分数 8✓ 进入候选池
    位置 49–56
    块分数 2留在池外
    位置 57–64
    块分数 6留在池外
    候选池:位置 17–24 和 41–482 个块 × 8 个位置 = 16 个候选位置

    这里的长度、分数和选取数量均为教学设定。下面回到报告的实际上限。

    同时得到本层的 Top-512,以及供后续层使用的候选池。

    2

    候选池:最多 16,384 个位置

    2,048 个块×每块 8 个位置=16,384

    块按其最高索引分数选择。候选池是后续索引器的搜索范围。

    3

    后续 Reindex 层:在池内选自己的 Top-512

    共同候选池各层重新打分各自的 512 个位置

    这些位置对应本层实际使用的主 KV;不同层的最终选择可以不同。

    16,384 是搜索范围上限,512 是最终选择的数量;教学小例子的每块 8 格与每块 8 个位置一一对应。分层索引仅用于 CED 的解码器,首个 Full 层仍需完整扫描。报告 §2.3.2、图 5、§4.2
    展开算一算:历史变长后,要给多少个位置打分?

    跟随一个新位置的查询,统计解码器中 1 个 Full + 4 个 Reindex 的位置评分次数。N 是该查询因果可见的主 K/V 条目数;解码器压缩比为 1,每条对应一个位置。每次索引仍选出自己的 Top-512,其余 Reuse 层沿用最近的选择。

    可见主 K/V 条目数 N
    16,384 个位置

    相对评分工作量 · 各档参考路径 = 100%

    1 次 Full 评分4 次 Reindex 评分之和
    5 层各自搜索全部可见位置81,920位置·次
    16,384 + 4 × 16,384100%
    Full 搜全局,Reindex 搜候选池81,920位置·次
    16,384 + 4 × 16,384100%
    两条横条共用本档的比例尺;长度表示位置评分次数,满长为本档参考路径的 5N。1K = 1,024,1M = 1,048,576。

    16,384 个可见位置全部放入候选池,两种路径都需 81,920 位置·次。切到更长范围,观察候选池占比。

    可见主 K/V 条目数为 N,候选池最多容纳 16,384 个位置:分层索引计数为 N + 4 × min(N, 16,384)。Full 的扫描量随历史增长,四次 Reindex 的搜索范围受候选池上限约束。

    以上按报告 §2.3.2§4.2.1 的配置推算,衡量索引器的搜索工作;整模型耗时还取决于注意力、专家计算与数据搬运等环节。机制后接数量对照的讲解方式参考 SuperAlign · CSA² 跨层复用

    实现补充:DeepSelect 加速 Top-K 选择

    索引器先计算分数,DeepSelect 再从这些分数中高效返回选中的位置编号。它是 GPU 选择算子,并不承担 Q/K/V 投影、CED 分工或缓存管理。

    官方 DeepSelect 仓库 ↗ 查看 topk 接口 ↗

    报告 §3.2 对选择算子的实现引用了 DeepSelect;仓库里的单算子性能数字,不能直接当成完整模型的加速倍率。

    CSA² 共享、筛选与复用的依据

    所有模式都计算本层主 Q、局部 SWA KV 和注意力输出。Reindex 使用自己的索引器查询重新选择,Reuse 不再运行索引器。

    编码器前两层仅 SWA;其余 18 层压缩率 2,三组各 Full+5 Reuse。解码器压缩率 1,第一组 Full+3 Reuse,后四组各 Reindex+3 Reuse。

    DeepSelect 在哪一步?

    报告 §3.2(第 18 页)直接引用 DeepSelect 的 TopK 内核。它接收已算好的分数,加速挑选 Top-K 的底层算子,也支持输出采样。官方所述 2–20 倍针对该算子与 torch.topk 的对照;整模型速度还取决于其余计算。

    官方 DeepSelect README ↗

    报告 §2.3 · 第 10 页

    Engram 在第 2、15 层,为当前表示补充记忆

    40 层主干负责逐层计算;其中两个 Engram 模块都接在前 20 层因果编码器中。它们根据当前 token 及其前面的短片段,查找训练得到的向量,再结合当前上下文融入表示。

    在整条计算路径中的位置

    主线跟随“睡觉”这个位置的四路隐藏状态;右侧两个模块分别使用以该位置结尾的 2 / 3 / 4-token 片段查表。它们有各自的记忆参数。

    文字 embedding → 复制为四路 → 第 1 层
    来自第 1 层的四路状态注入点 1:第 2 层之前每路接收经过门控的记忆增量
    Engram 模块 1 · 约 98B短片段 → 24 次查表 → 投影、门控
    第 2–14 层 · 持续更新四路状态
    来自第 14 层的四路状态注入点 2:第 15 层之前再次融入这套模块提供的记忆
    Engram 模块 2 · 约 98B同一组片段 → 本模块自己的表与投影
    第 15–20 层 → 后 20 层解码器 → 输出头

    一个 Engram 模块:同时查三种长度

    下游每路隐藏状态含 5,120 个数(5,120 维)。查回的记忆先投影到匹配维度,再用门控融入四路。

    2、3、4 三种长度同时使用,每种长度各有 8 个哈希头。模型共查 24 次;悬停或点击任意头,高亮它使用的片段,并查看地址与向量。

    小猫趴在窗边睡觉
    2 个 token窗边 · 睡觉
    3 个 token趴在 · 窗边 · 睡觉
    4 个 token小猫 · 趴在 · 窗边 · 睡觉
    2 个 token · 第 1 个哈希头
    1. ① 片段的离散编号窗边 · 睡觉 → [17, 29]编号为教学设定。
    2. ② 该头将编号映射为表内地址示例 Hash₂,₁([17, 29]) → 地址 4同头、同片段得到同一地址;哈希可能碰撞。
    3. ③ 读取该头对应的表项T₂,₁[4] = [0.0, 0.0, …] · 共 256 个分量各头查自己的表区,向量由训练学习。

    这里用小整数哈希与示例表项展示映射关系。实际哈希与表大小见官方实现;每头 256 维、每种长度 8 头是模型配置。

    先定位到两个注入点,再展开一个模块的查表过程。片段与地址是教学示例;2、3、4 三种长度、每种 8 头和每头 256 维来自官方配置。

    把 24 次查表的结果接回四路隐藏状态

    2-token 片段8 × 256 = 2,048
    3-token 片段8 × 256 = 2,048
    4-token 片段8 × 256 = 2,048
    拼接三组结果:3 × 2,048 = 6,144 维拼接保留各个分量,组成一条更长的记忆向量。
    可训练线性投影 WE6,144 维 → 25,600 维 = 4 × 5,120 + 5,120,再拆成下面两部分
    4 个匹配键每路一个 ki,各 5,120 维与该路当前隐藏向量匹配,计算一个 0–1 的门控系数,表示本次加入多少记忆。
    1 个共享记忆值 v5,120 维,供四路共用四路使用同一条记忆向量,各自的门控系数控制加入比例。
    逐路更新:原隐藏向量 + 门控缩放后的记忆向量例如门控为 0.3,就把记忆向量的每个分量乘 0.3,再与该路原向量逐项相加;结果仍为 5,120 维。

    所以,查回的 6,144 维向量先经投影,得到维度匹配的键和值;四路各自调节同一份记忆值的贡献。这里的键用于 Engram 门控匹配,注意力层的 K 在后续注意力计算中另行产生。

    配置:每头 256 维、8 头、主干 5,120 维、四路;连接:Engram.forward 的投影、门控与相加

    为什么主 K / V 与 Indexer K 要分开看?

    主 K / V 保存注意力真正读取的内容;Indexer K 只参与历史位置的筛选。它们可以来自同一边界状态,同时由不同投影产生并承担不同职责。

    继续下一单元
    05预填充 / 解码 → 恢复 → 缓存细节

    学习单元 5 / 8

    生成时怎样管理历史

    如何读入、追加、保存与恢复?

    Prefill(预填充)处理已经给定的输入,Decode(解码)逐步追加新位置。这一单元走完一次历史复用与恢复,再用容量、位宽和存储位置解释不同状态为什么采用不同寿命。

    整段读入,和逐步生成有什么不同?

    提示词中的所有位置已经给定;回答中的新位置则依赖前一轮选出的结果。两种阶段的工作范围因此不同。

    已知的一段输入,可以按层一起处理

    同一层的三个位置都从这一层的输入读取信息,因此可以组成矩阵一起计算。等这一层完成,三个位置的输出一起成为下一层的输入。

    首次读入 · Prefill
    横向:同一层的 3 个位置纵向:从第 1 层依次到第 3 层
    已知输入位置 1小猫位置 2正在位置 3睡觉
    能参考的位置×未来位置,因果遮罩挡住每个编号对应上方同一列的词。
    第 1 层读嵌入表示
    更新位置 1注意力可参考
    123
    更新位置 2注意力可参考
    123
    更新位置 3注意力可参考
    123
    第 2 层读第 1 层输出
    更新位置 1注意力可参考
    123
    更新位置 2注意力可参考
    123
    更新位置 3注意力可参考
    123
    第 3 层读第 2 层输出
    更新位置 1注意力可参考
    123
    更新位置 2注意力可参考
    123
    更新位置 3注意力可参考
    123
    读图示例

    第 2 层更新“正在”(位置 2)时,参考的是第 1 层产生的位置 1、2 的表示。相同的因果边界在每一层都成立。

    每个编号块代表一个输入位置,✓ / × 表示可见性,不表示注意力权重或计算耗时。这里展示 3 层通用教学模型;V4.1 的实际 40 层结构在CED 的 40 层分工中展示。

    逐步生成时,下一项要等上一轮选定

    例如“睡觉”被选出后,它才成为新的已知位置。计算这个位置的表示,才能得到后面句号、逗号等候选。

    1. 01
      首次读入已知“小猫 · 正在” → 计算 → 选出“睡觉”

      处理多个已知位置,建立它们的 K/V 缓存。

    2. 02
      继续生成 · Decode新位置“睡觉” → 计算 → 选出“。”

      复用历史 K/V,只为刚确定的新位置追加状态。

    3. 03
      后续轮次用户或工具带来新内容 → 再次读入

      命中的前缀可沿用缓存;新增内容需要计算。

    “读入少做一些计算”和“生成时一次接受多个 token”作用于不同环节。后文分别由 CED 与 DSpark 展开。
    Prefill、Decode 与缓存命中的依据

    图中的步骤展示数据依赖:哪些结果要先准备好,后面的计算才能继续。实际实现会把部分操作融合、批处理或重叠执行。

    因果遮罩使输入位置不能利用未来位置,但已知输入仍可按层并行处理。所需的历史缓存完整命中时,主要计算新增后缀。若全局缓存命中而局部状态已过期,V4.1 还会重放有限长度的历史末尾;缓存恢复路径解释这种情况。

    报告 §2.2 · 第 9 页
    紧接逐步生成

    全局历史仍在,近期窗口状态却可能缺失

    主 K / V 保存较长历史;各层的 Sliding-Window Attention(滑动窗口注意力,SWA) K/V 只服务近期窗口。沿下面的具体算例走六步:旧的 1,024-token 前缀就绪,工具返回后发现局部状态已过期,重放前缀末尾 128 个位置,得到近似恢复的局部状态,再接入 33 个新位置并完成编码器更新。旧前缀的全局 KV 始终复用,局部窗口最后从 897–1024 移到 930–1057。

    本代:SWA 有界重放

    工具终于返回了;局部状态已经过期,怎样接着算?

    沿用这个具体例子:前一轮已有 1,024 个 token,工具又返回 33 个 token。旧输入叫“缓存前缀”,新结果叫“新增后缀”。这些长度是教学设定。

    旧前缀已经处理,等待工具返回

    全局 KV 已保存;局部窗口仍可用,覆盖 897–1024。

    编码器恢复 · 1 / 6
    全局 KV 另保留较早的 1–896末尾 161 个位置 ↓
    输入位置
    897–92933 个930–102495 个1025–105733 个
    已知输入等待工具结果
    全局 KV覆盖位置 1–1024
    局部 SWA各层独立
    897–1024 · 可用括号圈出局部窗口:128 个位置
    编码器本步计算等待工具返回
    重放0新增0累计0
    之后仍需准备解码器末尾 930–1057 的输出仍需经过后 20 层,才能开始生成。
    1. 1旧前缀就绪
    2. 2等待结束
    3. 3重放尾窗
    4. 4局部已恢复
    5. 5接入新结果
    6. 6编码器就绪

    图中全局范围概括各份主 KV 对应的输入位置,条形长度不表示条目数。新增 33 个位置在每份 2:1 编码器主缓存中形成 16 条完整条目;末尾 1057 尚未成组,在该路径中仍由局部 SWA 提供。1:1 解码器主缓存则追加 33 条。部署时可把重放与新增输入合在一次预填充中,编码器共处理 128 + 33 = 161 个位置。报告 §2.3§3.2.2

    编码器就绪后,准备解码器,再开始生成

    本节:恢复编码器局部状态

    条件是旧前缀的局部缓存缺失。重放旧前缀末尾 128 个位置:本例为 897–1024

    CED:准备解码器局部状态

    读入结束时,把整个新输入末尾 128 个位置的编码器输出交给解码器:本例为 930–1057,为开始生成作准备。

    第二个窗口是每次读入结束后仍要完成的工作:位置 930–1057 的编码器输出通过后 20 层,近似建立解码器局部 KV,随后才开始生成。上方的 161 个位置只统计编码器处理的位置数。解码器局部状态用于本次生成,不进入前缀缓存。报告 §3.2.2

    为什么可以少存?因为丢失的短期状态有便宜的恢复办法。

    长期保留全局历史,把编码器局部状态留在短期池;局部状态偶尔失效时,再处理有限的尾部窗口。这才使“减少持久存储”成为可用的部署策略。

    缓存怎样变小,又怎样恢复?

    容量取决于保存多少数据,恢复成本决定哪些状态可以暂时丢弃。下面从同一份历史数据看两者的关系。

    缓存占多少空间,取决于“存几份、存几项、每项多大”

    上一章解释了为什么多层可以共用数据。把这件事放回缓存容量,就能看到共享、压缩和数值格式分别改变什么。

    本代:更多跨层共享

    ① 减少独立副本

    实际保存:3 份编码器全局 KV + 1 份解码器全局 KV每个盒子是一份独立的逻辑缓存
    E1主 KV + 索引器 K第 3–8 层共用2 个位置 → 1 条主 KV
    E2主 KV + 索引器 K第 9–14 层共用2 个位置 → 1 条主 KV
    E3主 KV + 索引器 K第 15–20 层共用2 个位置 → 1 条主 KV
    D1主 KV + 索引器 K第 21–40 层共用每个位置 → 1 条主 KV
    另有 40 份各层自己的局部 SWA 状态每份只覆盖近期窗口 · 窗口上限 128
    L1L2L3L4L5L6L7L8L9L10L11L12L13L14L15L16L17L18L19L20L21L22L23L24L25L26L27L28L29L30L31L32L33L34L35L36L37L38L39L40

    全局缓存跨层共享,40 份局部 SWA 状态各层独立。每个盒子代表一份逻辑缓存。不论压缩比是多少,这里的每一条主 KV 都是前面那种向量:512 维,64 个查询头共用一条。

    沿用压缩思路;调整配置

    ② 减少历史条目数

    沿序列看所有已完成的相邻组都按同一规则处理

    位置 1、2 组成第 1 条,3、4 组成第 2 条,持续到 1,535、1,536 组成第 768 条。

    沿网络看2∶1 用在三份编码器主缓存 E1、E2、E3

    解码器 D1 为 1∶1。每层的输入状态与 Q 仍逐位置计算,局部 SWA 也逐位置保留近期信息。

    因此,“压缩”的对象是供主注意力使用的历史 KV 条目。一条聚合记录承载相邻两个位置的数值特征;原输入的文字和位置继续保留。

    位置 1位置 2
    主 KV 第 1 条
    位置 3位置 4
    主 KV 第 2 条
    位置 1535位置 1536
    主 KV 第 768 条

    1,536 个位置 → 768 条主 KV每份编码器主缓存分别得到这一数量。

    只增加一个位置时,末尾会怎样?

    放大同一条序列的末尾;每个方格代表 1 个位置。

    更早的 767 个完整组保留 · 位置 1–1,534

    位置1,535位置1,536
    第 768 条两位置聚合完成
    待加入1,537待加入1,538
    下一组尚未开始等待位置 1,537 和 1,538
    768完整的主 KV 条目
    0末尾未成组的位置
    1,409–1,536局部 SWA 可覆盖的位置

    已有 1,536 个位置。每两个相邻位置组成一条,各份编码器主缓存均有 768 条完整条目。

    这里跟踪连续序列的逻辑分组。若下一次输入接在位置 1,537 后面,新的位置 1,538 与它组成一组;配对沿总位置继续。报告给出分组规则,后台未完成组的具体暂存方式属于实现细节。
    两个位置的信息,具体怎样合成一条?

    先把每个位置的状态分别乘两组训练得到的矩阵:一组产生待保存的信息数值,另一组产生各个数值的聚合分数。组内的分数经 softmax 转成权重,再加权相加。

    用只有两个数值的教学例子,观察“信息”和“权重”怎样配合:

    来自哪里第 1 个数值第 2 个数值
    位置 12占权重 75%8占权重 25%
    位置 26占权重 25%4占权重 75%
    保存为一条2 × 0.75 + 6 × 0.25= 38 × 0.25 + 4 × 0.75= 5

    加权聚合的结果为 [3, 5]。每个数值维度可使用不同权重;一条记录浓缩了两个位置的信息。这是有损聚合,FP4 还会进一步降低每个数的保存精度。

    报告用 C 表示待聚合的数值、Z 表示聚合分数。这里直接展示 softmax 后的教学权重;它们用于合成 KV,与前面“Q 和 K 匹配后汇总 V”的注意力权重分别计算。表格省略后续归一化等步骤。逐维加权的公式见 V4 报告 §2.3.1,式 11–12;V4.1 在此基础上改为互不重叠的分组,见本报告 §2.3

    压缩比例与共享范围,都属于 CSA² 的配置

    第 3 层输入的 1,536 个位置E1 · 768 条第 3–8 层共用
    第 9 层输入的 1,536 个位置E2 · 768 条第 9–14 层共用
    第 15 层输入的 1,536 个位置E3 · 768 条第 15–20 层共用

    三份主缓存分别从各自所在层的状态产生,每份各 768 条;各层仍有 1,536 个位置继续计算。CED 决定解码器主 KV 从 H20 取得数值来源,CSA² 决定这些 KV 如何压缩、共享和选择。

    第 1–2 层:纯 SWA各自保留近期最多 128 个位置的局部 KV。逐位置处理近期信息
    第 21–40 层:解码器 CSA²第 21 层从 H20 投影出 D1,其余 19 层共用这一份;压缩比 1。1,536 个位置 → 1,536 条主 KV

    因果边界:某个位置只使用已经完整落在其可见范围内的压缩组。位置 1,537 计算自己的状态时,第 769 组尚待位置 1,538 到来;它可通过局部 SWA 使用近期已有信息。依据:报告 §2.3§2.3.1§4.2.1;连续追加示意按这些规则推导。

    本代:主 KV 扩展到 FP4

    ③ 每个数用更少的位保存

    FP88 位浮点
    FP44 位浮点

    FP4 用 4 位浮点格式近似保存每个主 KV 数值,另存缩放信息。读取时把它们转换为计算所需的近似数值,这叫解量化;被舍去的精度不会因此恢复。局部 SWA KV 使用 8 位浮点格式 FP8。

    这三张图的口径、沿革与报告出处

    上面①「减少独立副本」按实际配置显示 4 份全局缓存和 40 份局部状态;②「减少历史条目数」展示相邻位置的连续分组,CSA² 的分组互不重叠。展开部分用两个数值的教学例子说明逐维加权聚合,省略输出归一化等步骤。编码器压缩比为 2,解码器为 1。压缩与稀疏选择在 V4 已有,V4.1 的新重点是跨层共享及主 KV 的 FP4。报告 §2.3§2.4.4§4.2

    上述设计共同作用 · 相同序列长度

    全局 KV:约为 V4-Flash 的 1/4

    V4-Flash100%
    V4.1-Flash约 25%
    890 B / token

    报告给出的全局 KV 占用
    1,000,000 token 约为 0.89 GB

    这是共享、压缩和量化共同作用后的全局 KV 占用,包含主 KV 与索引器 K。0.89 GB 按十进制换算;模型权重、局部 KV 和运行工作区另计。依据:报告摘要、§1§5
    本代:调整保存策略

    一段对话暂时停下,哪些状态值得长期保留?

    例如模型读完一份文档,正在等待工具返回结果。完整历史可能在之后再次使用;局部窗口状态主要服务当前会话的近期计算,两者适合不同的保存期限。

    全局 KV · 供长历史再次使用

    进入 SSD / 主机内存中的持久缓存。报告部署保留至少 72 小时。

    以后命中这段历史,可以复用已有结果。

    编码器局部 SWA KV · 服务近期窗口

    留在主机 DRAM 的短期池,按分钟级期限回收。

    过期后,用一小段已有输入近似重建。

    SSD、主机内存、GPU 显存,各保存什么?

    前面按用途区分“全局 KV”和“局部 SWA KV”;这里按硬件位置区分。同一份全局 KV,可以有供以后复用的持久副本,以及供当前计算读取的显存工作副本。

    存储位置保存的 KV使用时机
    SSD / 主机内存
    持久缓存
    全局 KV:主 K/V 与索引器 K保留长历史,供后续请求命中前缀后加载复用。报告部署中的全局 KV 保留至少 72 小时。
    主机 DRAM
    短期分布式内存池
    编码器各层的局部 SWA KV服务活跃会话。报告用每台机器约 10% 的主机 DRAM 组成池,按分钟级存活时长(TTL)回收;缺失时重放前缀末尾 128 个位置。
    GPU 显存(HBM)
    当前计算的工作集
    当前请求使用的全局 KV 与局部 SWA KV注意力计算直接读取。解码器局部 SWA KV 在每次预填充末尾准备,随后用于生成。

    解码器局部 SWA KV 只服务本次生成;跨请求的前缀缓存保留全局 KV,编码器局部状态由短期池补充。这里的“内存”指主机 DRAM,“显存”指 GPU HBM。依据:报告 §1§3.2.1(存储策略)§3.2.2(恢复与解码)

    持久缓存里,省去长期保留的局部状态

    条长表示持久缓存占用量 · 前代总量 = 100%

    V4-Flash全局 KV局部 SWA KV
    V4.1-Flash仅全局 · 约 1/8
    报告的同负载比较中,原持久缓存的局部状态接近一半;移除这部分,再将保留的全局 KV 缩至约 1/4,合计约为原持久缓存的 1/8。条形按这一近似关系绘制。此处的“持久缓存”与上面的“全局 KV”是两个统计口径。报告 §3.2.1

    低价缓存命中:重复输入只按 1/50 的单价计费

    长文档、多轮对话和 Agent 往往反复携带相同前缀。DeepSeek 默认构建硬盘缓存:后续请求完整匹配已落盘的前缀单元时,这部分输入按缓存命中价格收费,其余输入按未命中价格收费。

    deepseek-flash(V4.1-Flash)· 元 / 百万输入 token · 2026-09-11 核对
    时段缓存命中缓存未命中命中部分节省
    空闲0.02 元1 元98%
    高峰0.04 元2 元98%
    例如:一次输入 100 万 token,其中 90 万命中

    空闲时段输入费 = 0.9 × 0.02 + 0.1 × 1 = 0.118 元。同样输入全部未命中为 1 元,本例节省 88.2%。新生成的输出另行计费。

    低成本的技术基础:SSD 承担大容量持久保存;CSA² 与 FP4 减少需保存和搬运的全局 KV;短期内存池与有界重放减少长期保留局部状态的开销。命中前缀后,服务复用已有计算结果,再处理新增内容。具体的 1/50 单价比例来自 API 定价。

    报告的“至少 72 小时”描述其部署配置。面向用户的 API 缓存按尽力而为提供,命中量以返回的 prompt_cache_hit_tokens 为准;缓存构建需要时间,保留时间通常为数小时到数天。价格与时段以官方价格页为准;匹配规则见上下文硬盘缓存文档

    只重放末尾 128 个位置,和完整重算差在哪里?

    局部 SWA 缓存丢失后,模型重新计算各层的局部 K/V。精确重建要补齐原来的跨层局部依赖;有界重放只重算末尾窗口,并把局部注意力限制在这段范围内。两者都运行网络中的真实运算,区别在于重算时可用的局部信息。

    精确重建补齐依赖,再恢复状态

    一个位置会参考左边的状态;这些状态在更低层又参考更早的位置。层数越多,所需重放范围越长。

    有界重放 · 近似重建重算尾部,缩短恢复工作

    尾部起点处少了更早的局部信息,差异可以逐层传递。因此,恢复的局部 K/V 可能与完整计算有所不同。

    已有全局 KV 仍然保留并参与注意力。这里截短的是局部 SWA 分支的重放范围。

    看一个三层例子:较早的局部信息怎样影响位置 9?

    教学模型:每层的局部窗口为 3 个位置,即当前位置及其左边两个位置。下面沿着同一个目标——第 3 层后的位置 9——查看依赖。

    精确计算输入依赖一直追溯到位置 3

    从下往上看:9 → 7–9 → 5–9 → 3–9。逐层向左补齐依赖,再向下计算。

    只重放位置 7–9局部依赖从位置 7 截断

    第 1 层的位置 7、8 先受到影响;差异沿后续层传递,到达目标位置 9。

    局部依赖齐全可能受截断影响短重放范围外

    图中画出目标位置的局部依赖;两种方式都保留全局 KV 路径。真实 V4.1 的局部窗口为 128,编码器与解码器各有 20 层。

    报告采用尾部 128 个位置的有界重放。对编码器缓存恢复来说,重放的旧前缀沿用原全局 KV;随后新增内容的全局与局部 KV,则基于恢复后的状态继续计算,也可能随恢复边界产生差异。这是计算上下文的近似;前文 FP4 讲的是数值保存精度。

    报告实验观察到的回答质量影响很小;针对解码器重放,后训练也加入相同过程以帮助模型适应。结论同时保留了未测试边界下可能退化的限制。依据:V4.1 技术报告 §2.2(第 9 页)、§3.2.2(第 20 页)与结论。

    缓存精度、存储与恢复的依据

    主 KV 使用 E2M1,每 16 通道配 E4M3 缩放因子,类似 NVFP4 但省去第二级全局缩放。RoPE 后量化;局部 SWA 仍为 FP8。索引器 Q/K 使用 MXFP4,和主 KV 不是同一格式。

    报告部署中全局持久 KV 保留至少 72 小时,编码器局部状态是分钟级短期策略。这两个时间范围描述报告中的部署配置;具体服务以自身缓存策略为准。

    报告 §2.4.4 · 第 14 页报告 §3.2 · 第 19 页
    FP8 改为 FP4 时,缓存的什么属性发生变化?

    量化改变每个分量使用多少位来保存,向量的分量数量保持不变;压缩聚合才会改变条目数量或表示组织。

    继续下一单元
    06草稿 → 验证 → 接受 → 回到生成

    学习单元 6 / 8

    一次怎样推进多个候选

    DSpark 如何提出、核验并接受多个 token?

    普通生成循环每轮选一个 token。DSpark 在这条主线旁先提出一段草稿,再由主模型核验连续前缀,并把被接受的部分送回同一个追加循环。

    草稿怎样让一次验证留下多个 token?

    主模型生成一项通常需要完整计算。先由较小模块提出多个候选,再由主模型一次核对,可能让这次计算的成本被多项输出分摊。

    V4.1 采用的新模块

    较小的模块先写一小段,主模型再一起核对

    前面的一般生成流程,每轮确定一个新 token。DSpark 希望主模型的一轮计算能留下多个 token。

    01

    提出 5 项草稿

    已确定的文字是“小猫正在”。后面的内容暂时只是候选。

    已确定的前文
    小猫正在
    候选 1等待起草
    候选 2等待起草
    候选 3等待起草
    候选 4等待起草
    候选 5等待起草
    这些候选还没有加入已确定的前文。
    02

    一次调用,验证这 5 项

    把草稿作为一批输入。主模型同时计算五个预测位置的分布,因果遮罩仍限制每个位置能看到的前文。

    同一批验证 · 五个位置一起计算
    五份结果会一起显示。
    5
    五份分布,由同一次验证得到

    验证完成后,点按或移入任意一列,查看它当时依据的前文;键盘可用 Tab 聚焦。

    概率与通过情况均为教学设定,重点展示批量验证的数据依赖与前文更新。实际接受规则以对应采样验证算法为准。

    03

    保留通过的连续部分,接着往下写

    前 3 项通过,第 4 项“不停”未通过。主模型在这里补出“轻轻”;后续“摇动”的旧前提随之改变。

    本轮之后,实际使用的前文
    小猫正在新内容将在采用结果后接到这里
    前文会保留在这里,作为下一轮起草的起点。
    草稿被接受草稿未通过主模型补出旧前提失效
    沿用的思路

    提前提出多个候选、再由主模型验证,属于推测解码。DeepSeek-V3 的 MTP 已探索多 token 预测。

    本代采用的 DSpark

    3 个 Transformer 块并行计算 5 个草稿位置的基础分数,再用轻量模块处理候选间的依赖。调度器结合接受概率和服务负载,选择实际验证长度。

    技术报告 §2.4.3,印刷页 13–14。这里演示选择验证 5 项的情形;实际请求的验证长度由调度器决定。

    DSpark 草稿、验证与采用的依据

    报告中 DSpark 有 3 个 Transformer 块,滑动窗口 128,一次为五个草稿位置计算基础 logits,Markov 头建模依赖,置信度调度决定验证长度。它在主干预训练后单独训练,后训练中继续对齐。

    报告 §2.4.3(DSpark)· 第 13–14 页
    回到普通生成循环

    通过验证的连续前缀会追加到序列,缓存随已接受位置更新;第一个未通过的位置决定下一次从哪里继续。DSpark 改变了每次验证可能留下的 token 数,最终采用的 token 仍经过主模型核验。

    回看输出闭环
    候选怎样经过验证后成为下一轮输入?

    草稿模块先提出候选,主模型从头核验连续前缀;通过的部分按顺序追加到序列,并随即成为后续计算的输入。

    继续下一单元
    07参数角色 → 学习信号 → 更新

    学习单元 7 / 8

    这些运算怎样学出来

    参数从哪里来,训练又改变什么?

    推理让训练得到的参数参与前向计算;训练用损失评价输出,让梯度沿计算依赖返回并更新参数。

    激活参数:一个位置的计算,实际用到了多少权重?

    前面 Q、K、V 的投影矩阵中,训练得到的每个数都是一个参数。模型还保存专家网络、嵌入表等权重;推理时,当前计算路径会调用其中相应的部分。

    看模型保存的全部权重

    总参数量

    统计模型拥有多少训练得到的数值。各个专家的权重都属于这个集合。

    看一个 token 的当前计算路径

    激活参数量

    统计本次前向计算调用的参数规模。多个位置可以反复使用同一组权重。

    同一个模型,读入与生成的激活规模不同

    读入 · Prefill准备长输入的历史状态
    8B约 80 亿
    生成 · Decode新位置继续经过全部 40 层
    16B约 160 亿

    前文的 CED 让长输入的大多数位置只完成前 20 层;生成的新位置经过全部 40 层。报告据此给出 8B / 16B 的阶段激活口径,读入末尾仍有窗口重放工作。接下来用 MoE 看清:即使执行某一层,也只会调用这层的一部分权重。

    参数量、计算量和缓存量分别统计。一次前向会执行矩阵乘法等运算;对话产生的 K/V 则是中间状态。激活参数更少有助于减少计算,实际耗时还取决于注意力、访存和设备调度。

    B 表示十亿;8B 为 80 亿,16B 为 160 亿。阶段激活量依据报告 §2.1§4.2.1;后文继续核对总参数组成。模型的全部权重仍需由部署系统保存和管理。

    历代模型比较

    总参数、激活参数与计算量分别回答什么?

    B 表示十亿,T 表示万亿;FLOPs 是 floating-point operations(浮点运算次数),FP8 是 8 位浮点格式。

    总参数描述模型拥有多少训练得到的权重;激活参数描述一次处理某个 token 时实际经过其中多少权重;计算量还取决于序列阶段、上下文长度、算子和数值精度。

    本图选取 DeepSeek-V2 到 V4.1 的主要架构代际,用来比较参数规模、每个 token 的激活量和同条件下的计算量;它不枚举所有发布型号。额外模块与适用条件随图注明。

    V4.1-Flash 的参数量怎样计算?

    总参数量描述模型保存了多少训练得到的数值;激活参数量描述一个 token 经过计算时,调用了其中多少。B 表示十亿,1B = 10 亿。

    报告所列的两部分参数748B7,480 亿
    主干参数552B注意力、专家等模型权重
    Engram 参数196B训练得到的条件记忆

    组成条的长度按参数量比例绘制。约 748B 是 552B 与 196B 相加的结果,采用报告的近似口径。

    依据:所附 V4.1 报告 §2.1(第 7 页)、§2.4.2(第 13 页)和 §4.2.1(第 21–22 页)。总量与激活量分别统计,推理过程中产生的 KV 缓存另计。约 748B 是报告列出的主干与 Engram 两项近似规模之和,统计范围为这两部分。
    展开计算:这些大数字怎样由层、专家和记忆表累积起来?

    先算专家主体权重:约 545B

    每层有 384 个路由专家和 1 个共享专家。一个专家的前馈计算包含三张大矩阵:两张将 5,120 维转换到 2,304 维,另一张转换回来。这是报告采用的 SwiGLU 前馈结构。

    每层专家数
    384 + 1 = 385
    每个专家的矩阵参数
    3 × 5,120 × 2,304
    含 MoE 的层数
    40
    40×385×3×5120×2304= 544,997,376,000 ≈ 545B

    这是根据配置估算的专家主体权重规模。报告的 552B 主干还包括注意力等模块,其他部分采用报告总量口径。

    再算 Engram 记忆表:约 196B

    两个 Engram 模块各自保存三类短片段(2、3、4 个 token)的记忆。每类使用 8 张查找表;原文称为 8 个哈希头,即通过 8 种映射查表。每张表约有 1,600 万条,每条保存 256 个数。

    表的数量
    2 个模块 × 3 类 × 8 张
    每张表的条目数
    约 16,000,000
    每条的维度
    2,048 ÷ 8 = 256
    2×3×8×16000000×256≈ 196.6B

    16,000,000 是近似表长;实际采用不同的质数。因此这个算式用于核对数量级,报告将 Engram 参数规模记为 196B,两个模块均分。

    用不同训练信号,逐步形成任务能力

    报告沿用预训练、监督微调和强化学习等范式,强调数据、环境、可验证任务与教师指导的规模。

    01

    预训练

    在 45T token 多模态语料中学习表示、知识与预测。

    02

    SFT · 监督微调

    学习高质量任务示范中的回应与行动方式。

    03

    RL · 强化学习

    在可运行、可验证的任务中,根据反馈更新策略。

    04

    OPD · 在策略蒸馏

    学生模型先自己回答或执行任务,再利用教师模型对这些过程的指导更新参数;最后阶段超过 40 个教师。

    任务准备好后,模型怎样从反馈中学习?

    预训练先形成基础模型;后训练继续调整权重,让模型更好地回应指令和完成任务。V4.1 沿用 SFT → RL → OPD 的流程。下面用一道加法编程题,区分三种学习信号。

    同一教学任务编写 add(a, b),正确处理正数和负数。两项教学检查:2 + 3 = 5;−2 + 3 = 1。示例程序与概率用于解释学习方式;实际训练覆盖大量复杂任务。
    01 · SFT

    跟随参考示范学习

    给模型什么
    题目和参考程序,例如 return a + b
    用什么反馈
    提供参考答案此前的 token,让模型预测下一项,再与参考下一 token 比较。
    怎样更新权重
    训练程序汇总预测误差,更新模型,使参考示范中的输出更容易被生成。

    参考答案提供逐位置的学习目标。

    02 · RL

    自己尝试,再学习反馈

    给模型什么
    题目与可运行环境;模型自行生成程序,也可以运行测试、修改代码。
    用什么反馈
    验证器检查实际结果。例如直接相加通过两项;先把负数改为正数的实现只通过一项。
    怎样更新权重
    收集一批尝试记录,根据任务反馈等构成奖励;训练程序据此更新权重,调整今后生成这些行为的概率。

    完成任务的效果,指导模型怎样行动。

    03 · OPD

    在自己的轨迹上学教师

    给模型什么
    题目;由学生(正在训练的模型)先生成程序或行动过程。这条实际生成的记录叫作轨迹
    用什么反馈
    教师(提供指导的模型)读取学生已经生成的前缀,给出下一 token 的概率分布,作为学生权重更新的指导信号。
    怎样更新权重
    训练程序依据师生预测分布的差异更新学生权重。报告最终阶段采用全词表蒸馏。

    学生走过的上下文,决定在哪里接受指导。

    一次学习里,输入什么、比较什么、最后改什么?

    1 / 3 · 准备本次学习材料
    题目 + 参考前缀实现加法;参考程序已给到 return a这段前缀来自参考答案。
    等待比较参考答案的下一项是 +先预测这个位置,再与参考答案比较。
    模型权重:尚未执行这次更新这一步只是准备题目、前缀和学习目标。

    手动步骤用于展开学习信号。真实训练对一批样本、多个位置汇总计算;下面描述权重更新的方向,示例不运行模型训练。

    在 RL 中,当前模型先生成并执行一批尝试;任务反馈与长度等因素构成奖励,训练程序据此更新权重,再让更新后的模型继续尝试。改进来自这一循环的累积。

    展开一个 OPD 位置:教师具体提供什么?

    学生已生成程序片段 return a。在这个相同的学生前缀上,比较学生与教师对下一项的预测:

    一个参与蒸馏的预测位置 · 所有概率为教学设定
    候选 token学生预测教师指导
    +40%80%
    -30%10%
    *20%5%
    其余词表10%5%

    每列合计 100%,横条满长代表 100%。候选划分为示意;“其余词表”合并了未逐项展示的候选。

    比较的是两份分布

    教师既给出偏好的下一项,也给出其他候选的概率。训练利用这样的分布信号调整学生预测;“全词表”说明指导覆盖的候选范围。

    最终 OPD 阶段覆盖各领域并使用超过 40 个教师模型,不同领域可以使用各自适合的教师。学生与教师也可以采用不同架构。

    训练时 · 学习发生

    记录与反馈进入优化过程

    训练程序更新模型权重,并保存成新的模型版本。任务验收负责提高这些学习材料与反馈的可靠性。

    使用时 · 应用已学能力

    同一份权重处理新请求

    模型根据输入生成答案,更新本次会话的中间状态与 KV 缓存。日常推理过程中使用的权重保持固定。

    报告依据:§5.1 的 SFT、RL、OPD 流程,§5.1.1 的可验证任务,§5.1.4 的长度奖励,以及 §5.2.4 的全词表 OPD 与教师配置。上面用三种标准训练方式说明学习信号;具体代码、token 划分与概率均为教学示意。

    训练题的评分,能分清答对与答错吗?

    一个任务包包括题目、运行环境和验证器。验证器是自动检查结果的程序;它的反馈将用于后续训练,因此也需要验收。报告的代码任务构建流程采用多个 agent 试做,再由独立的质检 agent 验收。

    微型编程题 · 用于说明验收
    被验收的对象:任务包下面三项一起交给后续训练使用。
    问题

    编写 add(a, b),返回两个整数的和,也要支持负数

    环境

    可运行程序并传入两个数的测试环境。

    验证器 2 项检查

    正数检查:add(2, 3) 应为 5

    负数检查:add(-2, 3) 应为 1。

    任务包 v1
    1 / 3 · 多个 agent 试做试做
    实现甲 · 直接相加2 / 2 通过

    输入 2、3 → 5;输入 −2、3 → 1

    实现乙 · 先把负数改为正数1 / 2 通过

    输入 2、3 → 5;输入 −2、3 → 5

    输出用于对照程序行为;得分只统计验证器列出的检查。

    用两份试做记录检验评分依据。

    甲能处理负数,乙在负数输入上答错。现有验证器给出甲 2 / 2、乙 1 / 2。

    接下来独立验收:题目要求与检查是否一致。

    入库之后才进入训练使用

    训练任务库保存题目、环境和判分依据;甲、乙作为试做记录保留。以后模型重新做这道题,验证器提供结果反馈,训练程序再据此更新模型权重。

    本图的验收步骤整理任务包,模型权重的更新发生在后续训练中。任务入库也与软件部署上线属于不同流程。

    这个例子只放大“漏测会使错误实现获得同样好评”。报告中的真实任务更复杂,质检还检查环境、难度、事实与评分漏洞;使用中的任务持续复审。

    任务结构与验收流程:官方报告 §5.1.1(第 25–26 页)。任务卡与验收闭环的组织方式参考 SuperAlign 后训练图解;例子与交互为本页教学设计。

    推理强度 1–100:模型怎样学会调节思考长短?

    强化学习还训练了一种可调节的生成策略。模型接收一个 1–100 的整数 b,数值越高,越鼓励更充分的推理。训练时,把这个强度值写入系统提示,和任务一起交给模型;模型通过后续奖励学习怎样响应它。

    训练把“强度值”与“推理策略”联系起来。
    训练时 · 下面三个步骤反复进行
    1 · 生成尝试任务 + 强度 b

    同一道题搭配若干训练档位;模型在每个档位生成多份回答。

    2 · 计算反馈任务质量 + 长度项

    较低 b:同样长度扣分较多。
    较高 b:同样长度扣分较少。

    3 · 更新权重比较同题、同档位的回答

    根据奖励调整策略,再用更新后的模型生成下一批尝试。

    这一训练循环,得到同一套模型权重模型学会按强度信号,调整推理长度与完成任务的取舍。
    使用时 · 训练后的权重保持固定
    本次请求任务 + Reasoning Effort: 75
    同一个模型按学到的策略生成推理与回答

    箭头表示前一步结果交给后一步。训练覆盖有限档位,部署可输入中间值,利用学到的插值能力;每道题的实际输出长度仍由生成过程决定。

    调节的是一次回答愿意花多少推理

    强度更高时,平均推理通常更长、计算成本更高,困难任务可能受益更多。前面 MoE 的每层专家配置保持相同;较长的推理让模型多生成一些位置。

    具体长度仍由任务与生成过程决定

    b 是模型学过的偏好信号。它与 max_tokens 这类输出硬上限各有作用:前者影响生成策略,后者限制最多输出多少。实际长度还随题目、采样和多轮工具调用变化。

    模型的细分能力,与 API 提供的档位

    报告记录的 2026 年 9 月公开 API 使用三个预设值:

    API 档位b所请求的推理强度
    low50较低
    high75较高
    max100最高
    展开训练公式:长度扣分怎样随强度变化?

    设一份回答使用了 ℓ 个推理 token。训练奖励中的长度项为:

    rlen = −min(Cmax, k(b) × ℓ / Lnorm)

    k(b) = k0 exp[−(bbmin) / τ]

    Lnorm 是参考长度,Cmax 限制最多扣多少分;bmin 是最低训练档位,k0 是该档位的扣分系数,τ 控制系数下降的速度。随着 b 增大,同样长度的扣分系数按指数下降,模型因而学到不同的成本与质量取舍。

    这套公式描述训练中的取舍。具体训练档位与惩罚超参数共同影响学到的策略;附录 C 用局部近似分析长度趋势,实际输出长度随任务与生成过程变化。

    依据:报告 §5.1.4表 2(第 29–30 页)、§5.3.3 与附录 C(第 49–51 页)。这项功能属于后训练学到的控制能力。

    展开:训练之后的延伸概念

    继续深入时,还会遇到这些概念

    以下只介绍作用,计算细节留作延伸阅读。

    • 门控前馈与归一化:SwiGLU 用门控调节专家内部的信息变换,RMSNorm 调整数值尺度,两者的逐项运算在本页作了简化。
    • 位置编码与注意力参数化:RoPE 把相对位置关系引入匹配计算,查询压缩与分组输出投影则进一步调整计算规模。
    • 图文专家负载均衡:V4.1 分别维护图像和文字的路由校正偏置,让两类输入各自获得较均衡的专家使用分布。
    • 草稿内部的依赖与调度:DSpark 用 Markov 头处理草稿候选间的依赖,并结合置信度和负载决定实际验证长度。
    • 训练优化器:Muon、AdamW 与 Sinkhorn 平衡更新分别服务于不同类别的参数,决定训练中权重怎样更新。
    • 分布式训练与部署:参数分片、跨设备共享、视觉编码与读入和生成阶段的分离,以及算子融合,共同影响实际吞吐、延迟和显存开销。

    对应报告 §2.1.1§2.3§2.4.3§2.5§3.1–3.2§4.2

    训练与推理怎样使用同一组参数?

    训练用损失和梯度调整参数;训练完成后,推理读取这些固定参数完成前向计算。两种过程共享计算依赖,运行目的和参数是否更新有所不同。

    继续下一单元
    08评测条件 → 全程回放 → 来源

    学习单元 8 / 8

    如何判断效果并回顾全程

    证据能支持哪些结论,又有哪些边界?

    任务、指标、执行框架和比较条件放在一起看,再沿输入到输出回放一次。各专题旁边可以查看直接来源,这里再集中汇总。

    报告中的成绩说明了什么?

    测评分数描述任务表现,计算量和缓存容量描述运行开销。比较模型成绩时,也要一起看任务与测试条件。

    这些数字,各自测的是哪一种能力?

    预训练结束的基础模型,与完成后训练的对话模型,接受的测评有所不同。同一个数字,模型阶段和指标不同,含义也不同;认准这两项,才知道提高的是什么。

    报告中的三类能力证据
    测评对象与出处测什么怎样读
    基础模型公开任务基准§4.3 · 表 1知识、推理、代码、长上下文与多模态任务。逐项看准确率、成功率等成绩,并保留表中的提示示例数(shots)与任务设置。
    基础模型内部保留语料§4.3 · 图 6模型对内部文档、代码和学术材料的预测能力,用 BPB 衡量。BPB 按模型给出的概率计算平均每个字节所需的比特数;越低,文本越容易被模型预测。报告开头的“提高 5%–10%”属于这类保留集评估。
    后训练模型任务解决表现§5.3 · 表 3表 4完成后训练后,模型回答问题、写代码和使用工具的表现。同时看推理强度、采样次数与执行框架。下方交互图展示这一类成绩。

    前文的 token·层、KV 字节数与索引评分次数,分别描述完整层计算位置数、存储占用和搜索工作量;这里的任务成绩描述模型表现。每类数字都对应自己的测量对象。

    切换任务,观察排序怎样改变

    四个模型使用同一条 0–100 分轴,均为各自的 Max 推理努力设置。Resolved 指任务解决率,Pass@1 指单次尝试成功率。数据来自所附报告表 3。

    同一份报告的模型对照;分数不能直接转换为推理速度。

    执行框架也会改变同一模型的成绩

    执行框架负责组织系统提示、工具接口、上下文管理和行动循环。报告表 4 对比两种执行框架时,同一 V4.1-Flash 得到不同成绩;两者均采用 Max 推理强度(100)。

    Codex 框架65.6
    mini-SWE 框架74.2

    同一模型,相差 8.6 个百分点。

    对照固定同一份模型权重版本(checkpoint)、解码配置与任务集;每题采样 8 次。Resolved 指任务解决率。
    评测任务、指标与比较条件的依据

    报告 §6 明确讨论 CSA² 选择错误、SWA 近似重放在未测边界下的退化可能。多 Agent 结果也属于特定任务子集与墙钟预算下的初步实验。

    报告 表 3 · 第 33 页报告 表 4 · 第 35 页报告 §6 · 第 37 页

    表 3 中这里展示的四个模型均采用各自的 Max 推理努力设置。表 4 的同模型框架对照固定 checkpoint、解码配置与任务集,使用 Max 推理努力(100);DeepSWE 每题采样 8 次。报告 §5.3.1(第 32 页)及表 4 注释(第 35 页)给出具体设置。

    沿着计算过程,回顾这份报告

    回顾的线索是:被改变的对象是什么,它从哪里来、由哪些层使用、少了哪些工作;顺着这条线索,结构名称就能和实际机制对上。下面六道单选沿着同一条计算过程排开,从一轮回答问到候选起草;每题三个选项,选完当场给出判断和依据,答错的那题可以直接回到对应正文核对。

    1. 1生成

      新 token 是在哪一步才真正确定的?

    2. 2注意力与缓存

      已经算过的位置,它们的 K / V 为什么下一轮还能直接用?

    3. 3CED

      后 20 层用的全局主 K / V,是从哪里产生的?

    4. 4CSA²

      40 层里,哪些层要重新筛选历史位置?

    5. 5缓存策略

      局部窗口状态过期以后,靠什么补回来?

    6. 6DSpark

      主模型怎样一次核对 5 项草稿?

    依据与延伸阅读

    V4.1 的机制与配置以所附技术报告为主要依据;算例中的数字和词语选择单独标为教学示意。

    DeepSelect 的 Top-K 接口 ↗:接收分数,返回选中条目的编号。

    图解参考 · 《DeepSeek-V4.1-Flash 技术报告图解》

    CSA² 工作量、训练任务质检和 MoE 数值合并借鉴了这份独立图解的讲解切入点。相关机制与数字均再对照官方报告,页面图示独立绘制:

    参考版本:2026 年 9 月 11 日保存的七页 HTML。

    展开:资料范围、核对日期与报告页码

    资料读取范围

    V4.1 的公开说明与更新见官方模型页。本页以所引用报告版本为讲解基准;在线权重和部署配置以模型仓库的当前文件为准。

    补充阅读链接(未作为本页机制与数字的依据):文章一文章二

    官方模型页访问核对:2026-09-12。各项配置与价格的核对日期见对应段落。所有机制演示在浏览器本地执行,不请求模型。

    完整结构、图文、Engram 与训练的报告出处

    图像经 DeepSeek-ViT 成为空间特征网格;3×3 pixel-unshuffle 将邻域重排到通道维,位置数减为 1/9,再经 MLP 投影接入语言序列。邻域信息随重排保存在通道中。

    报告强调合成任务的规模、多样性、可验证性和环境工程;后训练采用 SFT、RL、OPD 的标准范式。异步训练还要控制样本长度偏差与旧策略样本问题。

    • §2.1.1第 8 页
    • §2.4.2第 13 页Engram 的 2/3/4-gram 寻址
    • §4.2.1第 21–22 页384 个路由专家、激活 6 个、1 个共享专家
    • §4.2.2第 22 页45T 多模态 token
    • §5第 25 页
    • §5.2.4第 31–32 页超过 40 个教师

    从原理走向实现:三个官方仓库分别做什么?

    先区分模型外部的格式处理、模型计算中的选择算子,以及支撑算子运行的软件。它们在不同位置发挥作用。

    输入输出接口

    deepseek-recipe ↗

    把不同 API 的对话请求整理成 V4 / V4.1 的 prompt,并配合对应 tokenizer 转成 token IDs,再把模型输出解析为响应。官方演示能查看特殊 token 和输入格式。

    这里的“编码、解码”指格式与 token 转换;CED 的编码器、解码器则是神经网络层。官方演示展示输入输出格式,不运行模型推理;实际服务的推理后端需另行提供。

    官方 README ↗
    注意力中的选择步骤

    DeepSelect ↗

    接收索引器已经算好的分数,高效返回 Top-K 位置编号。从历史到候选池中的“选哪些位置”与它直接对应;选好后,注意力再读取相应 K/V。

    报告 §3.2 明确引用它的 TopK 内核。内核测试的加速倍率只对应那一步计算。

    官方选择接口 ↗
    算子编译与运行

    DeepJIT ↗

    管理设备算子的运行时编译、加载和启动,支持 CUDA GPU 与昇腾 NPU。它还保存已编译的程序,供后续直接复用。

    这里缓存的是程序;前文 KV cache 保存的是 token 的中间数值。报告提到的 DeepGEMM 在公开实现中使用 DeepJIT。

    官方 README ↗DeepGEMM 依赖说明 ↗

    DeepSelect 有报告中的直接引用;另外两个仓库提供官方接口与实现资料,帮助理解模型周围的软件分工。