《AI Agent 技术原理与架构·模型、推理与能力边界》4.3 上下文长度、注意力复杂度与成本曲线

长上下文的成本不是一条曲线,而是两条:注意力的计算随长度二次增长,KV Cache 的读取随长度线性增长。本节用缩放关系与一个 64K token 的算例,说明什么时候二次项主导、什么时候线性项主导,以及为什么 FlashAttention 降低的是显存访问而不是计算量。

以下数字为教学示例,不构成对任何真实模型或供应商性能的承诺。

“上下文越长越好”是一个昂贵的直觉。上下文从 1K 增到 64K,token 数变成 64 倍,但注意力的计算量变成约 4096 倍,KV Cache 的读取量变成 64 倍。两条曲线一起决定成本:短上下文时线性项可能占主导,长上下文时二次项迅速压过一切。

这一节用两个缩放关系说明成本曲线,然后讨论三个架构问题:长上下文什么时候值得、FlashAttention 改变了什么、上下文预算应该怎么分配。

两条曲线

注意力计算:对长度 $n$、维度 $d$ 的序列,$QK^\top$ 和 $AV$ 两个矩阵乘的浮点运算量约为:

$$
\text{FLOPs} \approx 4 \cdot L \cdot n^2 \cdot d
$$

其中 $L$ 是层数。$n^2$ 来自“每个 token 都要和每个 token 计算相似度”。

KV 读取:decode 每生成一个 token,都要读取完整的 KV Cache。规模为:

$$
\text{Bytes} \approx 2 \cdot L \cdot H_{kv} \cdot d \cdot n \cdot \text{bytes_per_element}
$$

这是线性的:序列翻倍,读取量翻倍。

两条曲线的差别在长上下文时最明显。$n$ 从 1K 到 64K,注意力计算是 4096 倍,KV 读取是 64 倍。这不是说 KV 读取不重要;在 decode 阶段,KV 读取可能才是瓶颈,因为它受内存带宽限制。两条曲线对应两个不同阶段:prefill 更偏计算,decode 更偏带宽。

最小实验:缩放关系与一个 64K 算例

下面的实验实现两个成本函数,并输出从 1K 到 64K 的缩放倍数。它还计算了 64K token、32 层、128 维、8 个 KV 头的一个算例,用来观察绝对量级。

# file: agp_lab/context_cost.py | write
# tier: 2
# verify: python3 -m unittest tests.test_context_cost
"""上下文长度的成本曲线:注意力二次项与 KV 线性项。"""
from __future__ import annotations


def attention_flops(tokens: int, head_dim: int, layers: int = 1) -> int:
    """只算 QK^T 与 AV 两个矩阵乘:约 4 * n^2 * d 每层。"""
    if tokens < 0 or head_dim <= 0 or layers <= 0:
        raise ValueError("参数不合法")
    return 4 * layers * tokens * tokens * head_dim


def kv_read_bytes(
    tokens: int,
    layers: int,
    kv_heads: int,
    head_dim: int,
    bytes_per_element: int = 2,
) -> int:
    """decode 每步要读完整 KV Cache,规模与 token 数线性相关。"""
    if min(tokens, layers, kv_heads, head_dim, bytes_per_element) < 1:
        raise ValueError("参数不合法")
    return 2 * layers * kv_heads * head_dim * tokens * bytes_per_element


def scaling(new_tokens: int, base_tokens: int) -> dict[str, float]:
    if base_tokens <= 0:
        raise ValueError("base_tokens 必须为正")
    ratio = new_tokens / base_tokens
    return {"tokens": ratio, "attention": ratio ** 2, "kv": ratio}


if __name__ == "__main__":
    base = 1024
    print("tokens  attention_x  kv_x")
    for tokens in (1024, 4096, 16384, 65536):
        row = scaling(tokens, base)
        print(f"{tokens:<7} {row['attention']:>11.0f} {row['kv']:>6.0f}")
    print("flops@64k:", attention_flops(65536, 128, layers=32))
    print("kv_bytes@64k:", kv_read_bytes(65536, 32, 8, 128))

运行:

cd private/labs/agp-lab
python3 -m agp_lab.context_cost

输出:

tokens  attention_x  kv_x
1024              1      1
4096             16      4
16384           256     16
65536          4096     64
flops@64k: 70368744177664
kv_bytes@64k: 8589934592

