将注意力偏置折叠至键中使压缩 KV 缓存运行于标准内核

1. 问题与价值

这篇论文解决的核心问题是：Attention Matching（AM）这类 KV cache 压缩方法会产生一个“带偏置的 cache”，而现有推理引擎的标准 kernel 无法直接消费这种 cache。

具体来说，AM 在压缩 KV cache 时，每个保留的 key 除了原来的注意力 logit q·k_j/√d 之外，还附加了一个标量偏置 β_j。这个偏置是 AM 拟合出来的，用来让保留的 key 承载被丢弃 key 的注意力质量。问题在于：FlashAttention、vLLM 的 paged cache、prefix cache、KV transfer 等标准基础设施都只接受“纯 key 和 value 张量”，没有地方放这个额外的偏置项。PyTorch 的 flash backend 直接拒绝任何加性 mask。

这个问题的价值在于：AM 及其后继方法（ARC-KV、TAM、Latent Compaction、KV-Surgeon 等）在压缩率上表现良好，但它们的部署被这个偏置卡住了。已有两条出路都不理想：要么用 FlashBias 的 rank-one 增广方案，给每个 query 和 key 加一个额外坐标，但这改变了模型的 query 路径，并且 vLLM 会把 head dimension 从 128 存成 136（FlashAttention）或 256（FlashInfer），多占 6% 到 100% 的 KV 内存；要么直接丢掉偏置（Still、QREAM 的做法），但这放弃了 AM 专门拟合的质量修正项。

论文的解决方案是：把偏置“折叠”进 key 本身。每个保留的 key 沿一个 per-head 的共享方向 u 移动 β_j·√d·u 的距离，这样 query 与移动后 key 的点积就自动包含了偏置项乘以 q·u 的因子。如果 q·u ≈ 1，折叠后的 cache 就近似等价于带偏置的 AM cache，但形式上是一个纯 KV cache，可以直接跑在标准 kernel 上。

受益者：任何想在 vLLM、FlashAttention 等标准推理栈上部署 AM 类压缩方法的团队。他们不再需要为每种 GPU 和 cache layout 编写和维护带偏置的 attention kernel，也不需要修改模型的 query 路径或接受额外的 head dimension 开销。对于自托管长上下文推理服务，这意味着可以直接用现成的 vLLM 部署压缩后的 cache，享受压缩带来的吞吐提升（论文中 T4 上 Qwen3-4B 从 4 个并发请求提升到 31 个，decode 从 29 tokens/s 提升到 200 tokens/s）。

2. 已有工作的不足

在本文之前，处理 AM 偏置的部署问题主要有三条路线，各有具体缺陷：

路线一：FlashBias 的 rank-one 增广。 FlashBias 提出把低秩偏置分解成 query 和 key 的额外坐标，在 FlashAttention 内部计算。对于 AM 的 per-key 标量偏置，这是 rank-one 情形：给每个 query 加一个常数坐标，给每个保留的 key 加 β_j·√d 的坐标。这个方案是精确的，但有两个具体代价。第一，head dimension 从 128 变成 129，而 vLLM 0.18.1 的 FlashAttention backend 只接受 8 的倍数，所以实际存储为 136，比折叠方案多 6% 的 KV 内存；FlashInfer 只支持 64、128、256，所以会存成 256，多 100%。第二，引擎必须修改模型的 query 路径来追加这个常数坐标，这是对模型代码的侵入性改动。

路线二：直接丢弃偏置。 Still 方法在论文中明确说，因为 serving 偏置需要 kernel 支持，所以它在所有报告的结果里都把 β 设为 0。QREAM 也论证 per-key 偏置与标准 KV cache 不兼容，直接移除偏置，只拟合 value。问题在于：AM 的偏置不是可有可无的装饰，它是通过非负最小二乘拟合出来的，用来让保留 key 的注意力质量覆盖整个上下文。丢掉偏置意味着保留的 key 只携带自己的注意力质量，会系统性地低估文档部分相对于后续 token 的注意力份额。论文的实验显示，在 equal budgets 下，drop 的 KL 到 full cache 在 12 个设置里全部高于 fold，其中 10 个超出噪声。

