HySparse2：整体架构、KV 生命周期与 PD 分离

HySparse2：整体架构、KV 生命周期、Prefill/Decode 与 PD 分离完整解析

整理日期：2026-10-06。本文新建，不覆盖已有文档。配套：HySparse 完整整理。

完整性说明：已从本任务原始记录找回今天的三轮技术问答。正文按主题详细重组，末尾附录按时间保留三轮完整提问与完整回答，包括第一轮架构图、PD 时序图、数学推导、实验取舍和后两轮全部追问。原文只转换 LaTeX 分隔符、标题层级和不可移植的引用格式，不删段落。历史讲解中的简化说法由正文澄清，不以静默删改历史代替纠正。

时间口径：北京时间 2026-10-06。技术问答为 13:02 开始的论文解读、13:47 的三项追问、19:03 的局部窗口追问。19:08 的请求是本次文档整理任务，不是另一个待解释的技术段落。

阅读导航

1. 先建立三个区别：来源与缓存、历史 KV 与历史 Reader、阶段与层。
2. 模型总图、两级共享、三类 KV。
3. SA 的两类位置为什么仍有必要。
4. Prefill 提前退出：四个 token 的例子与依赖证明。
5. Decode、状态生命周期、伪代码。
6. PD 的基础定义、部署、交接和流水线。
7. 与 HySparse、YOCO、DeepSeek CED、MLA–KDA 的联系。
8. 性能归因、消融结果与理论边界。
9. 逐问题覆盖清单、历史表述澄清、全部三轮历史问答。

1. 论文与结论

论文：HySparse2: Hybrid Sparse Attention with Two-Level KV Sharing，arXiv:2609.26368。

• 论文 HTML
• 论文 PDF

一句话：HySparse2 让后半模型的全局 KV 从前半模型 hidden 提前生成；后半各组 SA 共享所属 FA 的 KV 与选择索引，并把局部需求改成访问同一 KV 中的近期位置。这样，绝大多数历史位置不必再执行后半模型的 Query、attention 读出和 MoE。

它同时使用两种不同的共享：

不能把它们合并成“所有层共享同一份 State”。

2. 最容易混淆的三个区别

容易混在一起的说法	正确区分
Cross KV 来自 Self	来自 Self 的 hidden，经 Cross 自己的 K/V 投影；不是把 Self 的 FA/SWA KV 直接拼起来
跳过 Cross Prefill	跳过绝大多数历史位置的 Cross 完整前向；这些位置的 Cross KV 仍生成，首 token 仍需最后位置的 Cross 输出
P 跑 Self，D 跑 Cross	这只描述首次交接的一部分；独立 D 后续仍需运行 Self + Cross。PD 按阶段分，不是按层分

另一个必须分开的概念是：有局部访问窗口，不等于存在独立的 SWA 子层和缓存。

3. 整体架构与层数

蓝色箭头是 KV Bridging：Cross 的全局 KV 由 Self 侧源 hidden 提前投影出来。红色箭头是 KV Reuse：同一组里的 SA 直接复用所属 FA 的 KV 和选择索引。虚线 Prefill Exit 表示历史 token 跑完 Self-Decoder 后就可以退出，不必再走 Cross 的完整前向。

图 2 的 49 层模型为：

共 25 层 Self、24 层 Cross；总计 24 SWA、5 FA、20 SA。本文如显式写层号，使用从 1 开始的编号：Self 为 1–25，Cross FA 为 26、32、38、44。

Self-Decoder 仍为因果模块，不是翻译模型里可看见后文的双向 Encoder。用它构建的历史表示必须满足因果性。

flowchart TD X["输入 token / Embedding"] --> S1["Self：12 层 SWA"] S1 --> A["源表示 A：Self FA 输入"] A --> SF["Self：1 层 FA"] SF --> S2["Self：12 层 SWA"] S2 --> B["源表示 B：Self / Cross 边界表示"] A -.-> P["按图示映射进行 4 组独立 K/V 投影"] B -.-> P P --> M["4 份互相独立的 Cross Global KV"] B --> C1["组 1：FA + 5 SA"] C1 --> C2["组 2：FA + 5 SA"] C2 --> C3["组 3：FA + 5 SA"] C3 --> C4["组 4：FA + 5 SA"] C4 --> O["输出头 / 采样"] M -. "各组读取所属的那一份" .-> C1 M -.-> C2 M -.-> C3 M -.-> C4

图中的 M 是四份缓存的集合，不表示四组全部读取一个混合池。蓝色桥接源的具体层映射应以论文图或实现为准：原图既画出 Self FA 输入侧的源，也画出 Self/Cross 边界侧的源。正文公式用对应 Self FA 输入表示说明原则，不能因此把所有桥接都改写成“统一使用最终 ”，也不能把 input hidden 误写成该 FA 已聚合过的 output hidden。

4. 第一层共享：KV Bridging

4.1 改的是 K/V 的输入，Query 不改来源

对 Cross 分组 的 FA，简写为：

上标 表示 Self， 表示 Cross， 是分组， 是该分组对应的源位置（层/接口），不是 token 索引。这里直接用投影算子，避免矩阵按行/列存储时的乘法方向混淆。

K/V 可以在源 hidden 就绪时提前生成；Q 必须等当前 Cross 层的输入 hidden 到达。桥接 KV 不意味着桥接了 attention 输出或选择分数。

4.2 同源不等于同缓存

即使 ，独立投影仍可产生不同的：

各组 Writer 的输入就绪后，组间 KV 投影在计算图上独立，可以独立调度。但同 GPU 上实际并行是否提速取决于资源饱和程度，不保证开多个 stream 就更快。

5. 第二层共享：KV Reuse

同组 FA 后面的 5 个 SA 直接复用：

第 个 SA 仍生成：

然后执行本层的注意力读出、输出门、输出投影、残差和 MoE。复用资料和候选位置，不等于复用答案。

下一组 FA 使用自己的 Query 做新的全局扫描和选择；下一生成位置 也需要重新产生相应选择，不能永久沿用 。

6. 三类 KV：回答“是不是 Self FA + SWA 的两套缓存”

不是。缓存归属如下：

缓存	生成输入	投影属于谁	谁读它	规模
Self FA Global KV	Self FA 的输入 hidden	Self FA	Self FA	一份，随上下文增长
Self 每层 SWA KV	该 Self SWA 层输入 hidden	该 SWA 层	该 SWA 层	24 份窗口状态
Cross Global KV	指定 Self 源 hidden	对应 Cross FA	该 FA 与同组 5 SA	四份，随上下文增长

Cross SA 不把 Self FA KV 与 Self SWA KV 当成两路输入，也不从两者拼接生成自己的 KV。

“源 hidden 在形成过程中受到 Self FA 和 SWA 加工”与“直接读取这两类层的 KV”是不同的计算关系。

因此，删除的是 Cross SA 自己的局部 KV 分支；Self 的 24 份局部缓存仍保留，Self FA 的全局缓存也仍保留。

7. Cross 没有独立 SWA，为什么 SA 还选两类位置

7.1 局部信息需求没有消失

全局 Top-K 可能挑中远处事实，却漏掉当前句子里的否定词、变量、标点、刚刚生成的内容。最近 token 不一定都有很大的全局选择分数。

删除一个独立 SWA 模块，不代表愿意放弃近期上下文。因此采用“近期必选、远处择优”的访问规则。

7.2 两类位置来自同一份 KV

对于位置 ，窗口宽度为 ：

在窗口外取最高分的至多 个位置：

论文配置为 。如果上下文不够长，实际位置数小于预算；窗口外选择避免和必选窗口重复占预算。

它们从同一个 取条目。忽略 sink、门控、多头和输出投影时的核心形式为：

最近位置和远处位置参加同一次归一化。这里的拼接是沿被访问的 token/entry 轴排列 KV 条目，不是把 K 与 V 拼成同一个特征，也不是把两套不同层的缓存混合。

物理实现可以按索引直接访问 paged KV，无须真的复制出长期持有的连续拼接数组。

7.3 数值例子

若 ，最近窗口为 。再从 中选 1024 个位置，例如函数定义、前文证据、工具输出等。

