CLAA：跨层注意力聚合，长上下文 Prefill 的 TTFT 最高降低 39%（2026）

Prefill 与 Decode：两种截然不同的瓶颈#

Transformer 生成式推理分成两个阶段。Prefill（预填充）：一次把整段 prompt 输入模型，所有位置并行计算，生成第一层的隐藏状态和 KV 缓存，产出第一个 token；Decode（解码）：此后每个新 token 只能依赖之前所有 token，串行逐 token 生成。

这两个阶段的瓶颈性质完全不同：

• Decode 是 memory-bound。每个解码步只算一个新位置的注意力，计算量极小（8B 模型每 token 约 16 GFLOP），但要把全部前缀的 KV 缓存从 HBM 读一遍，带宽随上下文长度线性增长。本博客前文《MAC-Attention：Match-Amend-Complete 注意力复用》开篇算过这笔账：128K 上下文、LLaMA-3.1-8B，每生成一个 token 就要流式读取约 16 GiB 的 KV。
• Prefill 是 compute-bound。prompt 里的 L 个位置全部并行计算，注意力部分是 O(L²) 的矩阵乘，MLP 部分也要对每个位置算一遍。L 越大，prefill 的绝对耗时越长，而且与”生成多少 token”无关——即使模型最终只回答一个字，也要先把整个 prompt 算完。

算一笔具体的账。LLaMA-3.1-8B 有约 $8\times 10^9$ 参数，处理长度 $L$ 的输入大致需要 $2 \times 8\times 10^9 \times L$ FLOP（前向一次乘加算两 FLOP）。当 $L = 10^4$（一万 token，一次标准的长文档问答）时：

A100-SXM4-80GB 的 BF16 稠密算力约 312 TFLOPS，理想情况下这段 prefill 就要约 0.5 秒；实际考虑注意力、访存与 kernel 效率，论文实测 LLaMA-3.1-8B 在 A100 上处理 10k token 的 TTFT（Time-to-First-Token，首 token 延迟）约 900 ms。对比之下 decode 每 token 只有 16 GFLOP，同一块卡上算力层面微秒级就能完成。所以长上下文的 prefill 是实实在在的计算瓶颈，而 TTFT 直接决定了用户”等第一个字”的时间——检索增强问答、代码库问答、长文档总结这类应用里，几千到几万 token 的 prompt 非常常见，prefill 常常占掉端到端时延的一半以上。

已有的 prefill 加速路线，各自卡在哪#

• FlashAttention 系列：通过分块与在线 softmax 把注意力从”物化整个 $L\times L$ 矩阵”改成”按块流式读取”，把访存常数压到极低。但它没有改变算法复杂度，$L$ 增大时 $O(L^2)$ 的乘法量依然存在。本博客前文讲过 FlashAttention-4 在 Blackwell 上能把注意力推到矩阵乘的速度，但那是把常数榨干，不是改变复杂度。
• 动态稀疏注意力（MInference，微软团队，NeurIPS 2024）：利用注意力模式的结构（垂直稀疏、水平稀疏、块稀疏），运行时动态跳过一部分 QK^T 计算。它省的是注意力矩阵乘本身，但 MLP 部分仍然要处理全部 L 个 token。
• 语义压缩（LLMLingua 等）：用一个小模型把长 prompt”改写”成短摘要再喂给主模型。压缩率可观，但改写本身是自回归生成，要花几秒；对单次查询而言，这个开销往往吃掉全部收益（论文实测 Selective Context 的改写耗时 3-5 秒，比不压缩还慢，详见后文实验）。
• Token-ranking 启发式：先给每个 prompt token 打一个”重要性分”，然后主模型只对最重要的 top-k% token 做完整的前向计算。这类方法不需要训练、不改模型权重、不依赖额外硬件，是 2024-2025 年很活跃的一条线。本文的主角 CLAA 就属于这个家族。

三种代表性 Token-Ranking 方法#

