你的问题只是一小块

你打进输入框的那句话被包进了一份大得多的文档,模型看到的是整份。

模型收到的是一整份临时组装的文档。你的那句话通常是里面最小的一块。

这份文档里塞了六样东西:一段由 AI 公司写的行为说明书(告诉模型该怎么表现)、模型能调用的各种工具的说明书、从过去对话里存下来的记忆、从资料库里捞出来的相关文档、到目前为止的全部对话记录,最后才是你刚打的这句话。

决定往里塞什么、按什么顺序塞、什么该扔掉,这门手艺叫 context engineering(上下文工程,即为模型准备输入材料的技术)。它比往箱子里装东西难得多。模型的注意力有限,每多塞一点,精度就掉一点。

掉得很缓慢,不会突然崩。文档越长,答案越不准,哪怕问的是很简单的问题。

这解释了一件怪事:两个产品用的是同一个底层模型,你问一模一样的问题,得到的答案可能完全不同。模型是同一个,包在问题外面的那份文档不一样。

各家公司连什么时候去搜集材料都不一样。有的一上来就把所有可能用到的东西全捞进来;有的只给模型一堆线索,文件路径、存好的查询语句,让它边干边取。前者快,后者省。

组装好的文档 真正送进模型的东西 行为说明书 AI 公司写的指令 装入 工具说明书 能调用什么、要什么输入 装入 过往记忆 从早先会话存下来的 装入 检索到的资料 从资料库捞出来的文档 按需装入 全部对话记录 每轮都完整重发 装入 你刚打的那句话 通常是最小的一块 装入
你打的那句话只是六样成分之一,而且通常是最小的一样。检索资料画成虚线,因为有的产品一次全捞、有的让模型边干边取。

它每次都在失忆

模型对上一句话毫无记忆,你看到的对话历史,每一轮都要从头重发一遍。

模型是无状态的,两条消息之间,它什么都不留。每一次请求到达时,它都不记得之前发生过什么。

屏幕上那条越来越长的对话,是每一轮都被完整重建、完整重发的。

算一下账就不舒服了。假设一个产品的行为说明书有 1000 个字符单位,你每句话和它每句回复各约 100 个:第一轮要处理 1100 个,第二轮 1300,第三轮 1500,到第二十轮已经接近 4900。

输出的单价比输入贵,但输入的量每一轮都在滚雪球,输出却基本恒定。所以在任何聊天类产品里,花钱的大头通常是那个单价更便宜的输入。

最笨的办法是每次全部重发。短对话没问题,一旦聊到超出模型的容纳上限就走不下去了。有三种改法:

  1. 直接扔掉最老的几轮。不费时间,但扔掉的就找不回来了。
  2. 把之前的对话压缩成摘要,然后从摘要重新开始。这样能保住已经做过的决定和还没解决的问题,同时丢掉那些没人需要看第二遍的东西。
  3. 把材料整个存到模型的视野之外,等到相关时再取回来。

所以长对话会变慢、变贵,助手也会渐渐忘事,因为总有细节在被裁掉或压缩。还有一件事:你回头去编辑之前发过的某条消息,等于改写了模型认为「发生过」的事实。

每轮需要处理的 token 数 第 1 轮 约 1,100 说明书 1000 + 你的一句话 100 第 3 轮 约 1,500 第 20 轮 约 4,900 是第 1 轮的 4.5 倍
同一个产品,你只是多聊了十九轮,每轮要处理的量就涨到 4.5 倍——因为每轮都在把整段对话重读一遍。数字出自原文示例(1000 token 说明书,每条消息与回复各约 100 token)。

答案生成前先过安检

在模型开口之前,另一个更小的模型先读一遍你的请求,判断该不该放行。

组装好的文档不会直接送到模型手里。它先经过一个独立的、更小的模型,专门训练来判断这个请求该不该继续。

关键在于它是独立的。这个安检层和主模型是两套系统,可以单独重新训练、单独调参、单独监控,完全不影响主模型。它能做的也不只是放行或拦截:它可以把请求转到别处、记录下来,或者标记出来交给人审。

这道工序要花时间,你感受到的那个停顿里就有它的一份。某个生产系统公开过的数字:早一代的这类判断器会让算力消耗多出约 24%,同时让本来无害的请求被误拒的比例上升 0.38 个百分点。两个数字都高到限制了它的铺开范围。

替代方案是分级筛查:先用一个极便宜的检查扫过所有流量,只有被标记出来的对话才送去那个昂贵的判断器。这么一改,额外算力降到约 1%,无害请求的误拒率降到 0.05%。

改造前 改造后 额外算力 约 +24% 约 +1% 无害请求误拒率 +0.38 个百分点 0.05% 检查方式 全部流量走贵的 先便宜筛一遍
同一道输入安检,从'所有请求都送进昂贵判断器'改成'先廉价筛一遍、只有可疑的才深查',算力开销降到约二十四分之一。数字来自原文引用的某生产系统公开数据。

同一句话,有的语言贵十五倍

文字被切成碎片交给模型,而切法对不同语言极不公平。