两部分共用一份缓存，只是确定索引的方法不同。前者保证基本局部上下文，后者提供远程检索。

7.4 两代不是同一个 attention 的两种写法

项目	HySparse 独立 SWA	HySparse2 Forced window
局部 KV 来源	本层历史 hidden	Cross 组共享 KV
独立局部投影	有	无
局部缓存	有	无
归一化	局部、全局分别归一化再门控融合	所选局部、远程位置一起归一化
本层历史 hidden 依赖	有	无

第二代在访问模式上具有滑动窗口特征，但没有独立 SWA 记忆构建路径。不能把 Forced SWA 这个实验名称误读成“其实又放回一个 SWA 层”。

8. Prefill 早退：四个 token 的完整例子

输入为 ，要生成 。

8.1 四个位置都运行 Self

Self 的 FA 和 SWA 仍要完成各自正常计算。

8.2 四个位置都生成 Cross KV

这些投影不是完整 Cross block。无需对所有历史位置生成 Cross Q、做 Cross FA/SA 读出或运行 Cross MoE。

8.3 只让位置 4 的边界表示运行 Cross

位置 1、2、3 不产生 Cross hidden 也不影响未来记忆，因为对应的 Cross KV 已由 Self 侧生成。

位置	Self 完整前向	Cross KV 投影	Cross Q/读出/MoE
1、2、3	执行	执行	跳过
4	执行	执行	执行，预测 5

8.4 之后输入 x5 时，仍需两半模型

采样得到 后，预测 的过程为：

“只算最后一个 prompt 位置的 Cross”不是“未来所有 token 只过 Cross”，也不是“Cross 只执行一层”。后半 24 层仍沿层依次执行。

9. 为什么这是精确省略，而不是尾部近似

9.1 普通结构的深层历史 KV 依赖历史 hidden

为了给未来 token 保存第 层的位置 KV，必须先计算位置 的前面层输出。

9.2 桥接后，历史 KV 与 Cross 历史 hidden 脱钩

当所有桥接 KV 已就绪，Cross 的当前位置可抽象为：

索引由同组先行 FA 的当前 Query 得到。后续 SA 无需自己过去位置的 hidden 来写缓存。于是沿层递推计算 即可，其他位置没有必须补算的局部 Writer。

精确性指对同一个已经训练好的 HySparse2 计算图，省掉不影响最后输出的历史节点；不指它与全注意力模型或第一代模型输出相同。实际浮点 kernel 可能因分块和归约顺序产生微小数值差异，也不改变依赖上的结论。

9.3 仍然不能跳过的东西

• 历史位置的 Self 计算；
• 历史位置的 Cross KV 投影；
• 位置 的 Cross 层及输出头；
• Decode 每个新位置的 Self 和 Cross；
• 需要全位置训练损失或 prompt log-probability 时，相应位置的 Cross 输出。

9.4 为什么不需要 128-token 或 100-token replay

独立 SWA 会要求本层历史 hidden，Q 短卷积也会要求本层过去的投影。若这些依赖跨多层叠加，需要的输入尾部范围可能超过单层窗口。

HySparse2 后半的近期信息已经在桥接 KV 中。128 是访问预算，不是要重新计算的 128 个 Cross hidden；100 是此前特定 KDA Query 卷积方案推导的尾长，不适用于这里。

10. Decode 与缓存生命周期

10.1 单个新 token 的执行

1. Embedding 后执行前 25 层 Self。
2. 更新 Self FA 的全局 KV 和各 SWA 窗口。
3. 源 hidden 就绪时，为四个 Cross 分组各追加一个 KV entry。
4. Cross 第 1 组 FA 使用当前层 Query 扫描自己的全局 KV，产生当前索引。
5. 该组 5 个 SA 使用自己的 Query 复用 KV 和索引。
6. 继续其余 3 组，输出头采样下一 token。

完整 hidden 链仍串行，只有在输入就绪后的 KV 构建分支获得了独立调度机会。

10.2 状态的生命周期

状态	Prefill	Decode	请求结束
Self FA Global KV	构建全部历史	每 token 追加	释放或按 prefix 策略保留
24 层 Self SWA KV	计算过程中形成窗口	滚动更新	释放或以可恢复形式保留
4 组 Cross Global KV	源 hidden 投影构建全部历史	每组追加新条目	释放或按 prefix 策略保留
桥接源 hidden	按需暂存供投影	当前 token 暂存	无其他用途后可释放
最后位置边界状态	启动 Cross 所需	当前 token 工作状态	可释放
FA 选择索引	只算需要读出的 Query	每组每 Query 重新产生	临时量，不是固定记忆
Cross 局部 SWA KV	不存在	不存在	不存在

论文没有给出完整 prefix-cache 生命周期实现。表中的请求结束处理是系统选择，不能将模型有 KV sharing 等同于默认跨请求持久化。

10.3 示意伪代码

以下表达依赖关系，不是官方仓库代码，也不是可直接运行的 kernel：

def prefill_cache_only(prompt):
    self_cache, source_states, boundary = run_self_decoder(prompt)
    cross_cache = {}
    for group in cross_groups:
        cross_cache[group] = project_group_kv(
            group, source_states[group.source]
        )
    return self_cache, cross_cache, boundary.last_state

def start_generation(bundle):
    # prompt 最后位置的 Cross KV 已由 P 构建，不能再重复追加。
    h = run_cross_current_position(
        bundle.last_state, bundle.cross_cache
    )
    return sample(lm_head(h))

def decode_one(input_token, state):
    h, sources = run_self_one(input_token, state.self_cache)
    for group in cross_groups:
        state.cross_cache[group].append(
            project_group_kv(group, sources[group.source])
        )
    h = run_cross_current_position(h, state.cross_cache)
    return sample(lm_head(h))

boundary.last_state 代表所需完整边界残差/hidden 状态；若模型存在多流残差结构，不能只因为讲解写了一个 就假设实现只需一个简单向量。训练与推理也须保持位置编码、mask、cache offset 和权重版本一致。

11. 从零理解 PD 分离

11.1 Prefill 和 Decode 是请求的两个阶段

例如输入 10000 个已知 token，生成 100 个未知 token。Prefill 批量处理已知输入并建缓存；Decode 把刚采样出的 token 送入模型，利用缓存预测下一个。

首 token 的输出头通常计入 Prefill，也可以把最后阶段挪到 D 节点。定义边界不同不等于该计算消失。投机解码可改变执行批次，但不改变基本因果要求。

11.2 分离的是服务角色

P worker 专门处理新 prompt，D worker 接手缓存后持续生成。典型普通模型 PD 中，P 和 D 都具有完整模型能力，只是调度的阶段不同。每个 worker 可能跨多张 GPU。

大 Prefill 常具有大批量矩阵乘特征；小批量 Decode 常受权重/KV 带宽影响。实际瓶颈会随 batch、上下文和并行方式变化，不应把“P 必然纯算力、D 必然纯带宽”当成无条件规律。

分离可减少 Prefill 对逐 token 输出的干扰，并分别扩缩资源、选择批大小和并行策略。代价是缓存传输、目的端显存预留、排队、同步和可能的布局转换。

11.3 不是把前半层放 P，后半层放 D

如果每个生成 token 都先经过设备 A 的前半层，再经过设备 B 的后半层，那是按模型深度切分的流水线，需要逐 token 跨设备传 activation。

PD 是按阶段分工：P 为这个请求准备历史，交接后 D 持续生成，P 可以去处理别的请求。

对比	PD 阶段分离	模型层流水线切分
切分对象	prompt 阶段与生成阶段	前半层与后半层
主要交接数据	历史 KV / 状态	每次前向的 activation
后续每个 token 是否都经过原 P	通常不需要	若原 P 承担前半层，则需要
是否可组合	可以	可以，但组合后要分别描述两种机制

12. HySparse2 的 PD 部署与交接

12.1 论文明确的部署方案

P 节点只需 Self 的 25 层加 Cross KV Bridging 投影。Cross KV 在 P 上投影完成再发送，因为该配置下投影 KV 比源 hidden 更小。