统一记号：prompt 长度 $L$，模型 $M$ 在第 $l$ 层、第 $h$ 个注意力头处，prompt 所有 token 的 key 向量组成矩阵 $K_{\mathrm{prompt}}^{(l,h)} \in \mathbb{R}^{L \times d_k}$，$d_k$ 是 head 维度。每种方法的目标都是给每个 prompt token $i \in \{1,\dots,L\}$ 算一个重要性分数 $S_i$，然后取 top-k% 作为”保留集合”。

GemFilter（Shi 等，2024，arXiv 2409.17422，标题里的”1000x input token reduction”指它把输入压到千分之一）。它假设：prompt 的最后一个 token 经过前 $r$ 层处理后得到的 query 向量 $\mathbf{q}_{\mathrm{last}}^{(r)}$，足以识别出上下文里哪些 token 相关。于是重要性分数就是这一个 query 对全部 prompt key 的原始注意力（pre-softmax）在所有头上求和：

式中下标 $i$ 表示取向量第 $i$ 个分量，即 token $i$ 的 key 与最后一个 token 的 query 的点积；除以 $\sqrt{d_k}$ 是标准注意力缩放。GemFilter 的实现是两遍式：先跑一个截断到第 $r$ 层的前向，用最后一 token 的 query 排序，丢弃这遍中间状态，再用保留下来的 token（保持原始位置 ID）重新做一遍完整前向。

FastKV（Jo 等，2025，arXiv 2502.01068）。它用 prompt 末尾 $W$ 个 token 组成的”观察窗口” $\mathcal{W}$ 作为 query 集合，在某个 Token-Selective Propagation（TSP）层 $l_{\mathrm{TSP}}$ 处打分，每个 query 对全部 key 的 softmax 后注意力概率在所有头上求和：

与 GemFilter 的关键差别是架构：FastKV 是单遍式的——在每层都计算打分并压缩该层存进 KV 缓存的 token 数，但保持全部隐藏状态继续前向；只在 TSP 层做一次序列剪枝。它的压缩率由”保留率”统一控制，prefill 剪掉的 token 与 decode 用的 KV 缓存共享同一个保留集合。

Speculative Prefill（Liu、Chen、Zhang，ICML 2025，arXiv 2502.02789）。思路最”激进”：用一个小的草稿模型 $M_{\mathrm{spec}}$ 先跑完整 prompt，再自回归生成 $k$ 个 lookahead token，用这些”未来 token”的 query 给 prompt 打分——模型在生成时会找什么，哪些 token 就重要。分数取每个 lookahead query 在所有层、所有头上原始注意力最大值的平均：

注意这里的 key 矩阵是草稿模型算出来的 $K_{\mathrm{prompt,spec}}$，因为打分发生在草稿模型的隐藏空间里；之后主模型才对 top-k% token 做选择性的 prefill。

三种方法的共性很清晰：都用注意力作为重要性信号，区别只在于用谁的 query（最后一个 token / 观察窗口 / 草稿模型生成的未来 token）、在哪一层打、取 pre-softmax 还是 post-softmax。它们的排序质量如何？此前只能通过端到端基准（LongBench 分数、TTFT）间接比较——但端到端指标把”排序质量”和”架构效率”（两遍 vs 单遍、KV 是否压缩）混在一起，根本回答不了一个基本问题：到底哪种排序更接近 token 的真实重要性？ 更麻烦的是，这些方法都只信任某一层（$r$、$l_{\mathrm{TSP}}$）的注意力，而注意力在不同层之间可能剧烈变化——选错层就会系统性丢 token。

CLAA 这篇论文（Bradley McDanel、Steven Li、Harshit Khaitan，2026 年 2 月 17 日发布于 arXiv，编号 2602.16054；前两位作者任职于 Meta Reality Labs）做的第一件事，就是先把”真实重要性”的测量问题解决掉。

Token 的重要性，由答案说了算#