文档接下来被切成模型能处理的单位,也就是 token。常见的词往往是完整的一块,生僻的词会被拆成好几片。

现在多数系统是从最底层的字节开始切,而不是从字符,这样任何书写系统的文字都能被表示出来。一个参照:一个 token 平均约等于四分之三个英文单词。

由此带来两个后果。

第一个是成本和容量因语言而异。一场大型机器学习会议上发表的研究,把同一段文字的各种译本拿来测量,发现 token 数量的差距最大可达十五倍。这不只是账单的问题。token 数越高,处理越慢,同样大小的容纳空间里能装下的内容越少。某些语言的使用者,拿着一份一模一样的文档,能用的空间实实在在地更小。

第二个是关于单个字母的问题会变得别扭。问一个单词里某个字母出现了几次,等于要求模型往自己拿到的那些碎块内部去看。

15 倍 同一段话,不同语言的 token 数差距 23 倍 按步调度带来的 吞吐量提升上限 60-80% 早期服务系统白占的 内存比例 1/10 缓存过的提示词 部分的收费
四个来自公开研究与测试的数字,分别对应语言公平、调度效率、内存浪费和缓存定价。十五倍那张是标红的原因:它直接决定了不同语言的使用者能用多少空间。

你和陌生人共用一台机器

你的请求会和别人的请求被打包在一起跑,而同批里有谁,可能影响你拿到的答案。

没有哪个模型是闲坐着等你的。你的那串 token 先排队,然后和其他人的请求一起,组成一批,在同一台硬件上跑。

为什么非要打包?因为现代的 AI 芯片算力极强,但它的内存带宽有很大一部分耗在搬运模型参数上,而不是真正为某一个请求干活。把参数搬一次,同时供给许多个请求用,才让这门生意在成本上说得通。

笨办法是:凑齐一组请求,一起跑,等整组全部跑完再开下一组。如果每个回复长度差不多,这没问题。但聊天回复长短悬殊,有的十个词就完了,有的能写一千个词。于是硬件有一部分时间在干等那个最长的。

更好的办法是按每一步来调度:哪个回复写完了,新请求立刻顶上它的位置,不用等整组清空。测试显示,这比笨办法的吞吐量最多能提高 23 倍,同时响应时间的中位数也改善了。

共用资源还带来一个古怪的后果:就算把随机性完全关掉,一模一样的请求也可能返回不同的答案。因为这里面的数值运算对「同时有多少个请求在一起算」很敏感。同一个提示词发给一个大模型一千次,可能得到 80 种不同的回答。

停顿和打字是两码事

那个停顿和随后的逐字吐出,是两种性质完全相反的计算,快慢由完全不同的因素决定。

生成一个回复分两个阶段,性质正好相反。

第一阶段一口气把整份组装好的文档读完。每个输入 token 都和其他所有 token 一起被处理,所以这活儿可以并行,压榨的是芯片的纯算力。这个阶段就是那个停顿。

第二阶段一次吐一个 token。每个 token 都依赖它前面那个,完全没法并行。这里的瓶颈是内存速度,不是算力。每走一步都要把之前算过的东西全部读回来一遍。这个阶段就是那个稳定的打字过程。

第一阶段的耗时随输入长度增长。所以一段聊了二十轮的对话,开口前的等待明显比在新窗口里问同一个问题更久。第二阶段的速度基本不变。聊得越久,停顿越长,吐字速度几乎纹丝不动。

这两半是分开计量的:一个叫首字延迟,涵盖从你按下回车到第一个字出现的全部时间,排队等待也算在里面;另一个叫每字间隔,管的是之后每个字之间的空隙。总时长约等于前者加上后者乘以回复的长度。

还有一个连带效应:某一个超长的输入会拖慢同一批里所有人的生成。办法是把那个长输入切成块,和正在进行的生成穿插着跑,这样别人的输出还能继续流出来,代价是被切开的那位要多等一会儿。

停顿阶段 一口气读完整份文档,能并行,拼算力。 聊得越久,它越长。 打字阶段 一次吐一个字,没法并行,卡在内存速度。 长短对话都一样快。
同一次回复里的两个阶段,瓶颈完全不同:停顿吃算力且随对话变长,吐字吃内存速度且基本恒定。

算过的不再算第二遍

吐字阶段之所以快,是因为读输入时算出的东西被存了下来反复用。而存这些东西,才是一台机器能同时服务多少人的真正天花板。

第二阶段每吐一个字都要顾及前面所有内容,为什么还能这么快?因为那些活儿没有重做。读输入时算出来的结果被存了下来,之后每一步直接取用。

这份存下来的状态大得吓人。一个 700 亿参数量级的模型,装着一段 8000 token 的对话,每个请求就能占到几个 GB。几十个并发对话加起来,在模型本身的参数还没算进去之前,就能撑爆一整块高端 AI 芯片的内存。一台机器能服务多少用户,通常卡在这份对话状态上,而不是卡在模型本身。