若 D 要独立处理后续 token，则 D 必须具备完整 Self + Cross 能力。这是由计算依赖推出的要求，不能把它写成论文已经公布某套调度器的全部部署细节。

12.2 正确交接至少要覆盖哪些状态

内容	为什么需要
Self FA 全局 KV	新 token 的 Self FA 要读历史
Self 各 SWA 窗口状态	新 token 的 Self SWA 要读局部历史
四份 Cross KV	当前和后续 Cross 要读完整历史
最后 prompt 位置的边界状态	D 完成首 token 的 Cross 读出
长度、位置、页映射、布局和量化元数据	防止读错位置、重复写入或错解释缓存

论文重点说明 Cross KV 传输；其余字段是独立 D 正确执行所需的系统推导，不是论文附带的已实现 wire protocol。

12.3 首次启动和后续 Decode 不一样

首次：P 已经运行位置 的 Self，D 只需接着运行该位置的 Cross，得到 。

随后： 是一个新输入位置，D 需要运行它的 Self、追加缓存、运行 Cross，得到 。

sequenceDiagram participant U as 请求入口 participant P as P worker：Self + 桥接投影 participant D as D worker：完整模型能力 U->>P: prompt P->>P: 全部位置运行 Self P->>P: 根据源 hidden 构建四份 Cross KV P->>D: Self 状态、Cross KV、元数据 P->>D: prompt 最后位置的边界状态 D->>D: 只对最后位置运行 Cross D-->>U: 首个回答 token loop 后续生成 D->>D: 新 token 运行 Self D->>D: 更新 Self 缓存，追加四份 Cross KV D->>D: Cross FA 选位置，SA 复用并读出 D-->>U: 下一个回答 token end

P 不需要为这个请求的每个生成 token 再提供 Self 计算。若特意这样部署，就需要明确那是额外的模型流水线设计。

13. PD 流水线能在哪里重叠

以下是从依赖图得到的机会，不是论文实测结果：

1. 源 hidden 与投影流水化：某个源 chunk 就绪，立即构建对应 Cross KV，无须等所有 prompt 位置全部到齐。
2. KV 生成与传输流水化：完成的 KV chunk 可发送到 D，P 继续计算其他 chunk。
3. 不同请求间流水化：P 处理请求 B 的 prompt 时，D 生成请求 A 的输出。
4. 组间投影调度：各 Cross 组投影在源输入就绪后独立，可合并 GEMM 或并行安排。

但 D 当前 Query 的 FA 需要所有因果可见 KV 已可读，不能在未到齐的缓存上直接采样。各组最早就绪时刻、网络带宽和页安装开销会决定真正的临界路径。

一个仅用于理解的时间模型为：

上式是不考虑重叠的分解；有重叠时必须按依赖 DAG 的临界路径统计，不能机械把所有阶段时间相加，也不能把它们全部取最大值而忽略先后依赖。

论文还讨论分界 hidden 较早可用，未来可支持更大的 DFlash 式 drafter 和异步协调；大 drafter 的训练及反馈协调是 future work。不能当成已经实测的 PD 或投机系统吞吐收益。

14. 与 YOCO、DeepSeek CED 和 KDA 尾部的比较

方案	后半记忆来源	后半本层历史依赖	只算最后位置是否足够
YOCO	Self 输出构建共享全局 KV	原论文 Cross 读出无额外局部历史 Writer	生成首 token 的 Cross 读出可只算最后位置
HySparse2	指定 Self 源 hidden，经组独立投影	删除独立 SWA，局部位置也读共享 KV	在本文讨论的计算图中足够
前面讨论的 DeepSeek V4.1 Flash CED	Encoder 驱动全局记忆	Decoder 保留逐层局部 SWA 状态	还要处理局部尾状态；不能与上两者混同
此前共享 的 MLA–KDA 提案	各后层独立 Writer 接共享	本层 Query 短卷积历史仍在	需按卷积依赖补齐尾部

对于 KDA 提案，若 33 个后半 KDA 层各有宽度 4 的 Query 卷积：

这解释“100-token”是依赖长度，不是选取 100 个相关 token，也不是 KV 缓存容量。该尾部沿层串行，但层内可以批量计算有效位置；状态必须从正确前缀状态推进，不能把 用于所有尾部 Query，更不能重复写入历史。

HySparse2 的四组桥接只生成 KV，并不等同于 KDA state-only Writer：后者还需逐位置处理门控、K/V 与状态扫描。不能用轻量 KV 投影的代价证明 KDA Writer 也一定便宜。

关于 bounded replay：HySparse2 把它作为保留 Cross SWA 历史依赖时的近似处理例子。有限尾窗重算是否与完整运行等价，需要验证边界状态和感受野，不能仅凭窗口等于 128 就宣布精确。

15. 与第一代的逐项区别

维度	HySparse	HySparse2
骨干	FA 后接若干 SA，逐组串联	Self + Cross
Global Writer 输入	各组当前层 hidden	Cross Writer 改接 Self 源 hidden
组内 KV 与索引共享	有	有
选择粒度	64-token block	单 token
SA 的近期信息	本层独立 SWA KV 分支	共享 KV 的强制局部位置
归一化与融合	两分支独立 softmax + 门控	一次稀疏 core attention，再走输出路径
历史后半 Reader	仍影响后续记忆构建	大部分可省略
P 节点完整骨干需求	普通实现仍需完整	可仅部署 Self + 桥接投影
独立 D 的计算能力	完整模型	仍需完整模型

16. FLOPs、缓存与真实系统性能应分别归因

16.1 Attention 工作量的示意

Decode 在长度 时忽略维度常数：

5 个 FA 仍扫描历史，20 SA 访问稀疏集合，24 Self SWA 访问局部窗口。Decode 仍有随上下文增长的部分。

Prefill 全序列缓存构建只运行 Self 中的一个 FA，而不是运行 Cross 四个 FA 的所有历史 Query；桥接 KV 仍需对所有位置投影。这与只把 FA 换成 SA 是不同层面的收益。

16.2 论文报告的数字

在 80B-A3B、长度 1M、FP8 KV 口径下：

模型	KV cache
Hybrid SWA	12.09 GB
HySparse	6.72 GB
HySparse2	2.69 GB

HySparse2 的 Prefill FLOPs 相对 HySparse 减少约 ，相对 Hybrid SWA 减少约 。这些是计算量对比，不能写成同倍率的 TTFT 或吞吐实测加速。

16.3 缓存缩小不全是 Bridging 的功劳

第二代论文的对照配置中，HySparse 和 HySparse2 都有五份 Global KV。对应每位置每份 KV 的元素量分别为：

因此，这个对照中进一步缩小 KV 的主导数值来源是 GQA 到 MQA 以及 head 维度的配置变化。Bridging 的主要突出贡献是改变 Prefill 依赖，而不是把五份 Global KV 变成一份。

记每份 global KV 每 token 字节数为 ，局部每层为 ，有粗略状态量：

索引、量化 scale、页对齐、临时 buffer 需要另计。原论文第一代的维度表与第二代中的对照模型配置并不完全相同，比较时必须说明口径。

17. 实验取舍：不要写成全面无损

17.1 训练与模型设置

主实验是 49 层、80B-A3B、hidden size 2048 的 MoE，采用简化 mHC，残差 mixing matrix 固定为 identity。主对照预训练约 500B token，长度 32k；轻量后训练增加约 100B token，加入 agentic 数据，长度扩到 256k。

Self SWA 使用部分 RoPE；FA/SA 使用 NoPE。所有 SA/SWA 使用输出 sigmoid gate 与可学习的每头 sink bias。因此正文 softmax 公式是解释 core attention 的简式，不是逐行官方实现。

17.2 token-level 与 block-level

固定全局 1024 token 预算的预训练消融：

指标	Block	Token
RULER-v2	49.56	56.13
MRCR-v2，2-needle	12.94	21.08
GraphWalks	29.38	34.92
BBH	61.93	60.70
NoLiMa	40.27	38.43

token-level 能把预算分给散落的标识符、角色边界、工具结果，避免为了单个有用 token 附带整个块。但不是所有指标都提升。