启发式方法有一个共同的信息劣势：它们必须在生成开始前、只看着 prompt 猜测哪些 token 重要。而”重要性”的定义天然是事后性的——一个 prompt token 是否重要，取决于模型生成的答案有没有用它。CLAA 提出的 Answer-Informed Oracle（答案回看注意力基准） 把这条思路贯彻到底：token 的重要性 = 生成的答案回头看它时，注意力给了它多少。既然启发式本质上是”用部分信息预测这个真值”，那这个真值就是评估它们的标尺，也是任何启发式不可逾越的性能上界。

Oracle 的构造：三阶段流程#

Oracle 的构造分三个阶段（论文 Algorithm 1）：

1. 提取 prompt 的 key：对完整 prompt 做一次前向，把每一层、每一个头的 $K_{\mathrm{prompt}}^{(l,h)}$ 全部保存下来。注意这里只需要 key，不需要保存任何注意力矩阵——这正是刻意为之的设计：完整生成过程中注意力矩阵是 $L\times L$ 的，全存下来内存不可承受，而只存 key 是 $O(L)$ 量级的，完全可控。
2. 生成完整答案并收集 query：用同一个模型（greedy 解码）从 prompt 开始生成直到 EOS，过程中把每个生成 token 在各层各头的 query 向量 $\mathbf{q}_{\mathrm{gen},i}^{(l,h)}$ 依次存入列表。这一步就是一次普通的生成，成本可接受。
3. 回看打分并聚合：把收集到的所有答案 query 与第 1 步保存的 prompt key 做注意力，得到注意力分数矩阵；然后在”层 × 头”维度取最大、在”答案 token”维度取平均，最后做一维平均池化（kernel size 7）去噪，得到每个 prompt token 的 oracle 分数 $S^{\mathrm{oracle}}$。

伪代码如下（论文 Appendix D.4 的简化）：

1
def get_oracle_ranking(model, prompt_tokens, max_gen_len):
2
    # 阶段 1：完整 prefill，保存 prompt 全部 key
3
    _, prefill_kv = model.forward(prompt_tokens)
4
    k_prompt = prefill_kv.get_all_keys()
5

6
    # 阶段 2：完整生成答案，逐个收集生成 token 的 query
7
    q_generated = []
8
    next_token = prefill_kv.get_next_token()
9
    cur_kv = prefill_kv
10
    while not is_eos(next_token) and len(q_generated) < max_gen_len:
11
        output, cur_kv = model.forward(next_token, past_kv=cur_kv)
12
        q_generated.append(output.get_query())  # 所有层、所有头的 query
13
        next_token = output.get_next_token()
14

15
    # 阶段 3：答案 query 回看 prompt key，聚合得到真值分数
16
    scores = aggregate_attention(q_generated, k_prompt, use_softmax=False)
17
    return scores

三个聚合设计各有理由：

• 跨层、跨头取 max：与 Speculative Prefill 的思路一致——“即使只有一条强注意力连接，也可能承载关键信息”。一个 token 只要被某一层的某个头强注意，它就该被保留；取 max 不会让任何一层的机会被其他层的噪声平均掉。
• 在答案 token 维度取平均：与 Speculative Prefill 只用 $k$ 个（论文里 $k=8$）猜测出的未来 token 不同，oracle 用的是完整 ground-truth 答案的所有 token——8 个猜测 vs 上百个真实生成，后者对”这个 token 到底有没有被用到”的度量稳定得多。
• 1D 平均池化（kernel=7）：相邻 token 的重要性高度相关（一个词的重要部分常横跨几个 token），池化平滑局部波动、稳定排名；GemFilter、FastKV、CLAA 在对比时也统一加了这个后处理，保证公平。

评估指标：Spearman 秩相关系数#

排序质量和真值的接近程度用什么量？论文用 Spearman 秩相关系数 $\rho$：把 oracle 分数和启发式分数各自转成排名，再算两个排名序列的皮尔逊相关：

$r_a, r_b$ 是两组排名，$\mathrm{Cov}$ 是协方差，$\sigma$ 是标准差。$\rho$ 取值 $[-1, 1]$：1 表示两个排名完全一致，0 表示无关，-1 表示完全相反。选秩相关而不是原始分数相关的原因：我们要比较的是排序序次（最终只有 top-k% 会被保留），而各方法的分数尺度完全不同（有 softmax 概率、有原始 logit、有跨模型打分），秩相关天然对单调变换不变，是排序问题里最干净的度量。

