有一个很典型的现场:客服知识库里,退款政策的适用范围写在第一段,后面跟了十几页细则。用户问「买了三个月还能退吗」,模型答得斩钉截铁,但引用的条件对不上。你把同一段资料挪到最后再试,它又答对了。看起来像模型「没看见」第一段,可那段文字明明在输入里,token 一个不少。

另一个现场更现实:模型号称支持 128K,团队把整本手册塞进去,前两周效果不错,月底账单出来,输入 token 数量翻了几十倍,首 token 延迟也肉眼可见地变长。上下文不是免费的容量,长度每加一倍,注意力的计算和缓存都要跟着涨,而模型对长文里不同位置的注意力并不是平均分配的。

先分清位置、长度和记忆

注意力机制本身只看内容,不看顺序。把「狗咬人」和「人咬狗」的词序打乱,如果没有任何位置信息,模型算出来的注意力分数是一样的。位置编码就是给每个 token 附加一个「你在第几位」的信号,让模型能区分先后。没有它,上下文只是一袋词。

上下文窗口是模型一次能接收的最大 token 数,超过就会被截断或者直接报错。记忆则是另一回事:它指模型能不能在多次请求之间保留信息。窗口大,只代表这一轮能塞进去的内容多;下一轮开新会话,之前的 KV cache 通常已经丢了。把 128K 窗口当成「记住了 128K」,是很多需求评审里的第一个误会。

位置编码:告诉模型每个 token 在第几位,决定顺序感
注意力:按相关性从上下文里取信息,成本随长度平方增长
KV cache:把算过的键值存下来避免重复计算,显存随长度线性增长

还有一个容易混淆的单位:上下文长度按 token 算,不按字数算。中文一个字通常接近一个 token,但英文单词、标点、特殊符号的切分规则不同,同一段文字在不同分词器下的 token 数可能差不少。评估容量时要以实际分词结果为准,不要拿字符数拍脑袋。

绝对位置与相对位置

绝对位置编码给每个位置一个固定的向量,第 1 位一个向量,第 2 位另一个,像给每个座位贴上编号。模型训练时见过哪些编号,推理时就只认识哪些编号。训练最长 4K,突然来一段 32K,后 28K 的位置编号模型从来没见过,表现自然掉。可学习的位置表还有个别扭之处:同一句话出现在开头和结尾,拿到的是两套完全不同的位置向量,模型很难把「这句话的意思」和「它在哪里」分开。

相对位置编码不关心绝对编号,只关心两个 token 隔了多远。注意力打分时加一个跟距离有关的偏置,距离近的给一点加分,距离远的给一点减分。这样模型学的是「前后关系」而不是「座位号」,换长度时更从容。缺点是实现更复杂,不同层、不同头的距离偏好也不一样。

早期的正弦位置编码是固定公式,不需要学习,理论上能算到训练外的位置;但模型没见过那么远的组合,实际效果仍然会掉。固定公式解决的是算不出来的问题,解决不了没学过的问题。

现在主流模型用的旋转位置编码,通常叫 RoPE,可以看成相对位置思路的一种巧妙实现。它不额外加位置向量,而是把每个 token 的查询向量和键向量按位置旋转一个角度。位置越靠后,旋转角度越大。两个向量做点积时,角度差正好对应位置差,于是「相对距离」被编码进了相似度里。

RoPE 到底转了什么

把一对维度看成平面上的一个点,位置每增加一位,就把这个点转一个小角度。不同维度对转的速度不一样:靠前的维度转得快,靠后的转得慢,合起来能区分近距和远距。查询和键都转,点积的结果只跟两者的角度差有关,也就只跟它们的位置差有关。这就是它能表达相对位置的原因。