17.3 删除独立 SWA 的代价

指标	Gated SWA	No SWA	Forced SWA
GSM8K	64.52	60.35	59.44
MRCR-v2	27.66	20.73	22.67
RULER	88.19	84.55	89.84
RULER-v2	53.66	54.62	55.98
GraphWalks	35.39	36.48	37.13
LongPPL，越低越好	6.8807	7.1307	6.9838

Forced SWA 在某些检索和图推理指标上更好，但相对独立 Gated SWA，GSM8K 下降 5.08 点，MRCR-v2 下降 4.99 点。作者认为这是换取更少投影和缓存、支持完整 Prefill 早退的可接受取舍。不可概括成“独立 SWA 冗余，删掉完全无损”。

17.4 Bridging 的规模实验

290B-A8B、约 1.8T token、32k 的 Bridging 消融显示总体可比，但有任务得失：MMLU 72.68 到 72.80，TriviaQA 73.32 到 74.10，LongPPL 3.6053 到 3.4202；DROP 71.37 到 68.17，GSM8K 77.63 到 76.65，RULER 96.32 到 96.01。

这支持“主要为缩短 Prefill 依赖而设计，并能在该规模保留总体质量”，不支持任意改造都无损。

17.5 Bridging 与 KV Mirror

KV Mirror 采用早晚层反向配对的 U 形连接；两者都通过源 hidden 重投影形成目标 KV。论文比较中 Bridging 的 RULER 最终为 87.65，Mirror 为 81.28。

作者假设 FA 输入受到覆盖更广的注意力反向梯度监督，适合作为投影源。但这只是机制解释：FA 输入受到全局训练监督，不等于它已经在当前前向中经过这个 FA 的全局聚合。

17.6 主实验的长上下文优势

相同轻量后训练后，相对 HySparse，平均 MRCR-v2 和 RULER-v2 提升 11.30 和 19.81 点；256k 的 RULER-v2 为 58.45，对照 HySparse 32.61、Hybrid SWA 35.74。AgentPPL 与 LongPPL 曲线也更好。

这些应与训练数据、模型配置、评价长度共同陈述，不可单凭某个开关的结果解释全部主实验增益。

18. 理论支持是什么、没有证明什么

共同的设计来源是层间重要 token 稳定性和 KV 共享的经验可行性。少数 FA 负责刷新检索，后续 SA 复用资料但保留各自的 Query/MoE 深度。

配套 HySparse 文档完整推导了一个解释性界：若 Value 范数至多为 ，保留集合漏掉概率质量为 ，则固定 Query/KV 的重新归一化输出满足：

若后层完整注意力分布与源层总变差至多为 ，则在相应条件下：

这是聊天中的补充分析，不是作者给出的质量保证。它没有覆盖 KV 表示替换、全部层误差传播或最终答案正确性。

需要特别区别：

• 计算图可精确早退：同一 HySparse2 中，不计算无依赖的历史 Reader 不改变需要的数学结果。
• 架构改造质量保持：HySparse 变 HySparse2、独立 SWA 改 Forced window 是否影响任务质量，只能由实验回答。

前者不能替代后者。论文也没有证明无需重训便可把任意现有混合模型改造成 HySparse2。

19. 今天各个追问的直接答案索引

原问题	直接答案	正文
“架构、PD 计算流水线、与 HySparse 区别”	Self 建记忆、Cross 分组复用；阶段分离另行部署	§3–5、§11–17
“作者如何发现有效，理论支持是什么”	经验稳定性、KV 冗余、原生训练和消融；无普遍质量定理	§18、配套文档 §10–12
“SA 依赖 Self FA + SWA 两套 KV 吗”	不是；使用 Self 源 hidden 经 Cross 投影构建的组内 KV	§4、§6
“历史位置不经过 Cross 是什么意思”	不算历史 Reader，但历史 Cross KV 仍构建	§8–9
“与 YOCO、DeepSeek 一样吗”	共同思想相近；是否保留本层历史依赖决定尾部开销	§14
“先解释 PD 分离”	按请求阶段分，通常不是按层切分	§11
“结合 HySparse2 解释 PD”	P 可缩成 Self + 投影；独立 D 仍运行完整模型	§12–13
“Cross 没有 SWA，为什么还有两类位置”	删除独立分支，不删除局部需求；两类索引访问同一份缓存	§7

20. 对历史表述的澄清记录

1. “跳过全部 Cross Prefill”严格指全序列记忆构建路径，不免除首 token 的最后位置 Cross 读出。
2. “共享来自 Self 的 KV”应读作“由 Self hidden 经 Cross 投影生成”，不是直接复用 Self FA/SWA KV。
3. “最近 128”是强制访问集合，不是 Cross replay 长度，也不是另建局部 cache。
4. “所有 SA 共享 KV”仅在所属组内成立；四个 Cross FA 仍拥有四份不同缓存。
5. “索引共享”沿组内层深共享当前 Query 的选择，不跨所有生成时刻固定不变。
6. “Writer 可并行”是源输入就绪后的依赖解耦，不保证硬件并行收益；Reader 仍沿层串行。
7. “早退精确”不代表架构替换质量无损；两类结论分别论证。
8. “2.92 倍”是 Prefill FLOPs 口径，不是端到端 latency 实测。
9. “更小 KV”不能全部归因于 Bridging；对照的头数和维度是主要因素。
10. “局部窗口重放”不能在未验证边界状态时当作精确恢复。
11. 历史 source hidden 图是依赖示意，不是官方配置文件；具体桥接映射应保留论文图的区别。
12. PD 交接字段和分块重叠是系统推导；论文未来的 drafter/异步执行不是已验证部署。

21. 来源

• HySparse2：§3 架构和推理部署，§4 实验和消融。
• HySparse：第一代双分支与经验动机。
• YOCO：共享全局 KV 与后半模型早退的计算依赖。
• SGLang PD 文档：P/D 服务阶段分离的通用背景。
• 此前 DeepSeek 整体架构整理：DeepSeek-V4.1-Flash 整体架构。用于关联之前讨论；本文没有修改该文件。

---

附录 A：今天全部三轮技术问答，按时间保留

说明：以下保存全部技术问题和最终回答，不把工具执行日志、内部推理或简短进度通知混入技术正文。原始公式统一为 $...$ 和 $$...$$；Mermaid 源码保留，不额外转成 PNG。正文补充的边界不回写到历史回答中，因此可以同时看到原始解释和后续澄清。第一轮中的第一代讲解、数学支持和与 KDA 的关联也全部保留。

A.1 第 1 轮：13:02–13:10

用户原问题

解读：arxiv.org/pdf/2609.26368 包括架构、pd计算流水线等等并且解释和hysparse的区别。并且分析作者是如何发现hysparse的架构是有效的？换句话说理论支持hysparse是啥？为啥能想到？

当时的完整回答

这篇是小米的 HySparse2: Hybrid Sparse Attention with Two-Level KV Sharing。它与我们前面讨论的 Writer–Reader 分离非常接近，但又多了一层“直接共享 KV”。

先给出最重要的结论：

HySparse2 把后半模型的 KV 构建提前到前半模型，并让一组稀疏层共用 KV 和检索位置；同时移除后半模型独立的局部 KV 分支，使历史 prompt 不再需要经过后半模型。

它不需要我们之前讨论的“最后 100-token”依赖补齐，因为后半模型没有类似 Q 短卷积或独立 SWA KV 的历史 hidden 依赖。

下面依据 HySparse2 原文 HySparse2 原文，并对照 HySparse 原文 HySparse 原文 分析。会明确区分论文事实、计算图推导和作者尚未验证的设想。

一、先理解 HySparse：一层找信息，后面几层重复加工

HySparse 的基本单元是：

Full Attention，下面简称 FA，做三件事：

1. 构建本组的完整 KV。
2. 正常执行全注意力，生成本层输出。
3. 根据注意力分数，选出重要的历史位置。

后续 Sparse Attention，简称 SA，复用：

但每个 SA 层仍然生成自己的 Query、重新计算注意力权重，并执行自己的输出投影与 FFN/MoE。