Oracle 也是性能上界#

把 Oracle 排名拿去实际剪枝（对 top-k% token 做选择性前向），就得到一个经验上界：任何只看 prompt 的启发式，都不可能稳定超过它，因为启发式缺少的信息（答案内容）被 oracle 完全看到了。为了让上界公平，oracle 的剪枝方式必须与被评估方法的架构严格一致——比如 GemFilter/FastKV 在中间层 $l_p$ 剪枝，oracle 模拟时就在 $l_p$ 之前用 oracle 排名压缩每层 KV（但保持全部隐藏状态前向传播），在 $l_p$ 处才真正剪掉隐藏状态，之后照常。这样”上界与启发式只差在排序信号上”，架构差异被消除。

下图是论文 Figure 1，把整个评估框架和 CLAA 的位置画清楚了：

图中最上方，prompt 进入模型做 prefill；Oracle 通道额外生成完整答案，从答案反向聚合出真值排名；下方是各种 token-ranking 启发式与 CLAA——它们只能从 prompt 侧的信息打分，与 oracle 排名的 Spearman 相关 $\rho$ 就是它们的”测谎成绩”。论文用这个框架做诊断，结果发现了一个端到端基准完全看不见的失败模式。

图 2 里藏着的两个结论#

论文在 Llama-3.1-8B-Instruct 上、对 LongBench 的 16 个任务，把每种启发式方法逐层（0 到 31 层）与 oracle 排名算 Spearman 相关，画成下图（论文 Figure 2）：

每个子图是 LongBench 的一个任务，横轴是层号，纵轴是该层打分排名与 oracle 的 Spearman 相关。图上可以读出两个此前没人说清的结论：

结论一：单层启发式的排名剧烈波动，且在特定层出现”塌陷”。 FastKV 和 GemFilter 的曲线在层与层之间大幅跳动，在若干任务上（论文附录 C 给出细节：NarrativeQA、Qasper、HotpotQA、QMSum 里，两者在层 10 附近都出现尖锐的相关性跌落）排名质量骤降。对依赖单一固定层做决策的方法（GemFilter 的 $r$、FastKV 的 $l_{\mathrm{TSP}}$），如果选中的恰好落在塌陷区，就会用一份劣质排名剪掉真正重要的 token——而这一切在端到端基准上完全不可见，因为端到端分数是”排序质量 × 架构效率”的混合产物，塌陷层的坏排名被别的因素掩盖了。

结论二：浅层（0-4 层）的排名普遍不可靠。 所有方法的曲线在最初几层都明显低于深层。这不难理解：前几层还在构造词级表示，注意力模式粗糙，此时打出的重要性分信噪比低。基于浅层排名的剪枝等于在模型还没”看懂”上下文时就先扔东西。

为什么这个诊断有价值#

这个诊断的含金量在于它把”失败模式”和”修复方向”一步到位地指出来了。如果问题是单层信号的方差，那么修复方式就不是发明更聪明的打分公式，而是别信任何单层——把多层的信号聚合起来，让个别层的塌陷被其他层补上。这就是 CLAA 的全部内容，也因此论文标题下的副线是：一个简单的聚合策略，就能补上启发式与上界之间的大部分差距。

三个设计决策#

决策一：前 $m = 4$ 层不做任何压缩（defer）。 既然浅层排名不可靠、而浅层又在构造基础语义表示，CLAA 在前 4 层保持完整上下文前向，KV 缓存完整存储，只在第 4 层之后才开始压缩。消融实验证实了这一点（论文 Figure 7）：从第 0 层就压缩（$m=0$）精度最低，延迟到 $m=4$ 有明显提升；延迟更久收益趋平，而压缩生效越晚、省的计算越少，所以 $m=4$ 是收益和节省的平衡点。