这个设计的好处是没有一张「位置查找表」。训练时没见过 32K 的位置,不代表角度算不出来,旋转公式对任意位置都成立。但「算得出来」不等于「学得会」:模型在 4K 长度上训练,注意力头从没见过那么远的距离该关注什么,直接拉到 32K,分数会变得很平或者很乱。外推能力是训练分布和位置缩放共同决定的,不是公式自带的。

还有一个常被忽略的点:位置编码只影响注意力打分,不改变 token 本身的语义向量。两个 token 内容相同、位置不同,进入注意力的查询和键会因为旋转角度不同而不同,但它们的值向量还是原来的内容。理解这一点,就不会把位置编码当成「给每个词加一段说明」,它改的是相互比较的方式。

长上下文模型常见的做法是调整旋转的底数,或者把位置按比例压缩,让 32K 的位置落在训练时见过的角度范围内。不同模型的实现细节差别很大,具体配置要以模型卡和代码为准;换一个模型就照搬参数,很容易出问题。

成本:注意力分数与 KV cache

先算注意力分数矩阵。单层、单头、单样本,序列长度 n,分数矩阵有 n 的平方个元素。全模型还要乘层数和头数。实际推理中,很多实现不会把整张矩阵写进显存,而是分块计算,所以这个数字代表计算量和逻辑规模,不等于真实显存占用。再看 KV cache:每个 token 都要为每一层、每个头保存一份键和一份值,元素数是 2 乘层数乘头数乘头维度,乘上序列长度和批大小,再乘数据类型字节数。

下面是一段纯算术估算,假设 32 层、32 个头、头维度 128、批大小 1、fp16 每个元素 2 字节。它不涉及任何真实模型,也没有在本机跑过推理,只是把公式代进去。

layers, heads, head_dim, batch, bytes_per = 32, 32, 128, 1, 2
print("假设配置:layers=%d heads=%d head_dim=%d batch=%d dtype=fp16(%dB)" %
      (layers, heads, head_dim, batch, bytes_per))
print("%8s %18s %20s %16s %10s" %
      ("序列长度", "单层单头分数元素", "全模型分数元素", "KV cache字节", "KV cache GiB"))

for n in (1024, 8192, 32768, 131072):
    per_head = n * n
    total = per_head * layers * heads * batch
    kv = 2 * layers * heads * head_dim * bytes_per * n * batch
    print("%8d %18d %20d %16d %10.2f" %
          (n, per_head, total, kv, kv / 1024**3))

kv_per_token = 2 * layers * heads * head_dim * bytes_per * batch
print("128K 时每个 token 的 KV cache = %d 字节 = %.2f MiB" %
      (kv_per_token, kv_per_token / 1024**2))
print("128K 个 token 合计 = %.0f GiB" % (kv_per_token * 131072 / 1024**3))
print("1K 到 128K:序列长度 128 倍,注意力元素数 %.0f 倍,KV cache %.0f 倍"
      % ((131072 / 1024) ** 2, 131072 / 1024))
假设配置:layers=32 heads=32 head_dim=128 batch=1 dtype=fp16(2B)
    序列长度           单层单头分数元素              全模型分数元素       KV cache字节 KV cache GiB
    1024            1048576           1073741824        536870912       0.50
    8192           67108864          68719476736       4294967296       4.00
   32768         1073741824        1099511627776      17179869184      16.00
  131072        17179869184       17592186044416      68719476736      64.00

128K 时每个 token 的 KV cache = 524288 字节 = 0.50 MiB
128K 个 token 合计 = 64 GiB
1K 到 128K:序列长度 128 倍,注意力元素数 16384 倍,KV cache 128 倍

这组数字最刺眼的地方是两条曲线不一样。长度涨 128 倍,KV cache 涨 128 倍,是线性;注意力分数元素涨 16384 倍,是平方。短文本时两者都不算什么,到了 128K,KV cache 一个人就吃掉 64 GiB,还没算模型权重和中间激活。这也是为什么长上下文服务要么限制并发,要么把 KV cache 分页、量化、换到更便宜的存储上。