早期的服务系统按「这个请求最长可能写多少」去预留一整块连续内存。一篇被广泛引用的系统论文测了这笔账,发现六到八成的内存是白占着没用的。修法是操作系统用了几十年的老招数:把存储切成小块、固定大小、按需发放。改完之后浪费降到 4% 以下,吞吐量提高到原来的 2 到 4 倍。

同一个思路还能跨轮次用。既然每条消息都要重发开头那一整块相同的内容,那算好的开头就可以存着重用,不必每轮重算。各家公司明码标价:提示词里被缓存的那部分,收费常常只有正常输入价的十分之一。缓存条目一般几分钟就过期,除非一直被用到而刷新。

这就是为什么写提示词有条规矩:不变的内容放最上面,会变的内容放最下面。一个每次请求都在变的开头,没法被有效重用。

被白白占用、没派上用场的内存比例 早期:预留整块 按最长可能的回复预留连续内存 60-80% 改后:切成小块 吞吐量同时提高到 2-4 倍 低于 4%
把内存从'一次预留一大整块'改成'切成固定小块按需发放',浪费从六到八成降到 4% 以下。数据出自原文引用的一篇被广泛引用的系统论文。

说出口的收不回来

文字是一边生成一边送到你眼前的,这让它看起来快,但也意味着安全检查来不及拦住已经显示出来的话。

回复阶段同时在发生两件事。

文字之所以一个词一个词地出现,是因为它一产出就被送出来,而不是攒齐了再给。这提升的是感知上的速度。人正常阅读的速度大约是每秒六个 token,而生产系统的生成速度轻松超过这个数,所以边生成边送,你可以几乎立刻开始读,不用对着空白等。

第二件事是输出侧的安全检查。很多产品在输出上也设了一道检查,但这类检查得读完整个回复才能下判断。等它读完,回复早已显示在屏幕上了,而已经显示出来的字是收不回去的。如果为了等检查完成而把回复扣住,那边生成边送的好处就全没了。

这个矛盾目前没有定论。有的系统用专门设计的守卫,一个 token 一个 token 地边流边判;有的干脆不等成品文字,直接读模型生成过程中的内部状态来判断,这种做法便宜到可以一直开着。

用工具就是走一遍回头路

模型不会自己上网搜东西,它只能写一段话请求别人去搜,而每搜一次,整个流程就从头再跑一遍。

到这里为止,从按下回车到回复出现是一条直线。一旦牵扯到工具,这条直线就变成了圈。

模型不搜网、不读文件、不查数据库。它做的是产出一段文字,请求这些事情发生,用的正是组装文档时塞进去的那些工具说明书。外面的应用程序认出这个请求,去执行,然后把结果放回文档里。

结果就是新的输入。于是整个流程从头再跑一遍:重新组装、重新安检、重新切块、重新排队、重新走完两个生成阶段。一个动用了三次网络搜索的回复,意味着它在上面这一整套里完整来回跑了好几趟。这就是为什么这类回复明显更慢。

成本是急剧叠加的。在一个包含二十次调用、上下文不断变长的会话里,最早那几条消息被付费付了二十遍。一段两千 token 的指令,在两百次调用里发出去,光它自己就产生四十万个输入 token,这还是在任何实际工作开始之前。

组装文档 说明书 + 记忆 + 全部历史 + 新消息 安检与切块 判断是否放行,再切成 token 排队与打包 和陌生人的请求凑成一批 两阶段生成 先一口气读完,再逐字吐出 模型请求用工具 结果塞回文档,整圈重来 整圈重来 一个动用了三次网络搜索的回复,意味着这五步完整跑了好几遍—— 最早那几条消息因此被反复付费。
从按下回车到回复出现本是一条直线,一旦模型要求调用工具,结果就被塞回文档,五个步骤从头再走一遍。

慢和贵不是缺陷

长对话变慢、变贵、丢细节,不是产品没打磨好,是无记忆这个设计选择的必然账单。

把这一两秒拆开看,它是这么分掉的:一小部分花在网络传输和身份验证上;更大一部分花在组装那份文档、搜集记忆和参考材料上;输入侧的安全检查如今用分级筛查压到了约 1% 的算力;切块几乎不占时间;排队占多少完全取决于当时有多少人在用;而在一段长对话里,最大的一块花在读输入上,这正是聊得越久、停顿越长的原因。剩下的全是第二阶段,它的速度从第一条消息起就几乎没变过。

值得留意的是这些数字的来源。24% 和 0.38 个百分点来自某个生产系统公开的数据,23 倍吞吐提升来自公开测试,六到八成内存浪费来自一篇系统论文。它们都是被公布出来的结果,不是可以随手复现的测量。原文也明确说了,内容基于各方公开信息整理。

真正要带走的判断是:所有这些工程手段,分级安检、按步调度、分块内存、前缀缓存,都在补同一个洞:模型没有记忆。它不能记住你上一句说了什么,于是每一轮都得把整段对话重读一遍;整个产业围绕这个前提,造出了一整套精巧的省钱省时装置。

所以当你抱怨一段长对话变慢、变贵、开始忘事,你抱怨的是这个设计选择本身的账单。哪天模型真的能记住东西,上面这些装置里的大半都会失去意义。