路线三：为每种引擎写带偏置的 kernel。 AM 原论文报告偏置对 attention runtime 影响可忽略，ARC-KV 测出 bias-aware path 是 FlashAttention-2 的 1.06 到 1.09 倍。但问题不在速度，而在可用性：每个 serving 引擎都需要第二条带偏置的路径，为每种 GPU 和 cache layout 编写和调优。paged cache、prefix cache、KV transfer、FlashAttention 本身都没有偏置输入。论文引用的多个工作（Latent Compaction、Still、AsymKV、KeepKV 等）都把这一点列为部署缺口。

核心不足的总结：已有方案要么精确但侵入性强且有内存开销（FlashBias rank-one），要么无侵入但放弃 AM 的核心修正（drop bias），要么要求为每种引擎写专用 kernel（不可规模化）。没有一个方案能在“保持 AM 的 cache 尺寸、head dimension 和 query 路径不变”的前提下，给出一个纯 KV cache。

3. 重建作者的思考路径

假设我面对第 2 项里的问题：AM 的 cache 是 (K_S, β, V'_S)，其中 β 是每个保留 key 的标量偏置，标准 kernel 不认它。我想让它变成纯 (K', V')。

第一步：能不能把偏置吸收进 key 的几何位置？ 直觉上，logit 是 q·k_j/√d + β_j。如果我把 key 从 k_j 移到 k'_j，logit 变成 q·k'_j/√d。我希望 q·k'_j/√d = q·k_j/√d + β_j 对所有 query 成立。但左边是 q 的线性函数，右边多了常数项 β_j，所以没有任何单个 k'_j 能对所有 q 精确满足这个等式。这是第一个矛盾：精确折叠在单个 key 上不可能。

第二步：能不能给每个 key 单独拟合一个移动向量？ 如果我只关心一组已知的参考 query Q，那么条件就是 Q(k'_j - k_j) = √d·β_j·1。这是线性方程组，最小二乘解是 k'_j - k_j = β_j·√d·(Q 的伪逆作用于 1)。注意这个解对每个 key 是 β_j·√d 乘以同一个方向——因为伪逆只依赖于 Q，不依赖于 j。所以“给每个 key 单独拟合”自然退化为“所有 key 共享一个方向 u”。这解决了第一步的矛盾：虽然不能对所有 query 精确，但可以在参考 query 上做最小二乘。

第三步：共享方向 u 的几何含义是什么？ 移动后 logit 变成 q·k_j/√d + β_j·(q·u)。当 q·u = 1 时，这就是 AM 的 logit。所以问题转化为：找一个方向 u，使得未来 query 的 q·u 尽量接近 1。这让我想到：在参考 query 集合上拟合 u，使得 q·u 的均值接近 1，方差尽量小。最小二乘目标 (1/N)·‖Q_c·u - 1‖² 可以拆成均值项 (μᵀu - 1)² 和方差项 uᵀΣu。直接最小化这个目标会得到 u_LS = Σ⁻¹μ/(1+s)，其中 s = μᵀΣ⁻¹μ。但这里有个问题：最小二乘在均值和方差之间做了权衡，平均来说只施加了 s/(1+s) 的偏置，不是完整的偏置。这不够好——我希望均值项严格为 0，即 μᵀu = 1 精确成立。

第四步：强制均值约束。 在 μᵀu = 1 的约束下最小化 uᵀΣu，解是 u = Σ⁻¹μ/(μᵀΣ⁻¹μ)。这个 u 保证在参考 query 上 q·u 的均值精确为 1，方差最小。这就是论文的公式 (6)。到这里，核心方案已经成形：每个保留 key 沿 u 移动 β_j·√d·u。

第五步：误差会怎样？ 折叠后的 logit 是 AM logit 加上 t(q)·β_j，其中 t(q) = q·u - 1。如果所有被 attend 的 key 的 β 都一样，这个额外项只是给所有 logit 加同一个常数，softmax 不变，输出不变。误差只在 β 和 value 协变时出现。这提示误差应该正比于 t(q) 乘以 β 在注意力权重下的方差，再乘以 value 的跨度。用 softmax 导数 ∂p_j/∂ℓ_i = p_j(δ_ij - p_i) 沿路径 ℓ(τ) = ℓ_AM + τ·t(q)·β 积分，得到 do/dτ = t(q)·Cov_{p(τ)}(β, v)。再用 Popoviciu 不等式约束 β ∈ [-3,3] 和 value 距离 D_V，得到误差上界 (3/2)·D_V·∣q·u - 1∣。这是论文的公式 (8)。

第六步：value 要不要重新拟合？ 折叠改变了参考 query 上的 logit，所以原来 AM 拟合的 value 不再最优。应该用折叠后的 key 重新做一次最小二乘 value 拟合，即论文的公式 (9)。这能吸收一部分折叠残差。

第七步：u 的数值稳定性。 query 协方差 Σ 可能病态，所以加一个 ridge：Σ + λI，其中 λ = 10⁻²·tr(Σ)/d。均值约束仍然精确成立。

与论文实际路径的差异： 我的重建路径和论文基本一致，但有一个关键分叉我一开始没有意识到：论文在第三步和第四步之间明确区分了“最小二乘解”和“均值约束解”，并指出最小二乘解只施加了 s/(1+s) 的偏置，这是不够的。我最初会直接接受最小二乘解，不会想到要强制均值约束。另外，论文在第 3.3 节专门推导了与“丢弃偏置”的一阶比较（corollary），说明折叠误差是丢弃偏置误差的 ∣q·u - 1∣ 倍——这个对比视角我一开始不会主动建立，但它对理解折叠何时优于 drop 很关键。论文还强调了在 value refit 之前要把 key 舍入到 bf16，让 value 拟合的是 kernel 实际读到的 key，这个工程细节我在思考路径里不会提前想到。

4. 核心 intuition

类比：翻译中的“口音补偿”。 想象一个翻译员（保留的 key）要代表一个团队（被丢弃的 key）发言。团队里每个人说话有不同的“音量”（注意力质量），翻译员需要调整自己的“音量”来匹配团队的总音量。AM 的做法是给翻译员一个“音量旋钮”（偏置 β_j），每次发言时单独调节。但标准麦克风（kernel）没有这个旋钮接口。

折叠的做法是：让翻译员站到一个特定的位置（沿方向 u 移动）。这个位置的选择使得：当听众（query）从“正常角度”听时，翻译员的音量恰好等于原始音量加上旋钮的补偿。具体机制是：移动 key 改变的是 q·k 这个内积，而内积对移动的响应是 q·u 乘以移动距离。如果 q·u = 1，移动 β_j·√d·u 就精确等价于加 β_j。方向 u 的拟合目标是让参考 query 的 q·u 均值恰好为 1 且方差最小，这样“大多数听众从大多数角度听”时，补偿都是对的。

这个类比能对上机制：移动 key 是几何操作，不改变 cache 的数据结构；q·u 是 query 在方向 u 上的投影，决定了补偿的缩放因子；拟合 u 让投影集中在 1 附近，就是让补偿在参考 query 上尽量精确。误差来源是未来 query 的投影偏离 1，对应类比中“听众从奇怪的角度听”。

5. 方法 pipeline 举例

输入：一个 key-value head，上下文有 n = 4096 个 token，head dimension d = 128，预算 r = 409（10%）。参考 query 集合 Q 有 M = 1024 个 query（来自 repeat prefill 的每隔一个位置），上下文 query 集合 Q_c 有 N = 4096 个 query（原始 prefill 的所有 query）。

步骤 1：AM 拟合。 对 Q 计算每个 key 的平均注意力质量，选出 top-409 的 key 作为保留集合 S。对保留 key 做非负最小二乘拟合权重 w_j，目标是最小化 Σ_m (Σ_{j∈S} w_j·p_j(q_m) - 1)²，约束 w_j ∈ [e⁻³, e³]。取 β_j = log w_j。然后用最小二乘拟合 value：V'_S = argmin_X ‖softmax(Q·K_Sᵀ/√d + 1βᵀ)·X - O‖²_F。得到 AM cache (K_S, β, V'_S)。

步骤 2：拟合方向 u。 对 Q_c 的 4096 个 query 计算均值 μ（128 维向量）和协方差 Σ（128×128 矩阵）。加 ridge：Σ_λ = Σ + λI，其中 λ = 10⁻²·tr(Σ)/128。解线性方程组 Σ_λ·a = μ 得到 a。计算 u = a/(μᵀa)。此时 μᵀu = 1 精确成立。

步骤 3：折叠 key。 对每个保留 key k_j，计算 k'_j = k_j + β_j·√128·u。将 k'_j 舍入到 bf16 精度。

步骤 4：重新拟合 value。 用折叠后的 key 做最小二乘：V''_S = argmin_X ‖softmax(Q·K'ᵀ_S/√128)·X - O‖²_F。注意这里没有偏置项。

步骤 5：输出。 纯 KV cache (K'_S, V''_S)，每个 head 有 409 个 key 和 409 个 value，维度都是 128。这个 cache 可以直接写入 vLLM 的 paged blocks。

步骤 6：serving。 一个 query q 到来时，标准 attention 计算 softmax(q·K'ᵀ_S/√128)·V''_S。如果 q·u ≈ 1，这个输出近似等于 AM 的输出。如果 q·u = 0，等价于丢弃偏置。

6. 核心数学推导

目标：推导折叠误差上界，即公式 (8)：‖o_fold(q) - o_AM(q)‖ ≤ (3/2)·D_V·∣q·u - 1∣。

符号解释：

• q：一个 query 向量，维度 d
• k_j：第 j 个保留 key，维度 d
• β_j：第 j 个保留 key 的 AM 偏置，范围 [-3, 3]
• u：折叠方向，维度 d，满足 μᵀu = 1
• t(q) = q·u - 1：query 投影偏离 1 的量
• v_j：第 j 个保留 key 的 value，维度 d
• p_j：第 j 个 key 的注意力权重
• D_V = max_{i,j} ‖v_i - v_j‖：任意两个 value 之间的最大距离

推导步骤：

第一步：折叠后的 logit。 折叠 key 为 k'_j = k_j + β_j·√d·u。query 与折叠 key 的 logit 为： q·k'_j/√d = q·k_j/√d + β_j·(q·u) = q·k_j/√d + β_j + β_j·t(q)。 所以折叠 logit = AM logit + t(q)·β_j。

第二步：沿路径积分。 定义路径 ℓ(τ) = ℓ_AM + τ·t(q)·β，其中 τ ∈ [0,1]。τ=0 是 AM，τ=1 是折叠。注意力权重 p(τ) = softmax(ℓ(τ))，输出 o(τ) = Σ_j p_j(τ)·v_j。对 τ 求导： do/dτ = Σ_j (dp_j/dτ)·v_j。

第三步：softmax 导数。 softmax 的导数是 ∂p_j/∂ℓ_i = p_j·(δ_ij - p_i)。所以： dp_j/dτ = Σ_i (∂p_j/∂ℓ_i)·(dℓ_i/dτ) = Σ_i p_j·(δ_ij - p_i)·t(q)·β_i = t(q)·p_j·(β_j - Σ_i p_i·β_i) = t(q)·p_j·(β_j - β̄_τ)， 其中 β̄_τ = Σ_i p_i(τ)·β_i 是 β 在注意力权重下的均值。

第四步：得到协方差形式。 代入： do/dτ = t(q)·Σ_j p_j(τ)·(β_j - β̄_τ)·v_j = t(q)·Cov_{p(τ)}(β, v)， 其中 Cov_p(β, v) = Σ_j p_j·(β_j - β̄)·(v_j - v̄) 是 β 和 v 在注意力权重 p 下的协方差，v̄ = Σ_j p_j·v_j。

第五步：用 Cauchy-Schwarz 约束协方差。 对任意单位向量 w： w·Cov_p(β, v) = Cov_p(β, w·v) ≤ sd_p(β)·sd_p(w·v)， 其中 sd_p 是在权重 p 下的标准差。这是 Cauchy-Schwarz 不等式。

第六步：用 Popoviciu 不等式约束标准差。 β_j ∈ [-3, 3]，所以 sd_p(β) ≤ 3（区间长度的一半）。w·v_j 落在长度为 D_V 的区间内，所以 sd_p(w·v) ≤ D_V/2。因此： ‖Cov_p(β, v)‖ ≤ 3·D_V/2。

第七步：积分。 对 τ 从 0 到 1 积分： ‖o_fold - o_AM‖ = ‖∫₀¹ (do/dτ) dτ‖ ≤ ∫₀¹ ‖do/dτ‖ dτ ≤ ∫₀¹ ∣t(q)∣·(3/2)·D_V dτ = (3/2)·D_V·∣t(q)∣。

总结：这个公式在算什么：它给出了折叠 cache 与 AM cache 输出差异的上界，这个上界正比于 query 在方向 u 上的投影偏离 1 的程度 ∣q·u - 1∣，乘以 value 的最大跨度 D_V，再乘以常数 3/2（来自 β 的范围 [-3,3]）。关键含义：如果 q·u 接近 1，折叠几乎无损；如果 q·u 远离 1，误差线性增长。

7. 实验设计

数据集：

• QuALITY：30 篇文章，534 个四选一问题，每篇 2.8k 到 8.1k token
• LongHealth：20 个病人，398 个五选一问题，每个 10.0k 到 13.2k token
• LongBench：4 个英文 QA 任务（Qasper、MultiFieldQA-en、HotpotQA、2WikiMQA），每任务 50 个样本
• Pride and Prejudice：单文本 32k token，用于 layer-wise 分析

基线：

• full cache：不压缩
• keep：保留 AM 选出的 key，用原始 value，无偏置
• drop：保留 AM 选出的 key，用 β=0 重新拟合 value
• AM：完整 AM cache（key + 偏置 + 拟合 value）
• fold：本文方法（折叠 key + 重新拟合 value）

指标：

• accuracy：选项字母 log-probability 的 argmax 正确率
• KL(full‖·)：压缩 cache 的答案分布与 full cache 的 KL 散度
• agreement：与 full cache top option 的一致率
• 95% paired bootstrap 置信区间，超过噪声阈值的差异才称为显著

消融：

• value refit 的作用：去掉 refit 后 fold 的 KL 在 4B 和 8B 上上升 0.36 到 0.67
• u 的估计器：用均值方向 u = μ/‖μ‖² 替代协方差方向，fold 的 KL 在 4B 和 8B 上全部上升，两列超出噪声
• AM 拟合方式：AM-style fit vs 本文 fit，在不同模型上各有优劣
• per-head budgets vs equal budgets：per-head budgets 下 fold 在 9/10 设置与 AM 持平，但 KL 优势消失
• 其他偏置方法：log-count merging 的折叠，KV-Surgeon 两个 compactor 的折叠

实验能否支撑结论：能支撑核心结论“折叠在 equal budgets 下与 AM 精度持平（13/14 设置），且 KL 优于 drop（12/12 设置）”。但有几个缺口：第一，QuALITY 上 AM 相对 keep 的 accuracy 增益本身不显著，所以这些列只能说明 fold 没有造成可检测的损害，不能说明 fold 保留了 AM 的增益；第二，per-head budgets 下 fold 的 KL 优势消失，且在一个 Llama 设置上显著输给 AM 4.5 个点；第三，serving 实验的答案正确性只在 Qwen3-4B 的 51 个问题上验证，14B 的 LongBench 只验证了 greedy 输出一致性，没有验证 accuracy 差异的显著性。

8. take-aways

1. 折叠在 equal budgets 下与 AM 精度持平：在 QuALITY（4 个模型）和 LongHealth（3 个模型）的 14 个设置中，13 个设置的 fold−AM accuracy 差异在噪声范围内，唯一例外是 Qwen3-1.7B LongHealth 10%，fold 输 4.5 个点。

1. 折叠的 KL 到 full cache 在 equal budgets 下全面优于 drop：12 个设置中 fold 的 KL 全部低于 drop，其中 10 个超出噪声；drop 在 11/12 设置中有更多 KL>1 的问题。

1. per-head budgets 改变了结论：在 10 个 per-head budget 设置中，fold 与 AM 在 accuracy 上 9/10 持平，但 KL 优势消失（无一个 drop−fold KL 差异超出噪声），且在 Llama-3.1-8B LongHealth 5% 上 fold 输给 AM 4.5 个点、输给 drop 7.8 个点。

1. vLLM 部署可行且吞吐提升显著：Qwen3-4B 在 T4 上，10% 压缩时并发从 4 提升到 31，decode 从 29 提升到 200 tokens/s；Qwen3-32B 在 A100 上，10% 压缩时并发从 7 提升到 45，decode 从 135 提升到 872 tokens/s。

1. 折叠的误差集中在少数 head：在 Pride and Prejudice 的 far-query 分析中，最差的 10% (head, window) 对贡献了 90–96% 的总 excess error，且 81–89% 位于 layers 0–6，这些 head 的 q·u 均值漂移是主因。

9. 最脆弱的假设

最脆弱的假设是：在参考 query 上拟合的 q·u 均值等于 1 的性质，能推广到未来 query。 论文的整个误差界都建立在 ∣q·u - 1∣ 很小的前提上。公式 (6) 的 u 只保证在 Q_c 上 q·u 的均值精确为 1，方差最小。但论文自己承认：“nothing holds it there thousands of tokens later”。

论文给出的证据：第 4 节的 layer study 显示，在 far queries（距离上下文 4k token 以上）上，最差 head 的 ∣m-1∣ 中位数达到 0.18 到 0.34，而其他 head 只有 0.09 到 0.12。这些漂移的 head 贡献了 90–96% 的 excess error。附录 A.4 的 Llama 失败诊断也显示，question query 的 rms ∣q·u-1∣ 是 0.071，而 fit query 上是 0.044，且在所有 1280 个 head 上 question query 的偏差都更大。

这个假设一倒结论就崩的场景：如果任务需要长距离的多轮对话，query 分布会随对话推进而漂移，q·u 可能系统性偏离 1，折叠误差会线性增长。论文的 QA benchmark 都是“读完文档立刻提问”，没有探测这个 regime。论文在 Limitations 里也承认：“a multi-turn task would” probe this regime，但未做。

论文是否给出假设成立的证据：部分给出。在 near queries 上（距离 ≤1k token），fold 与 AM 的 median error ratio 在 1.3% 以内，说明短期内假设成立。但对于 far queries，论文只展示了 median head 仍然跟踪 AM（ratio 在 2.2% 以内），同时承认 mean 被少数 head 拉坏。论文没有给出一个可操作的判据来在 compaction time 预测哪些 head 会漂移——这被列为 future work。

10. 一周最小复现

目标：复现核心结论“折叠在 equal budgets 下与 AM 精度持平，且 KL 优于 drop”，用 Qwen3-4B 在 QuALITY 上。

硬件：1 张 24GB 消费级显卡（如 RTX 4090），1 周时间。

步骤：

第 1 天：环境搭建。安装 PyTorch、transformers、vLLM（可选，第一周可以只用 Hugging Face 做 accuracy 实验）。下载 Qwen3-4B 和 QuALITY 验证集的前 30 篇文章。

第 2 天：实现 AM。按论文公式 (1) 和 (2) 实现 AM 拟合：top-r key 选择（按平均注意力质量）、NNLS 权重拟合（投影梯度，300 步）、value 最小二乘拟合。用 repeat prefill 生成参考 query Q（每隔一个位置取一个）。在 bf16 下跑通 full cache 和 AM cache 的 accuracy 和 KL。

第 3 天：实现折叠。按公式 (6) 计算 u：对 Q_c 计算 μ 和 Σ，加 ridge λ = 10⁻²·tr(Σ)/d，解 (Σ+λI)a = μ，u = a/(μᵀa)。折叠 key：k'_j = k_j + β_j·√d·u，舍入 bf16。按公式 (9) 重新拟合 value。跑通 fold 的 accuracy 和 KL。

第 4 天：跑完整对比。在 Qwen3-4B QuALITY 上跑 10% 和 5% 两个 budget，对比 full、keep、drop、AM、fold 五个 cache 的 accuracy 和 KL。预期：fold−AM accuracy 差异在 ±3 点以内，fold 的 KL 低于 drop 约 0.6 到 1.0。

第 5 天：vLLM serving（可选但推荐）。用 vLLM 0.18.1 加载 Qwen3-4B，写一个 KV connector 把折叠 cache 写入 paged blocks，验证 answer letter 与 Hugging Face 一致。测并发数和 decode 速度。

第 6 天：消融。去掉 value refit，看 fold 的 KL 是否上升（论文 Table 12：4B 是 +0.43/+0.44，0.36 到 0.67 是 8B 的两列）。用均值方向 u = μ/‖μ‖² 替代协方差方向，看 KL 是否上升。

第 7 天：整理结果，计算 95% paired bootstrap 置信区间，确认 fold−AM 差异是否在噪声范围内。

数据规模：30 篇文章，534 个问题，每篇 2.8k–8.1k token。在 24GB 显卡上，Qwen3-4B 的 full cache 可以放下（每 token 144 KiB，8.1k token 约 1.2 MB，30 篇可以分批跑）。

预期指标：论文 Table 2 报告 Qwen3-4B QuALITY 10% 时 fold accuracy 62.7%，AM 63.7%，fold−AM = −0.9 [−2.4, +0.4]；fold KL 1.68，drop KL 2.34，drop−fold = +0.66 [+0.43, +0.92]。复现应落在这些数值的 ±2 点（accuracy）和 ±0.2（KL）范围内。

11. 反例设计

核心主张：折叠 cache 在 q·u ≈ 1 的 query 上近似等价于 AM cache，误差随 ∣q·u - 1∣ 线性增长。

反例实验：设计一个多轮对话任务，让 query 分布系统性偏离拟合时的分布。

具体设计：

• 用 Qwen3-4B，上下文是一篇长文档（如 8k token 的 QuALITY 文章），按论文协议拟合 AM 和 fold。
• 不立刻提问，而是插入一段很长的对话历史（如 4k token 的多轮对话），让模型在对话中逐步改变话题，最后再问关于文档的问题。
• 在每一轮对话后，记录该轮 query 的 q·u 均值。预期：随着对话推进，q·u 的均值会从 1 漂移开。
• 对比 fold 和 AM 在最后一轮问题上的 accuracy 和 KL。

判据：如果 fold−AM 的 accuracy 差异显著为负（超出 bootstrap 置信区间，且绝对值大于 5 个点），且这个损失与 q·u 均值的漂移量正相关，则说明折叠在 query 分布漂移时失效，核心主张“折叠可以替代 AM”在多轮场景下不成立。

更强的判据：如果 fold 的 accuracy 甚至低于 drop（即折叠不仅没有保留 AM 的增益，反而因为 key 移动引入了额外误差），则说明折叠在漂移场景下比简单丢弃偏置更差。论文附录 A.4 的 Llama 失败已经展示了这种可能性：在 per-head budgets 下，Llama-3.1-8B LongHealth 5% 时 fold 输给 drop 7.8 个点。

为什么这个实验能推翻核心主张：论文的误差界 (3/2)·D_V·∣q·u-1∣ 只在 ∣q·u-1∣ 小时才有用。如果多轮对话导致 ∣q·u-1∣ 系统性增大（比如均值漂移到 0.8 或 1.2），误差会线性增长，fold 可能比 drop 更差，因为 drop 等价于 q·u = 0，其误差是固定的，而 fold 的误差随漂移增长。论文自己承认没有测试多轮场景，这是最直接的攻击面。

12. 落地判断

能否用于“抢占式 GPU 自托管 27B 模型做多智能体脚手架”：可以，但有明确的条件和坑。

怎么用：

• 27B 模型（如 Qwen3-27B 或类似规模）在 fp16 下每 token KV 约 144 KiB（假设 head dimension 128，层数约 32–36）。如果上下文是 8k token，full cache 约 1.2 GB。在 24GB 消费级显卡上，这已经占了一半以上的显存。
• 用折叠方案压缩到 10%（equal budgets per head），以 1.2 GB 的原始 cache 计，压后约 1.2 GB × 10% = 120 MB（两个数按常见 8K 上下文、4 层 KV 的规模估算，不是原文数据），可以同时服务多个 agent 的上下文。
• 部署路径：离线跑 AM 拟合 + 折叠，得到纯 KV cache，通过 KV connector 写入 vLLM 的 paged blocks。vLLM 不需要任何修改，用标准 FlashAttention backend。
• 多智能体场景中，每个 agent 有自己的上下文，可以分别压缩后注入。如果 agent 之间有共享的文档前缀，可以只压缩一次，多个 agent 复用。

成本量级：

• 压缩本身是一次性的离线计算：AM 的 NNLS 拟合 + value 最小二乘 + 折叠的协方差计算和线性求解。对于 8k token 上下文，在单张 24GB 卡上大约几分钟量级（论文没有给出精确时间，但强调折叠的额外开销“all small next to AM’s NNLS and value fits”）。
• serving 时无额外开销：折叠 cache 就是纯 KV cache，decode 速度与同长度的普通 prompt 相同（论文测出 97–101%）。
• 显存节省：10% 压缩率下，KV cache 从 1.2 GB（估算值）降到 1.2 GB × 10% = 120 MB，理论上可服务约 10 倍的并发请求（即比原来多 9 倍）。

最大的坑：

1. 多轮对话的 query 漂移。多智能体脚手架天然是多轮的，agent 会在对话中改变话题和关注点。论文的 u 是在初始上下文的 query 上拟合的，随着对话推进，q·u 会漂移，折叠误差会增长。论文没有测试这个场景，且在第 4 节展示了 far queries 上少数 head 的严重漂移。建议：在多轮场景中，每隔几轮重新拟合 u 并重新折叠，或者监控 q·u 的均值，当漂移超过阈值（如 0.1）时触发重新压缩。

1. per-head budgets 的坑。论文的 serving 实验只用 equal budgets，因为 per-head budgets 会产生 ragged cache lengths，vLLM 的 paged cache 不好处理。但论文也显示 per-head budgets 下 fold 的 KL 优势消失，且在一个 Llama 设置上显著输给 AM。建议：如果追求最高精度，用 per-head budgets 但需要自己处理 ragged lengths（padding + mask），这会牺牲一部分 serving 的简洁性。

1. β 的大值问题。论文的 Llama 失败诊断显示，36% 的保留 key 的 ∣β∣ = 3（在 box 边界上），这些大 β 放大了 q·u 漂移的影响。把 β 限制在 ±1 可以消除失败，但这个 box 是在失败案例上选的，未在其他设置验证。建议：在 27B 模型上先跑一个小规模诊断，看 β 的分布和 q·u 的漂移，再决定是否收紧 β 的 box。

1. 抢占式 GPU 的额外风险。抢占式实例可能在任何时候被回收，而压缩是一次性离线计算。如果压缩结果没有持久化，被抢占后需要重新压缩。建议：把折叠后的 cache 序列化到磁盘，恢复时直接加载，避免重复压缩。