真实服务里还会用分页管理 KV cache,把连续的缓存切成固定大小的块,按需分配,减少碎片。它不改变总字节数,但能让并发更稳。批大小也要算进去:4 路并发就是 4 份 KV cache,显存压力直接乘 4。规划容量时按最坏情况算,别按平均长度算。

延迟也会跟着变。首 token 阶段要把整段提示算一遍,提示越长,首 token 越慢;生成阶段每出一个 token 都要读一遍 KV cache,上下文越长,每个 token 越慢。账单上的输入 token 数是线性计费,但机器上的显存和带宽压力不是线性感受,这就是「越用越贵越慢」的来源。

中间遗忘:为什么第一段反而被忽略

公开研究里反复出现过一种现象:把关键信息放在长文开头或结尾,模型找得比较准;放在中间,准确率明显下降,曲线像字母 U。大家把它叫做「中间遗忘」。它不是你一个人的模型问题,也不是玄学,和注意力怎么分配、训练数据里长文的分布都有关系。本机没有跑真实长上下文模型复现这条曲线,这里讲的是机制和工程应对。

一个解释是注意力预算被稀释。上下文越长,每个 token 能分到的注意力越少,中间的 token 既没有开头的「首位优势」,也没有结尾的「最近优势」,更容易被平均掉。另一个解释来自训练数据:多数文档的关键结论就在开头或结尾,模型学到的先验也是「重点在两头」,中间段落被当成过渡内容。还有实现层面的因素,位置缩放、窗口截断、缓存淘汰都会改变模型实际看到的内容。

工程上不用等理论定论。关键约束在开头写一遍,结尾再复述一遍;要求模型先引用原文再回答;把长文档切成几段,每段单独提问,最后汇总。这些做法不能根治中间遗忘,但能把关键信息放到模型更容易注意到的位置,成本也低。

还有一个低成本技巧:让模型先复述关键句,再给结论。复述相当于把中间信息重新拉到输出端,模型必须再注意一次。对格式要求高的场景,可以要求它先列出引用段落编号,减少凭空作答。这些提示都不改变模型结构,只是把注意力往你希望的位置引。

外推与训练长度,不是一回事

训练长度决定了模型见过什么,推理长度决定了你现在让它处理什么。两者之间的差距,就是外推。训练 4K 的模型直接吃 32K,位置编号或旋转角度落在没见过的区间,注意力分数会失真。位置插值把长位置压缩到短区间,频率调整改变旋转速度,这些方法能让模型「勉强看懂」更长输入,但通常需要少量继续训练或校准,否则能力会打折。

更关键的是,长上下文不等于长记忆。一次请求里的 128K,请求结束就没了;下一次对话,模型不记得上次说过什么。想在多轮里保持信息,要么每轮把关键内容重新放进提示,要么用外部存储做检索,要么依赖服务商提供的会话缓存。三者都不是「模型自己记住了」,只是把内容又送了一遍。

有些模型用滑动窗口注意力,只让每个 token 看最近的一段,计算量降下来,但远处的信息只能通过层层传递间接到达,容易丢。窗口大小和层数共同决定有效感受野,标称 128K 不代表每个 token 都真的看到了 128K。看到「支持长上下文」的宣传,先问它是全注意力、稀疏注意力还是滑动窗口,实际能力差别很大。

别用「支持 128K」当作「能稳定处理 128K」。厂商标称的是最大窗口,不是每个位置都同等有效。你的任务在 32K、64K、128K 上的通过率要分别测,找到实际可用的拐点,再决定线上限制。

长上下文和检索,怎么选

检索增强

先把文档切块、建索引,按问题取回最相关的几段,再交给模型。输入短、成本低、响应快,还能给出引用。代价是多了一套检索系统,切块和召回没做好时,答案会缺关键上下文。

长上下文