因此：

复用的是记忆和候选位置，不是复用 attention 输出，更不是跳过整层。

1. 同一份记忆，可以被不同层反复读取

设 FA 生成：

并为当前位置 选出索引：

后续第 个 SA 层执行：

虽然 一样，但：

所以各层可以从相同候选资料中提取不同信息。

2. 第一版还保留独立 SWA 分支

第一版每个 SA 层实际包含两条路径：

• 全局稀疏路径：读取前面 FA 的 KV。
• 局部 SWA 路径：使用本层自己生成的局部 KV。

两条路径分别计算注意力，再通过门控融合。

第一版默认选择 16 个、每个包含 64 token 的块，合计 1024 个全局 token；局部窗口为 128。

这个独立的局部 KV 分支，后来成了完整 Prefill 早退的障碍。 HySparse §3

---

二、HySparse2 的完整架构

1. 49 层怎么分？

论文图 2 的模型可以分成：

部分	结构	层数
Self-Decoder	个 SWA → 个 FA → 个 SWA	25
Cross-Decoder		24
合计	SWA、 FA、 SA	49

这里的 Self-Decoder 相当于我们之前说的“因果 Encoder”，不是双向编码器。

图中省略各层的残差、归一化和 MoE：

flowchart TD X["输入 token / Embedding"] --> S1["Self-Decoder：12 × SWA"] S1 --> HA["源表示 A：Self FA 的输入"] HA --> SF["1 × Full Attention"] SF --> S2["12 × SWA"] S2 --> HB["Self-Decoder 输出 / 分界表示"] HA -.-> SRC["按桥接映射选取源 hidden，不是直接复制源层 KV"] HB -.-> SRC SRC --> WP["4 组独立 K/V 投影"] WP --> MEM["4 份 Cross-Decoder Global KV"] HB --> C1["Cross Block 1：FA → 5 × SA"] C1 --> C2["Cross Block 2：FA → 5 × SA"] C2 --> C3["Cross Block 3：FA → 5 × SA"] C3 --> C4["Cross Block 4：FA → 5 × SA"] C4 --> OUT["输出头"] MEM -.-> C1 MEM -.-> C2 MEM -.-> C3 MEM -.-> C4

图里的两类源表示，是为了强调：**不能把全部桥接理解成“统一从最后一份 生成”。**正文用对应 FA 的输入 hidden 定义 Bridging；原图连线还包括 Self/Cross 分界处的 hidden。具体层对层连接应按图示或实现配置理解。

2. 第一层共享：KV Bridging——共享来源，不共享结果

对某个 Cross FA 层 ，它的 K/V 来自前半段的源表示：

但 Query 仍来自本层正在执行的 hidden：

两个 Cross FA 即使读取同一个源 hidden，因为投影权重不同：

仍然得到不同的 KV。

这一层正是我们讨论的“共享 hidden，各自独立 Writer”。

3. 第二层共享：KV Reuse——直接共享同一份 KV

每个 Cross FA 后面的 5 个 SA 层，不再独立构建全局 KV，而是直接读取这个 FA 的缓存。

所以：

• 4 个 Cross FA 之间：KV 独立。
• 同一个 FA 与后续 5 个 SA：共享一份 KV。
• 后续 5 个 SA 还共享该 FA 为当前 query 选出的索引。

这两种机制的区别非常重要：

机制	共享什么	还需独立构建 KV 吗？
KV Bridging	前半模型的源 hidden	每个 Cross FA 仍需要
KV Reuse	已经生成的 KV，以及选择索引	后续 SA 不需要

HySparse2 §3.2–3.3

---

三、为什么删除独立 SWA，就能彻底省掉尾部 replay？

1. 第一版的局部 KV 依赖本层历史 hidden

第一版 SA 的局部路径需要：

要给第 层构建最后 128 个位置的局部 KV，就必须先算出这些位置的 。

而这些 hidden 又依赖前面层更早的位置。

因此：

局部窗口只有 128，不代表只补算 128 个输入位置，就能精确恢复所有深层局部缓存。

这与我们之前推导 KDA Query 卷积的“逐层扩大的历史依赖”是同一类问题。

2. HySparse2 不再生成这份独立局部 KV

它改成：

从同一份共享 Global KV 中，强制选入最近 128 个位置，再选入窗口外最重要的 1024 个位置。

可以表示为：

随后 SA 层使用自己的 Query，对这组 KV 重新计算注意力。

这里的 128 是：

不是：

3. 两种“局部注意力”不是同一个计算图

第一版：

第二版：

不仅 KV 来源变了，注意力归一化和融合方式也变了。

因此它不是“删掉一份完全重复的缓存”，而是改变局部信息的表示和读取方式，以换取更简单的计算依赖。

---

四、Prefill：哪些计算执行，哪些跳过？

这里必须区分：

1. 构建未来生成所需的缓存。
2. 计算首个输出 token 的概率。

论文说“跳过全部 Cross-Decoder Prefill”，主要是在讲第一件事。

1. 对全部 prompt 执行 Self-Decoder

输入长度为 ，前 25 层正常处理全部位置。

得到：

• 24 个 SWA 层的局部缓存；
• 1 个 Self FA 的全局 KV；
• Bridging 所需的源 hidden；
• Self-Decoder 最后位置的输出表示。

2. 在前半段构建 4 份 Cross KV

对全部位置的源 hidden，执行 4 组 Cross FA 的 K/V 投影：

这四组投影在输入就绪后相互独立，可以独立调度。

但必须注意：

只是构建 Cross KV，不需要对全部 prompt 执行 Cross FA 的 Query、attention 或 MoE。

20 个 SA 直接复用上述缓存，也没有额外的历史局部 KV 要构建。

3. 为首 token，只运行最后位置的 Cross-Decoder

如果要预测：

仍要让最后位置 的分界表示，经过后面 24 层和输出头。

每个 Cross FA：

• 生成当前位置的 Query；
• 读取自己的完整历史 KV；
• 正常执行全注意力；
• 选出当前位置的稀疏索引。

后面 5 个 SA：

• 使用自己的 Query；
• 读取相同候选位置；
• 完成本层输出与 MoE。

这 24 层仍然沿深度串行。

但位置 不需要经过它们。

4. 为什么这里不需要“最后 100-token”？

给定已经构建好的记忆，第 个 Cross 层可以写成：

它不再需要：

来生成本层局部 KV 或做 Query 短卷积。

因此，为了计算最后位置，可以逐层只保留这个位置。

这是计算图带来的精确省略，而不是用一个有限窗口近似历史。

注意：训练时若要计算所有位置的语言模型损失，仍需执行所有位置的 Cross 读出；这个推理收益不等于训练计算也减半。

---

五、Decode：每个新 token 怎么走？

Decode 并不是只执行后半模型。

每个新输入 token，都需要：

步骤 1：执行 Self-Decoder

经过前 25 层，更新：

• Self SWA 的滚动窗口；
• Self FA 的全局 KV。

同时产生这个新位置的桥接源 hidden。

步骤 2：给四份 Cross KV 各追加一个 entry

这些 K/V 的生成不需要等待对应 Cross FA 的 hidden。

步骤 3：执行四组 Cross block

每组都是：

这里有两个容易混淆的地方：

第一，桥接的是 KV 来源，不是注意力分数。

Cross FA 的选择索引，要由它自己的当前 Query 计算，不能简单拿 Self FA 的索引替代。

第二，索引是当前 query 的临时计算结果。

下一 token 的 Query 变了，就要重新选择；不能把某次 Top-K 当作所有未来 token 的固定缓存内容。

Decode 仍有随上下文增长的全局读取

忽略维度常数，49 层图示架构的 attention 核心工作量可以粗略理解为：

其中：

所以它不是完全固定成本的 Decode：

• 5 个 FA 仍然读取不断增长的历史；
• SA 和 SWA 部分的访问范围较小。

---

六、PD 分离如何部署？传输什么？

1. 论文明确提出的部分

Prefill 节点只需要部署：

不需要放置完整的后 24 层 Reader 和 MoE 权重。