决策二：每个后续层都用观察窗口打分，滚动存入长度为 $n=4$ 的缓冲区。 从第 4 层开始，每一层 $l'$ 都用 prompt 末尾 $W=8$ 个 token 的 query 给全部 prompt key 打分——这就是 FastKV 式打分，但不是只在一个层打分，而是每层都打、存进一个滚动缓冲区。对 token $i$ 和第 $l'$ 层，层内分数为：

每个符号逐一对应：$j$ 遍历观察窗口 $\mathcal{W}$（$W=8$ 个最靠后的 prompt token），$\mathbf{q}_{j}^{(l',h)}$ 是其中第 $j$ 个 token 在第 $l'$ 层第 $h$ 头的 query 向量（维度 $d_k$），$K_{\mathrm{prompt}}^{(l',h)}$ 是该层该头全部 $L$ 个 prompt key 组成的矩阵，Softmax 沿 key 维度归一化把原始 logit 变成概率分布，再对窗口内 8 个 query、全部注意力头求和。直觉：一个 token 被”最近上下文”的注意力覆盖得越多，它对接下来要生成的内容就越重要——与 FastKV 相同的信号源，但每层都采一次样。

决策三：在剪枝层 $l_p = 15$ 处，对缓冲区里 $n$ 层的分数取逐 token 最大值，作为最终排名。 聚合操作就一行：

$\mathcal{L}$ 是剪枝层往前数 $n=4$ 层构成的窗口，$l_p=15$ 意味着聚合第 12-15 层的分数。选 max 而非 mean/sum 的理由：只要 token 被窗口内任何一层判定为重要，它就留下——这直接对冲了图 2 里”单层塌陷”的风险；取平均反而会让某一层的强信号被其他层的弱信号稀释，与聚合的初衷相悖。

为什么剪枝层选第 15 层（32 层模型的中点附近）？消融（论文 Figure 6 左图）显示：剪枝越晚精度越高（FastKV 从层 3 的 32.5% 升到层 15 的 46.5%），因为浅层信息尚未构造完整；但剪枝越晚，前面省下的层数越少。第 15 层是”前面有一半层数享受了稀疏化收益、后面还有一半层数继承压缩结果”的折中点。注意压缩一旦在 $l_p$ 生效，之后所有层的序列长度都缩短了，KV 缓存也按同一套排名压缩——prefill 省下的计算和 decode 省下的显存/带宽来自同一个决策。

完整流程与开销#

CLAA 的完整前向（论文 Appendix D.5 的伪代码简化）：

1
def claa_prefill(model, prompt_tokens, pruning_layer=15,
2
                 aggregation_window=4, defer_layers=4,
3
                 window_size=8, keep_rate=0.2):
4
    hidden_state = model.embed(prompt_tokens)
5
    kv_cache = {}
6
    layer_scores_buffer = deque(maxlen=aggregation_window)
7

8
    for l in range(model.num_layers):
9
        # 前 defer_layers 层：不压缩，完整前向
10
        if l < defer_layers:
11
            hidden_state = model.layer_forward(l, hidden_state)
12
            kv_cache[l] = hidden_state.get_kv_pair()
13
            continue
14

15
        # 每层：用观察窗口打分，存入滚动缓冲区
16
        q_window = hidden_state.get_last_n_queries(n=window_size, layer=l)
17
        k_all, v_all = hidden_state.get_keys(l), hidden_state.get_values(l)
18
        current_scores = aggregate_attention(q_window, k_all, use_softmax=True)
19
        layer_scores_buffer.append(current_scores)
20

21
        # 每层：按本层分数压缩 KV 缓存（供 decode 使用）
22
        compression_indices = topk(current_scores, keep_rate).indices
23
        kv_cache[l] = gather(k_all, v_all, on_indices=compression_indices)
24

25
        # 完整隐藏状态继续前向（压缩只影响缓存，不影响计算路径）
26
        hidden_state = model.layer_forward(l, hidden_state, use_kv=(k_all, v_all))
27

28
        # 剪枝层：对缓冲区内 n 层分数取 max，得到最终排名并剪序列
29
        if l == pruning_layer:
30
            aggregated = max(layer_scores_buffer, dim=0)   # Eq.6
31
            pruning_indices = topk(aggregated, keep_rate).indices
32
            hidden_state = gather(hidden_state, on_indices=pruning_indices)
33

34
    return model.final_norm(hidden_state), kv_cache

三个容易被忽略的工程细节，值得展开：

1. 打分是廉价的。每一层只做一个 $W \times L$ 的注意力（8 个 query 对 $L$ 个 key），而主注意力是 $L \times L$——差两个数量级，而且打分用的 key 就是前向计算中已有的中间结果，不需要额外读取。论文实测，聚合窗口内所有层的打分合计占 TTFT 不到 2%。不需要改任何 CUDA kernel，FlashAttention-2 原样可用，这也是它能直接落地的关键。
2. 隐藏状态全量前向，只有 KV 缓存被压缩。与 FastKV 相同的”双轨”设计：每层压缩的是”存进缓存供 decode 用的 KV 对”，计算路径上仍是完整序列，这样第 $l$ 层的输出不受压缩影响，直到 $l_p$ 处一次性剪序列。这与 GemFilter”重跑一遍完整前向”（两遍式）在架构效率上是本质区别。
3. 保留原始位置 ID。剪枝后的 token 序列传给后续层时，必须带上它们在原 prompt 中的位置编号。因为 RoPE 位置编码是相对的——注意力分数只依赖两个位置的相对距离 $m-p$，而不是绝对位置。乱序或者重排位置编号会破坏相对距离，注意力语义就全错了。三种启发式和 oracle 的统一做法都是 position_ids = original_position_ids。

把 CLAA 放回图 1 的框架里看：它没有引入任何新信号源（还是观察窗口注意力），只是在”用哪几层”上做了文章——前 4 层不压缩，中间逐层采样，剪枝层取 max 聚合。论文的整条论证链是：oracle 诊断出单层不稳定 → CLAA 用跨层聚合修复 → 排名向 oracle 收敛 → 端到端质量保住 → TTFT 下降。

实验设置#

• 模型：Llama-3.2-3B-Instruct（28 层）、Llama-3.1-8B-Instruct（32 层）、Mistral-Nemo-12B-Instruct（40 层），覆盖三个规模。
• 基准：LongBench（16 个任务：单/多文档 QA、摘要、few-shot、代码、合成任务）；Needle-in-a-Haystack（把事实埋在 16K-64K 上下文的任意深度，测检索）；RULER（64K 上下文、12 个子任务、每子任务 500 样本，测检索/多跳/聚合/QA 四类能力）。
• 基线：GemFilter、FastKV、Speculative Prefill（草稿模型 Llama-3.2-1B-Instruct，$k=8$ 个 lookahead token）、Full KV（不剪枝）。所有方法统一跑在 HuggingFace + FlashAttention-2 栈上，统一保留率 {10%, 20%, 40%}，统一 1D 池化（kernel 7），统一贪心解码，A100-80GB 单卡。CLAA 默认 $l_p=15, n=4, m=4, W=8$。
• 保证公平的细节：保留率对”prefill 的序列剪枝”和”decode 的 KV 缓存压缩”一视同仁；FastKV 的 TSP 层与 GemFilter 的 routing 层都扫过 {3,7,11,15,19} 后统一取 15，和 CLAA 的剪枝层一致——比较的是”同样在第 15 层剪枝时谁的排名更好”，而不是”谁的超参调得更妙”。

LongBench 主结果#

论文 Table 1 是 LLaMA-3.1-8B 在 16 个 LongBench 任务上的完整数据，三种保留率各一张。10% 保留率下各方法的平均值（Full KV 是 49.32）：

读法：Oracle 只比 Full KV 低 1.49 分——这告诉我们”只保留 10% token”这个约束本身的代价就这么大，任何方法的天花板就在这；CLAA 离上界只有 0.7 分，比 FastKV 又近了 0.68 分。而 GemFilter 掉了 11.73 分、SpecPrefill 掉了 7.33 分——不是任务难，是它们的排名质量差。注意 SpecPrefill 用了额外的 1B 草稿模型、还生成了 8 个 lookahead token 去”偷看未来”，成绩反而垫底偏上——这个反直觉结果后面专门分析。

保留率放宽到 20% 时，CLAA 平均 48.12 分，超过了 FastKV 在 40% 保留率下的 47.68——也就是说 CLAA 用一半的 token 预算拿到了对方双倍预算才有的质量，压缩效率高出一个档。跨模型趋势一致（Table 2）：Mistral-Nemo-12B 上 CLAA 46.05 vs FastKV 45.62（10%）、Llama-3.2-3B 上 42.93 vs 42.45，CLAA 在每个规模上都更接近 oracle 上界。这一致的”收敛到上界”模式，正是论文想要证明的：跨层聚合确实补上了单层不稳定的洞。

检索类任务：Needle-in-a-Haystack 与 RULER#

检索任务最能暴露”排名把关键 token 丢了”的代价。Needle-in-a-Haystack 把一句事实埋在上下文的不同深度（0-100%），问模型能不能找出来。40% 保留率下（论文 Figure 3）：

图中每行是一个 needle 深度、每列是输出长度，绿色代表检索成功。三个可读出的模式：

• GemFilter 在中段（22%-44% 深度）集体失败。它只用最后一个 token 的 query 打分，而文档首尾的 token 天然与”最后位置”的注意力强（文档边界效应），中段的 needle 淹没在边界 attention 里。论文推测其 routing 层主要关注文档边界，错过了中段内容。
• SpecPrefill 漏掉文档后半段。1B 草稿模型的”未来 token”偏好文档前半的常见模式，后半段的稀有事实被打成低分。
• CLAA 全程保持检索率，平均分 0.909 为全场最高。跨层 max 聚合让”任何一层觉得重要”的 token 都能活下来——needle 这种强信号至少会被某一层的注意力捕捉到，单层方法则完全取决于选中的那层当时的状态。

RULER（64K 上下文、40% 保留率）同样支持这个叙事：CLAA 检索类 89.85、多跳推理类 87.72，都明显高于 GemFilter（82.23 / 58.20——多跳推理近乎腰斩）且逼近 Full KV（98.27 / 86.88）；FastKV 的检索 87.69 被 CLAA 超出 2.2 分。检索和多跳都要求”分布在上下文各处的事实被同时保留”，这正是单层排名最容易失手的场景。

因果预测的代价：为什么 SpecPrefill 的 lookahead 失灵了#

论文第 5.3 节回答一个更本质的问题：启发式与 oracle 的差距到底来自哪？答案：来自信息差——oracle 看见了答案，启发式看不见。这个差距随任务结构变化：

• TriviaQA（知识问答）：CLAA 10% 保留率下 92.37 分，oracle 91.43 分——启发式反超了上界（在噪声范围内）。因为 query 里直接点名了目标实体，prompt 本身就包含足够线索，不需要”知道答案”就能排出正确的重要性。
• Qasper（论文问答）：CLAA 42.36 vs oracle 43.94，差距明显。相关上下文依赖微妙的语境线索，不看答案猜不出来。

SpecPrefill 的失败也是这个框架的功劳：它用 1B 草稿模型生成的 8 个 token 去弥补信息差，结果 10% 保留率下只有 41.99，落后”什么都不猜”的 FastKV 4.8 分。1B 模型猜不出 8B 模型会注意什么——lookahead 补充的信息质量，抵不上它打分所在隐藏空间与主模型不匹配的损失。这个结论对”用小模型辅助大模型”这类思路是个重要警示。

效率与精度的权衡#

论文 Figure 4 把每个方法在 10k token prompt 上的 LongBench 精度和 TTFT 画成散点（每个方法 10%/20%/40% 三个点）：

横轴 TTFT、纵轴精度，每个点代表一个（方法，保留率）组合。三种保留率下 CLAA 的点都贴着 oracle 的”上界曲线”，而 GemFilter 与 SpecPrefill 在同样 TTFT 下精度明显更低——同样的加速换来更多的质量损失。具体数字：10% 保留率下 CLAA 把 TTFT 从约 900 ms 压到约 550 ms，降幅 39%，同时保住 47.13 分（接近上界 47.83）。这 39% 就是本文标题里的核心数据，注意它来自”10k token 的 prompt 只算 10% 的 token”这个极端配置。

论文 Figure 5 给出端到端分解（10k token prompt + 32 token 生成），顺带解释了各方法 KV 缓存的差异：

柱状图是 prefill（TTFT）与 decode 的时间分配，标注了 decode 吞吐和 KV 缓存大小。两组值得注意的细节：

• CLAA 前 4 层不压缩，KV 缓存只比 oracle 略大：10% 保留率下 0.3 GB（oracle 0.1 GB），换取的是浅层完整表示带来的精度提升——论文认为这是明确划算的交换。
• GemFilter 的 KV 缓存反而最大（1.3 GB），decode 吞吐只有 16 tps，比其余方法（19-20 tps）低一截。原因在实现：GemFilter 保留完整缓存、解码时按索引取用，缓存没真正变小，decode 带宽收益落空。这正体现了”排序质量 × 架构效率”要分开评估——它的排名本来就垫底，架构实现还更贵。

与语义压缩方法的对比#

语义压缩是另一条路线：先让小模型改写 prompt 再喂主模型。论文用 Selective Context（Li 等，EMNLP 2023）和 LLMLingua（微软，ICML 2024）做对照，在三个任务上比端到端 TTFT（改写耗时 + prefill 耗时，论文 Table 4）：

两个结论。其一，改写开销吃掉了一切：Selective Context 在三个任务上全部比 Full KV 慢（0.29x-0.88x），LLMLingua 只在最长的 GovReport 上勉强快过 1x。改写是自回归生成，耗时是”秒”级的，而 prefill 本身不过几秒——单次查询场景里这条路不划算。其二，CLAA 在所有任务上同时拿下速度（1.34x-1.45x）和精度（与 Full KV 差距 4% 以内；TriviaQA 上 0.944 分与 Full KV 持平）。语义压缩的优势场景是改写结果可复用的批处理/多查询场景，单次推理则明显输给 token-ranking 家族。

消融：设计空间里的每个选择都被数据钉住了#

论文 Figure 6 汇总了两组消融：

• 左图（剪枝层 $l_p$）：所有方法都随 $l_p$ 后移而提升——FastKV 从层 3 的 32.5% 涨到层 15 的 46.5%。CLAA 在每一个测试层上都压过 FastKV 和 GemFilter，尤其在浅层：层 3 时 CLAA 已明显拉开差距。这说明跨层聚合不只是”在默认配置下有用”，而是对剪枝层位置本身就有鲁棒性——即使被迫在浅层剪，聚合缓冲的若干层信号也比单层强。
• 右图（聚合窗口 $n$）：从 $n=1$（退化为单层，等价于一个”每层都试试、只留一层”的 FastKV）扩到 $n=2$，各保留率下精度都显著提升——这是论文核心假设的直接验证：跨层聚合确实修复了单层不稳定的问题。$n$ 继续增大，20%/40% 保留率下在 $n=4$ 附近稳定；10% 激进保留率下波动较大、峰值出现在 $n=2$。论文选 $n=4$ 是”各保留率下都稳健”的折中。
• 附录的 $m$ 消融（Figure 7）：延迟压缩层从 0 到 4 精度递增，$m=0$（第一层就开始压缩）最差——模型在最需要完整输入构造表示的浅层被阉割，代价比想象中大。$m=4$ 之后收益趋平。

一个连贯的设计叙事浮现出来：浅层要完整（$m=4$）、中层要多采样（每层打分）、决策层要聚合（$n=4$ 的 max）——三件事全部服务于同一个目标：让排名不依赖任何单一层的状态。