把整份资料直接塞进去,少一层检索,跨段落的关联更容易保住。代价是 token 成本、显存和延迟都随长度上涨,中间位置的信息还可能被忽略,超长时甚至要截断。

实际项目里很少二选一。常见组合是先用检索把范围缩到几份文档,再把这几份完整放进较长的上下文,既控制成本,又避免切块把上下文切断。如果任务需要跨很多文档做全局归纳,长上下文更合适;如果是海量知识库里的精确问答,检索仍然是主力。

切块大小也要配合任务。问答类按段落切,摘要类按章节切,代码按函数切;切得太碎会丢上下文,切得太大会浪费召回预算。检索回来的段落最好保留原文顺序和标题,模型判断相关性时要用到这些线索。

选择标准可以落到三个数:单次请求的输入 token 上限、可接受的首 token 延迟、每千次问答的预算。三个数定下来,方案基本就定了。只谈效果不谈成本,最后一定会在账单上补课。

出了问题先看哪里

现象真实原因第一步查什么
关键段落在开头却答错长文注意力稀释,或提示被截断打印实际送入的 token 数与截断位置
同一资料放结尾就答对中间位置的信息更容易被忽略把关键约束在开头和结尾各放一次
扩到 128K 后首 token 很慢预填阶段计算量随长度增长分别记录首 token延迟与每 token 延迟
并发一高就爆显存KV cache 随长度和并发线性增长算每 token 的 KV 字节数,核对并发上限
训练 4K 的模型直接上 32K 就乱位置外推没做,模型没见过该距离查模型卡标称长度与位置缩放配置
新会话记不住上一轮只有窗口,没有跨请求记忆确认是否每轮重放关键历史
长文问答引用错段落检索召回错了,或段落编号对不上先看检索结果,再看模型引用

边界与代价

长上下文的第一层代价是钱。输入 token 按量计费,把整本手册塞进去,每次提问都重复付一遍。第二层代价是时间,首 token 延迟变长,交互式产品的体验会明显变差。第三层代价是显存,KV cache 挤压并发,能同时服务的人变少。三层加起来,很多时候「直接塞全文」并不比「检索几段」划算。

还有质量上的非线性。长度增加,模型不一定能等比例利用新增信息;有些任务在 8K 时最稳,到 32K 反而下降。位置编码的外推、训练数据的长度分布、注意力实现,都会影响这条曲线。评估时要按长度分档,不要只测一个最大值。

还要注意服务端的截断策略。有的接口超长直接报错,有的静默截掉中间或末尾,有的从开头截。你以为全文都进去了,实际可能只剩一半。上线前用一段带标记的长文本测一次,确认截断位置,并把这个限制写进产品提示,别让用户以为系统看完了全部资料。

最后是可控性。长上下文把更多内容交给模型自己挑,出了错很难定位是没看到、看错了还是没按指令。检索方案至少能告诉你「喂了哪几段」,排错路径更短。对需要审计的场景,这一点比省下的工程复杂度更重要。

当天能验证的练习

  1. 拿一段 8K 左右的资料,把关键句分别放在开头、中间、结尾,各问同一个问题,记录三次答案是否引用正确。
  2. 用本文脚本改几个参数,算出你目标模型的每 token KV 字节数,再乘上计划并发数,看显存够不够。
  3. 把同一份资料分别用「全文塞入」和「只取前三段」跑一遍,记录输入 token 数、首 token 延迟和答案质量。
  4. 找一个标称长上下文的模型,分别在 4K、16K、32K 输入下问同一类问题,找出通过率开始下降的长度。
  5. 开两个新会话,先告诉模型一个名字,再换会话追问,确认它是否记得,并把结果记进笔记。

上下文决定了模型这一轮能看到多少、能注意哪里;但看到不等于答对。同一个上下文、同一套权重,换个温度、换个采样策略,输出就可能完全不同。下一篇从「同一句提示今天答对明天答错」讲起,拆开温度、top-p、随机种子和结构化输出的实际机制。