Cross KV 在 P 节点投影好后再传到 D 节点，论文给出的理由是：投影后的 KV 比对应源 hidden 更紧凑。 HySparse2 §3.5

2. PD 分离不是 Self/Cross 模型切分

不能据此理解成：P 节点永远运行前半，D 节点永远只运行后半。

普通 PD 分离下，D 节点在后续生成时还要处理每个新 token 的 Self-Decoder，所以仍需要完整模型能力。

如果让 P 节点持续负责生成期间的前半模型，那变成了另一种跨节点模型流水线部署，会有逐 token 通信；不是单纯的 PD 分离。

3. 一条完整的交接流水线

下面把论文的部署设想与正确执行必需的数据交接画在一起。具体网络调度属于系统实现推导，论文没有给出完整调度器。

sequenceDiagram participant P as Prefill 节点 participant N as 缓存传输 participant D as Decode 节点 P->>P: 全部新输入执行 Self-Decoder P->>P: 源 hidden 就绪后构建 4 份 Cross KV P->>N: 发送就绪的 KV / 状态 N->>D: 安装缓存及位置元数据 P->>D: 最后位置的分界表示 D->>D: 最后位置执行 24 层 Cross-Decoder D->>D: 输出头与采样，得到首 token loop 后续生成 D->>D: 新 token 执行 Self-Decoder D->>D: 更新 Self 缓存与 4 份 Cross KV D->>D: Cross FA 选位置，SA 复用并读出 D->>D: 输出头与采样 end

若 D 节点要独立继续生成，除论文着重提到的 Cross KV 外，还需要能访问：

• Self FA 的全局 KV；
• Self SWA 的窗口状态；
• 最后位置的分界表示，必要时包括残差流表示；
• 序列位置、缓存映射、量化参数等元数据。

这部分是由正确执行要求推导出来的，不应误称为论文已经实现的传输协议。

4. 哪些地方可以流水化？

从依赖关系看，可以探索：

• 源 hidden 分块就绪后，立即执行对应 Bridging 投影；
• KV 分块生成后开始传输；
• 前半段后续计算与部分投影、传输重叠。

但这些只是可实现的机会，是否获益取决于算力、带宽和同步开销。

论文还讨论了利用分界 hidden 做更大的投机解码 drafter，但大 drafter 训练及异步协调属于 future work，不能当作已经验证的 PD 流水线性能。

---

七、与 HySparse 第一版的本质区别

维度	HySparse	HySparse2
总体结构	FA 与 SA 分组交替	Self-Decoder＋Cross-Decoder
全局 KV 构建来源	各组 FA 的本层输入	Cross FA 从前半模型源 hidden 构建
组内共享	FA 向 SA 共享 KV 和索引	保留
选择粒度	64-token block	单 token
局部信息	独立 SWA KV＋独立 attention 分支	强制把局部窗口加入共享 KV 的选择
历史 Cross hidden	仍参与后续缓存构建	不参与 Cross KV 构建
缓存构建 Prefill	仍需跑完整骨干	可在 Self-Decoder 后退出
后半模型尾部恢复	存在局部历史依赖	无独立局部缓存依赖
本文实验中的 KV heads	GQA，4 个	MQA，1 个

一个重要的性能归因问题

论文在 1M 长度、FP8 KV 口径下报告：

• HySparse2：2.69 GB；
• HySparse：6.72 GB；
• Hybrid SWA：12.09 GB。

同时报告 Prefill FLOPs 相对 HySparse 降低约 ，相对 Hybrid SWA 降低约 。

这不是实测 TTFT 或吞吐加速倍数。

而且，HySparse2 相比 HySparse 的缓存减少，不能全部归因于新引入的 Bridging。

两者在这组实验中都有 5 份全局 KV。区别之一是：

因此全局缓存部分的比例就是：

这与：

基本吻合。

所以，Bridging 的突出贡献是缩短 Prefill 计算依赖；这组对比中进一步缩小缓存的主要数值来源，是 KV 头数和维度配置的变化。 HySparse2 表 1、图 4

---

八、作者为什么能想到 HySparse？它的理论依据是什么？

先直接回答：

HySparse 主要建立在经验观察、已有架构结果和消融实验之上，不是先证明了一个“共享之后一定不掉质量”的定理，再据此设计模型。

原文明确给出两条来源：

1. 相邻层的重要 token 具有一定稳定性。
2. 跨层共享 KV 在已有实验中可行。

下面把这条思路展开。

1. 第一条观察：相邻层经常在看相似的资料

假设某个 query 在第 层主要关注：

• 函数定义；
• 某个变量；
• 前面一段关键证据。

下一层虽然继续加工 hidden，但不一定立刻换成完全不同的资料。

因此可能存在：

这不是 HySparse 首次观察到的。它引用了 TidalDecode、OmniKV 等工作。

例如 TidalDecode 直接分析了层间高分 token 的重叠，并发现需要在中间层重新选择；远距离层之间并不保证一直稳定。这支持的是“在一段层范围内复用，然后刷新”，不是“整个模型永远用同一组选中 token”。 TidalDecode §3.1

由此自然产生一个问题：

既然少数 FA 层已经付出全局扫描成本，为什么不让后面几层复用它找到的位置？

2. 第二条观察：不仅索引有冗余，KV 表示也有冗余

如果只共享索引，每个 SA 层仍然保存全长 KV：

那主要减少的是读取计算，缓存容量不一定下降。

CLA、YOCO 等工作说明，可以在训练中让多个层共享记忆，仍保留不同的 Query 和后续变换；MiniCache 则从压缩角度观察到相邻中深层 KV 的相似性。 CLA、MiniCache

于是设计进一步变成：

不仅重复使用“去哪找”，还重复使用“被查询的那份资料”。

但注意：**原模型 KV 相似，只是设计启发，不证明直接替换一定无损。**原生训练允许模型主动适应共享约束，这是很重要的一步。

3. 为什么共享 KV 后，深度仍有意义？

因为记忆不变，并不意味着查询过程不变。

可以把一组层理解成：

• 第一个 FA：全局找资料；
• 后续 SA：围绕这些资料进行多步加工；
• 下一组 FA：根据已经更新的 hidden，重新全局检索。

每一步仍然有独立的：

所以保留下来的是：

被限制的是：

是否值得这个取舍，最终需要训练结果回答。

4. “Oracle”不能理解成对所有后层绝对正确

FA 得到的是：

对它自己的 Query 和 KV，精确计算出来的注意力分数。

但是下一层 Query 已经变化，所以前一层的 Top-K 不一定是下一层的最优 Top-K，更不保证它是任务答案的最优证据集合。

因此，Oracle 更准确的含义是：

不使用额外近似 indexer 去预测源 FA 的注意力，而是复用源 FA 实际计算的分数。

它没有消除跨层复用本身的近似和限制。

---

九、可以怎样用数学解释“为什么可能有效”？

下面是我补充的条件化解释，不是 HySparse 论文给出的定理。

1. 稀疏读取是否准确，关键看漏掉多少注意力质量

先看单头、固定 K/V 的普通 attention：

选择位置集合 ，丢掉的概率质量为：

对保留位置重新归一化：

若：

则可得：

它的直观含义是：

若被保留的少量 token 已经承载了绝大部分 attention 权重，那么去掉其余位置，对当前 attention 输出的影响可以很小。

这只是当前算子的界，不是整个模型最终答案的保证。

2. 跨层复用索引，需要再加一个“分布变化不大”的条件

设源层注意力分布为 ，后续层假想的完整注意力分布为 。

如果两者的总变差距离满足：

而源层选出的集合漏掉的质量是 ，那么后层在同一集合外的质量至多为：

因此，类似地可以得到：

这说明 HySparse 的合理性依赖于两个条件：

1. 注意力本身足够集中；
2. 一组层之间的关注分布变化不太大。

也解释了为什么要定期插入新的 FA：重新全局选择，限制选择结果随层深变得不合适。

但真实模型还有多头聚合、KV 共享引入的表示变化、门控和后续非线性，这个小推导并不能覆盖全部误差。需要测量的是实际保留质量、输出偏差和任务指标，而不只是 Top-K 集合重叠率。