从 1K 到 4K,注意力计算涨 16 倍,KV 读取涨 4 倍;到 64K,差距扩大到 4096 倍对 64 倍。这个对比说明:上下文长度的成本不是线性的,也不是单一维度的。 如果只按 token 数估算成本,会低估长上下文的 prefill 开销;如果只按显存估算,会低估 decode 的带宽压力。

64K 算例的绝对数字是 70.4 TFLOPs 和 8 GiB KV 读取。它们不是实测值,只是公式结果;真实系统的有效吞吐还受批处理、并行策略、内存带宽和内核实现影响。实验的价值在于量级感:64K 不是“多一点点上下文”,而是一个不同的成本区间。

FlashAttention 改变了什么

FlashAttention(Dao et al. 2022)常被误解为“把注意力从二次降到线性”。它没有。它做的是IO-aware 的分块计算:把注意力计算切成适合片上内存的小块,减少对高带宽显存的读写,从而在相同 FLOPs 下更快、更省显存。

说法是否正确说明
FlashAttention 把复杂度降到 O(n)否计算量仍是 O(n²),减少的是内存访问
FlashAttention 让长上下文免费否显存和计算仍然随长度增长
FlashAttention 改善训练/推理速度是减少 IO,提高硬件利用率
FlashAttention 改变注意力语义否数学上等价,差异在数值精度

这个区分对架构很重要:如果团队以为“用了 FlashAttention 就没有二次成本”,就会低估长上下文的预算。正确的说法是:“FlashAttention 让二次计算更可行,但二次项仍然存在。”

长上下文什么时候值得

不是所有任务都需要长上下文。可以用一张表判断:

场景长上下文是否值得原因
需要跨文档综合、引用关系复杂可能值得检索难以覆盖跨文档依赖
单文档问答、事实定位通常不值得检索 + 短上下文更便宜、更准
代码仓库级修改视任务而定需要跨文件依赖,但可以用检索 + 结构化索引
多轮对话历史通常不值得全量保留摘要 + 关键事实 + 检索更可控
审计与合规可能需要完整上下文但可以用离线归档,不必每次放进推理

这张表的核心是“检索能不能替代”。如果检索能稳定召回相关片段,短上下文加引用校验通常比长上下文更便宜、更容易审计;如果任务依赖跨文档的全局关系,检索可能漏掉关键连接,长上下文才有优势。长上下文是检索的补充,不是替代。

架构含义

上下文成本对 Agent 架构有四个直接约束:

  1. 上下文预算要分层。 系统提示、任务、检索文档、历史、工具结果各占多少 token,要有上限和淘汰规则。
  2. 长上下文要有质量评测。 成本曲线只说明“更贵”,不说明“更好”;要在目标长度上测召回和任务成功率。
  3. 检索优先于拼接。 能检索到的内容不要全量拼接;检索的召回率要用引用核对验证。
  4. 缓存要利用前缀复用。 稳定前缀可以复用 KV,降低重复 prefill;变化内容后置,避免缓存失效。

第 1 条是很多系统缺失的。上下文预算通常以“最大 token 数”的形式存在,但没有分配规则:系统提示占多少、检索占多少、历史占多少、留多少给输出。没有分配,长文档一来就会挤掉历史,或者历史一长就挤掉检索,行为不可预测。

架构判据

判据合格的样子不合格的样子
预算有分配各段上下文有 token 上限与优先级只设总上限
长度有评测目标长度上的召回率与成功率只测短上下文
检索有核对引用与原文可逐条比对只看答案流畅度
成本有分解prefill 与 decode 成本分开估算只按 token 单价算
缓存有设计稳定前缀复用,变化内容后置每次全量重算

这些判据里,“成本有分解”最容易被忽略。很多团队按“每百万 token 单价”估算成本,但长上下文的成本不只是输入 token 价格:prefill 的计算时间、KV 的显存占用、decode 的带宽压力都会影响容量和延迟。单价只是账单的一部分。

prefill 与 decode 的成本分解

同一个 64K 请求,prefill 和 decode 的成本结构不同:

阶段主要成本随长度如何变优化手段
Prefill注意力矩阵乘、KV 写入约 O(n²)前缀缓存、截断、检索
DecodeKV 读取、内存带宽每步 O(n),总 O(n·输出)GQA、量化、批处理