---

十、作者通过什么实验确认设计？哪些结论不能过度解读？

1. 第一版不是“一开始就知道局部路径可以省”

HySparse 的消融显示，在相关 7B 实验中：

• 加入独立 SWA，GSM8K 从 29.7 到 37.7；
• 让 SA 和 SWA 都共享 KV，相比只让 SA 共享，GSM8K 从 36.7 降到 30.2。

所以第一版得到的是：

在当时的配置中，独立局部路径有价值，最大化共享会损害质量。

这属于受配置限制的实验结论，不是“局部 KV 永远不能共享”的定理。 HySparse 表 4

2. 第二版并没有证明删除独立 SWA 完全无损

HySparse2 对比独立 Gated SWA 与 Forced SWA：

• Forced SWA 在部分检索、图推理指标更好；
• 但 GSM8K 下降 5.08 点；
• MRCR-v2 下降 4.99 点。

作者认为，换来更少参数、更简单缓存和完整 Prefill 早退，这是可以接受的取舍。

因此，两篇论文并不矛盾：

第一版验证了独立局部表示的价值；第二版选择牺牲一部分局部表达自由度，换取更大的系统收益。

3. token-level 的优势来自更细的预算分配

固定选择 1024 个全局 token：

• block-level：最多选 16 个长度 64 的块；
• token-level：可以把预算分散给大量不同位置。

若多个重要标识符、角色边界、工具结果分散在不同块里，block-level 会把预算花在大量邻居上。

论文的消融支持 token-level 在相关长上下文任务上更好，但这并不意味着所有一般能力指标都同步上升。

4. 为什么选 FA 输入 hidden 做 Bridging？

作者给出的解释是：

FA 的训练梯度通过全局可见的注意力连接传播，使其输入表示受到更全局的监督；SWA 的直接连接范围更局部。

这是一个机制假说。Bridging 相比 KV Mirror 的实验支持这个连接选择，但没有排除所有其他因素。

特别注意：

“FA 的输入 hidden 受到全局训练监督”，不等于“它在本次前向中已经经过这个 FA 的全局聚合”。

输入和输出不能混淆。

5. “有效”也不等于全面无代价

HySparse2 的结果主要支持：

• 更低的 Prefill 计算预算；
• 更小的缓存；
• 在其长上下文、Agent 数据与评测设置中更强的表现；
• 一般能力整体接近，但存在任务间得失。

它没有证明：

• 任意已有模型都能无训练改成这个架构；
• 任意共享比例都有效；
• FLOPs 降低必然转化为同倍延迟降低；
• 当前 PD、异步投机解码方案已经获得端到端系统实测加速。

---

最后，联系你的 MLA–KDA CED 想法

HySparse2 给你的最直接启发不是“所有记忆都共享”，而是把三个设计问题分开：

1. Writer 输入从哪里来？
   Bridging：从前半模型拿 hidden，让 Writer 提前可执行。

2. 多少层共用一份记忆？
   Reuse：减少独立 Writer 和缓存副本。

3. Reader 是否还依赖本层历史 hidden？
   这决定能否只算最后位置，还是需要 100-token 之类的依赖补齐。

你的原方案保留本层 Q 短卷积，所以第三项依赖仍在。

HySparse2 则把后半段的局部信息需求也改成了读取前半段生成的记忆，从计算图上去掉这条历史 hidden 依赖。

可以把整条研究思路概括为：先利用层间冗余少建记忆、少做检索，再切断历史 hidden 对未来缓存构建的依赖，最终让大部分历史 Reader 变成真正可以不执行的计算。

---

A.2 第 2 轮：13:47–13:49

用户原问题

以下部分没看懂：1、hysparse2删除了独立SWA的kv Cache，SA的kv依赖是self-decoder中的FA+SWA的两套独立kv cache吗？ 2、prefill跳过Cross-Decoder 是啥意思？位置 不需要经过它们。是啥意思？和之前的yoco、deepseekv4.1flash一样吗？ 3、PD 分离不是 Self/Cross 模型切分。我不懂PD分离，先解释下PD分离，再结合hyspase2解释

当时的完整回答

你这里混在一起的是三个不同概念：

• KV 从哪里生成：从 Self 的 hidden 生成，不等于直接使用 Self 的 KV。
• 跳过哪些计算：跳过历史位置在 Cross 中的完整前向，不是跳过历史位置的 KV 构建。
• PD 怎么分工：按“处理提示词”和“逐步生成”分工，不是按模型前后两半分工。

下面逐个拆开。

1. SA 读取的是 Self-Decoder 中 FA 和 SWA 的两套 KV 吗？

不是。SA 读取的是它所属 Cross-Decoder 分组的 FA KV；这份 KV 是利用 Self-Decoder 的 hidden，重新投影出来的。

1.1 先区分三类缓存

缓存	如何生成	谁使用
Self 中 FA 的 KV	Self FA 自己的输入 hidden，经自己的 K/V 投影	Self FA
Self 中每层 SWA 的 KV	该 SWA 层的输入 hidden，经自己的 K/V 投影	该 SWA 层
Cross 分组的共享 KV	指定的 Self hidden，经该 Cross FA 的 K/V 投影	该 Cross FA，以及同组后续 SA

因此，“桥接”传递的是构建记忆的输入来源，并不是把 Self 的两套 KV 搬给 Cross。

用简化公式表示，第 个 Cross 分组的缓存为：

这里：

• ：该分组对应的 Self 侧源 hidden；
• ：Cross 分组自己的投影参数；
• ：新生成的 Cross KV。

即使两个 Cross 分组使用同一个源 hidden，投影权重不同，生成的 KV 也不同。论文中的四个 Cross 分组不是共用唯一一份 KV，而是各自有一份。HySparse2 §3.2

1.2 删除独立 SWA 后，“最近的 token”从哪里读？

仍然从这一份 Cross KV中读。

可以把它理解成一个数组：

SA 访问这个数组时，选出两类位置：

然后使用本层 Query 做注意力：

局部窗口和远处检索，是同一份缓存的两种取索引方式，不是两份不同缓存。

例如，缓存有 个位置：

• 最近一段位置直接选入；
• 较早位置中，再选相关性高的；
• 从同一个 KV 数组中取出这些条目，一起参与注意力。

HySparse2 的配置是强制保留最近 个位置，并从窗口外选择 个全局位置；后续 SA 复用所属 FA 的选择结果。HySparse2 §3.3、§4.1

所以，准确说法是：

删除的是 Cross SA 原本独立维护的 SWA 分支及其缓存；Self-Decoder 的 SWA 缓存仍然存在。

---

2. “Prefill 跳过 Cross-Decoder”到底跳过了什么？

跳过的是 prompt 大部分位置在 Cross 中的 Query、注意力读出、MoE 等计算；不是不为这些位置生成 Cross KV。

用四个 prompt token 举例：

现在要生成第一个回答 token 。

2.1 首先，四个位置都运行 Self-Decoder

得到 Self 侧的各类缓存和源 hidden：

接着通过桥接投影，为 Cross 构建覆盖四个位置的 KV：

注意：

位置 没有经过 Cross 的完整 Transformer 层，但它们已经在 Cross KV 中有对应条目了。

2.2 然后，只让位置 4 的 hidden 经过 Cross 各层

为了预测 ，我们需要位置 的最终输出：

不需要计算位置 的 Cross 最终输出。

用表格看更清楚：

prompt 位置	执行 Self 完整前向	构建对应的 Cross KV	执行 Cross 完整前向
	是	是	不需要
	是	是	需要，用来预测首个回答 token

因此，我之前如果直接说“Cross 完全不运行”，不够严谨。应该说：

全序列的 Prefill 缓存构建可以在 Self 后结束；产生首个回答 token 时，最后一个 prompt 位置仍然必须经过 Cross。

这最后一次 Cross 计算可以放在 Decode 节点上，作为生成启动步骤。不能因为把它划到 Decode 阶段，就认为这部分计算消失了。

2.3 为什么普通模型不能这样做？

普通 Transformer 的某个深层历史 KV 通常依赖该层的历史输入：

要得到它，位置 就必须先经过前面的深层计算。

而桥接之后：

Cross 的历史 KV 不再依赖历史位置的 Cross hidden。

所以，跳过历史 Cross hidden 的计算，不会导致未来缺少 KV。这就是提前退出成立的依赖关系。

同时，当前最后位置在 Cross 的各层之间仍然串行：

跳过历史位置，不等于各层并行。

2.4 和 YOCO、DeepSeek V4.1 Flash 一样吗？

大方向一样，具体依赖不同：

架构	共同点	关键区别
YOCO	后半模型的历史 KV 来自前半模型	Cross 层共享全局 KV，历史位置不必执行 Cross 完整前向
HySparse2	同样切断后半模型历史 KV 对自身 hidden 的依赖	Cross 按组共享 KV，并采用稀疏读取；局部位置也从共享 KV 读取
前面讨论的 V4.1 Flash CED	同样把全局记忆构建提前	Decoder 还保留逐层局部 SWA 状态，因此仍有尾部状态恢复问题

YOCO 的这条依赖关系在其 Cross-Decoder 公式中非常直接：共享 KV 来自 Self 输出，Query 来自当前 Cross 层。YOCO §2.2–2.3

HySparse2 特别强调，独立 Cross SWA 会引入沿深度扩大的历史依赖；移除它才能消除这条依赖。论文把 bounded replay 列为保留该依赖时的一种近似处理方式，所以不能把“只回放一个窗口”直接当成一般意义上的精确等价执行。HySparse2 §3.3

---

3. 先解释 PD 分离：它到底在分什么？

先暂时忘掉 Self/Cross。

3.1 一个请求有两个阶段

假设用户输入 个 token，模型回答 个 token。

Prefill：处理已经知道的输入。

输入的 个 token 都已给定，因此可以批量计算，建立它们的缓存，并通常计算首个回答 token 所需的输出。

Decode：继续生成尚不知道的输出。

采样出第一个回答 token 后，把它输入模型，生成第二个；再把第二个输入模型，生成第三个：

普通自回归生成中，下一步输入依赖上一步采样结果，不能像已知 prompt 一样把所有未来 token 直接批量送入。

3.2 PD 分离就是让两组计算资源分别负责这两个阶段

典型部署是：

资源	工作
P worker	接收新 prompt，完成 Prefill
D worker	接收该请求的缓存，继续逐 token 生成

这里的 worker 可以是一张 GPU，也可以是一组 GPU。

对于普通 Transformer：

• P worker 部署完整模型；
• D worker 也部署完整模型；
• P 算好 prompt 的 KV，传给 D；
• D 不需要重算 prompt，只需继续生成。

为什么值得分开？

因为长 prompt 的大批量计算和逐 token 生成的运行特点不同。混在一起时，一个大 Prefill 可能拖慢正在输出的请求；分离后，可以分别安排批大小、资源数量与调度策略。当然，缓存传输会带来额外成本。SGLang PD 分离文档

3.3 为什么说它不是 Self/Cross 切分？

因为切分的轴不同：

切分方式	按什么划分	一个新生成 token 怎么运行
PD 分离	请求的处理阶段	在 D worker 上完成所需的完整模型计算
前后层切分	模型深度	先到前半模型所在设备，再到后半模型所在设备

例如，假设把 Self 放设备 A、Cross 放设备 B：

这属于按层切分的流水线执行，不是仅凭这个安排就叫 PD 分离。

PD 则是：

P 负责把请求“启动好”，D 接手后负责持续生成。

P 不需要为同一个请求的每个生成 token 都再工作一次。

---

4. 把 PD 分离套到 HySparse2 上

HySparse2 的特殊之处是：

普通模型的 P 通常需要完整模型；HySparse2 的 P 可以只部署 Self 和桥接投影。

论文明确给出：其 层模型的 P 节点只需前 层以及 KV Bridging 投影；Cross KV 在 P 上生成后传给 D，因为投影后的 KV 比源 hidden 更小。HySparse2 §3.5

下面是按依赖关系展开的一种完整交接流程；其中具体通信字段属于实现设计，而不是论文公布的完整协议。

第一步：P 处理全部 prompt

P 执行：

同时用桥接投影构建 Cross 各组的完整 prompt KV。

此时不用让全部 个位置经过 Cross。

第二步：P 把继续生成所需状态交给 D

为了让 D 独立继续，所需状态包括：

• Self FA 的历史 KV；
• Self 各 SWA 层的窗口 KV；
• Cross 各组的历史 KV；
• 最后一个 prompt 位置的 Self 边界 hidden；
• 序列长度、缓存映射等元数据。

不仅要交 Cross KV：后续新 token 还要运行 Self，所以 Self 的历史状态也不能缺。

第三步：D 完成最后位置的 Cross，生成首 token

P 已经计算了位置 的 Self 部分，因此 D 可以接着执行：

这一次不必重新运行位置 的 Self。

第四步：之后每个新 token 都需要 Self + Cross

当 已经采样出来，预测 时：

后续重复这个过程。

因此，如果 D worker 要独立完成后续生成，它就仍然需要 Self + Cross 的完整计算能力，而不能只部署 Cross。

最终可以把两边记成：

	P worker	独立完成生成的 D worker
部署什么	Self + 桥接投影	Self + Cross + 桥接投影及输出头
处理什么	全部 prompt 的记忆构建	首次完成最后位置的 Cross；之后处理新 token
是否每个生成 token 都参与	否	是

一句话总结：HySparse2 不是“P 跑前半模型、D 永远只跑后半模型”，而是“P 只跑前半就能备齐历史记忆，D 随后用完整模型持续生成”。

---

A.3 第 3 轮：19:03

用户原问题

cross decoder里没有SWA，为啥SA还需要选出两类位置？

当时的完整回答

因为**“有一个独立 SWA 分支”和“保证能看到最近的 token”**是两回事。

HySparse2 删除的是前者，保留了后者。

1. 没有 SWA 分支，不等于不关注局部信息

假设当前位置是第 个 token。

如果 SA 只按相关性取全局 Top-，可能选出：

但是，最近几个 token 不一定都能进入 Top-。

这会带来问题：模型可能检索到了前文相关事实，却漏掉当前句子里的否定词、变量名、标点或者刚刚生成的内容。

因此，HySparse2 使用一个选择规则：

最近的 token 无条件保留；更远的 token 按相关性选择。

这是为了同时保证局部连续性和远程检索能力，不是为了维护两套缓存。

2. 两类位置，来自同一份 KV

设当前位置为 ，局部窗口为 。

第一类是强制选入的近期位置：

第二类是窗口外按相关性选出的远程位置：

最终的访问集合是：

**两类位置都从所属 Cross FA 的同一份 KV Cache 中取数据。**论文配置为 个强制局部位置，加上 个窗口外位置；同组 SA 复用 FA 的选择结果，并不是每个 SA 都重新选。HySparse2 §3.3、§4.1

这里的 是用于选择的相关性分数。忽略输出门等细节，SA 的核心计算可以写为：

注意：局部位置和远程位置一起参加同一次注意力归一化，不是分别运行一个 SWA 和一个 SA，再把两个输出相加。

3. 和“独立 SWA 分支”区别在哪？

对比项	独立 SWA 分支	HySparse2 的强制局部窗口
最近 token 的 KV 从哪里来	本层 hidden 生成的局部 KV	所属 Cross FA 的共享 KV
是否维护单独的局部缓存	是	否
如何实现局部关注	单独运行局部注意力分支	把近期位置强制加入 SA 的访问集合
是否依赖历史位置的本层 hidden	是	否

所以，你可以把 HySparse2 的 SA 理解为：

一个稀疏注意力操作，访问位置由“必选的近期 token”和“择优选择的远程 token”组成。

它在访问模式上有滑动窗口特征，但在模型结构上没有独立 SWA 分支，也没有该分支自己的 KV Cache。

这也解释了为什么它仍能跳过历史位置的 Cross 计算：即使访问最近的 token，读到的也是由 Self hidden 构建的共享 KV，不需要先计算这些历史 token 的 Cross hidden。

---