这解释了为什么“长上下文 + 长输出”特别贵:prefill 付二次项,decode 付线性项乘以输出长度。两个因子相乘,成本迅速失控。

一个 64K 请求的成本账

假设输入 64K token、输出 1K token、32 层、d=128、8 个 KV 头:

  • prefill 注意力约 70.4 TFLOPs;
  • decode 每步读取约 8 GiB KV,1K 步就是 8 TiB 的读取量;
  • 如果有效带宽是 2 TB/s,仅 KV 读取就需要约 4 秒(理想下限)。

这个算例是数量级估算,不是实测。它说明:长上下文的 decode 成本可能被低估,因为人们常只算输入 token 的单价,忽略每步都要读一遍 KV。

上下文预算的分配算法

一个可执行的分配顺序:

  1. 先扣系统提示与工具定义(稳定、必需);
  2. 再扣用户问题与当前工具结果(必需、短);
  3. 给检索文档分配上限,按相关度排序;
  4. 给历史对话分配上限,优先保留关键事实;
  5. 留出输出预算,不能把上下文塞满。

每一步都要有上限和淘汰规则。没有分配顺序,长文档一来就会挤掉历史,历史一长就挤掉检索,系统行为随输入长度剧烈变化。

FlashAttention 的适用边界

FlashAttention 在以下情况收益明显:

  • 序列较长,注意力矩阵无法完整放入片上内存;
  • 训练或 prefill 阶段,计算密集且内存访问多;
  • 硬件支持高效的片上内存与异步拷贝。

它不会改变:

  • O(n²) 的计算量;
  • 长上下文的显存总量;
  • 检索是否能替代长上下文。

把 FlashAttention 当成“长上下文免费”的理由,是架构评审里常见的误判。

长上下文与 RAG 的决策表

条件倾向长上下文倾向 RAG
文档集合小、稳定、需整体理解大、动态、只需片段
查询跨文档综合单点事实
更新频率低高
延迟预算宽松紧
可追溯性要求一般要求逐条引用

两者不是互斥的:可以用 RAG 选文档,再把选中的文档放进长上下文;也可以用长上下文做综合,再用引用定位来源。决策的关键是算清“多读的 token”是否换来了足够的质量提升。

上下文腐化

长上下文不保证模型真的用到所有内容。随着输入变长,关键信息可能被稀释,模型对中间位置的召回下降,这种现象常被称为“上下文腐化”(context rot)。缓解手段包括:把关键约束放在靠近使用位置、显式编号、重复关键指令、用结构化格式分隔文档。这些手段都不能根治,只能降低风险;最终仍要靠评测确认模型在目标长度上的实际表现。

小结

  • 长上下文有两条成本曲线:注意力计算约 O(n²),KV 读取约 O(n),两者对应 prefill 与 decode 的不同瓶颈。
  • 从 1K 到 64K,注意力计算约 4096 倍,KV 读取约 64 倍;只按 token 数估算会低估长上下文成本。
  • FlashAttention 减少内存 IO,不改变 O(n²) 的计算量;它让长上下文更可行,不等于免费。
  • 长上下文只在检索难以覆盖跨文档依赖时才有优势;单文档问答和事实定位通常用检索更便宜。
  • 上下文预算要分层分配:系统提示、任务、检索、历史、工具结果各有上限和淘汰规则。
  • 成本要分解到 prefill 与 decode;token 单价只是账单的一部分。

阅读导航:上一节:4.2 KV Cache:显存、批处理与并发上限 · 下一节:5.1 SFT:指令跟随能力从哪来 。

常见错误与边界

  1. 把 FlashAttention 当线性复杂度。 它减少 IO,不减少 O(n²) 计算;长上下文仍然昂贵。
  2. 只按 token 单价估算成本。 prefill 计算、KV 显存和 decode 带宽都会影响容量与延迟。
  3. 用长上下文替代检索。 检索能覆盖的场景,短上下文加引用校验通常更便宜、更易审计。
  4. 只设总上下文上限。 没有分层预算,长文档会挤掉历史,历史会挤掉检索,行为不可预测。
  5. 只测短上下文。 长上下文的效果需要在目标长度上评测;平均分不能代表 64K 表现。
  6. 忽略前缀缓存。 稳定前缀可以复用 KV;每次全量重算会浪费 prefill 成本。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图