张彦峰ZYF头像
会调接口不等于懂模型:Java 工程师视角的 Token 计量、上下文窗口、温度采样、Embedding 与幻觉边界封面图

会调接口不等于懂模型:Java 工程师视角的 Token 计量、上下文窗口、温度采样、Embedding 与幻觉边界

目录

一、为什么这六个名词值得认真对待

(一)三起线上问题,同一层理解缺口

1、凌晨批处理突然大面积被拒

2、客服会话越到后面越离谱

3、同一张工单两次分类结果不同

(二)这三起问题的共同结构

二、Token:一切账目的计量单位

(一)分词器在请求发出前做了什么

1、子词合并是关键的一步

2、切分点由词表决定,不由语义决定

(二)Token 密度:同一屏内容可以差出三倍

(三)同一个 Token 数,落在三本完全不同的账上

1、计费账:按总量结算,输入输出不同价

2、限流账:按速率结算,而且常常预扣

3、延迟账:输入决定首字,输出决定总时长

(四)输入段与输出段:两条形状完全不同的曲线

(五)Java 侧怎么数 Token

1、四条路,误差与代价各不相同

2、一个够用的计数抽象

3、四个容易漏掉的扣减项

(六)省 Token 的五个真杠杆与两个伪杠杆

三、上下文窗口:额度、结构与失败形态

(一)窗口里装的不只是用户问的那句话

(二)溢出的四种失败形态

(三)长上下文不是免费的:三条同时抬高的曲线

(四)位置也是一个旋钮

(五)会话变长之后的四种处置策略

1、四种策略各自保住了什么、丢掉了什么

2、摘要压缩的两个坑

3、一个二十轮会话的对照

(六)前缀缓存:把不变的放前面

(七)把装配做成一个有预算的组件

四、温度与采样:随机性从哪来,到哪去

(一)从分数到字:四道处理的次序

(二)温度改变的是分布形状

(三)top-k 与 top-p 的区别

(四)按任务类型定参数基线

(五)温度设成 0,也不能承诺「同样的输入一定得到同样的输出」

1、五个不确定性来源

2、seed 能给到什么保证

3、把「可复现」换成「可锁定」

(六)结构化输出:换约束手段比调温度有效得多

(七)参数是配置,不是常量

五、Embedding:把语义变成坐标

(一)它是什么,不是什么

(二)检索链路的五个环节

(三)相似度不等于相关性

(四)维度、归一化与距离度量必须配套

(五)混合检索与重排

(六)换一个 Embedding 模型,等于把整个索引作废重来

六、幻觉:成因、分类与四层防线

(一)它不是一个可以修掉的缺陷

(二)六类幻觉的判别指纹

(三)四层防线与加固顺序

(四)把校验写成一条责任链

1、链的骨架

2、失败之后做什么

3、最有价值的两个校验器

七、能力边界:哪些活不该交给它

(一)四类系统性弱点

(二)三个「看起来能做」的陷阱

(三)判断与执行分离

八、把六个概念连起来:一次问答的完整账本

(一)逐环节的 Token、延迟与成本

(二)七个旋钮对三条曲线的影响

(三)容量与并发怎么推算

1、五步推算

1.1 算单请求的 Token 占用

1.2 用配额除以单请求占用,得到理论吞吐

1.3 用 Little 定律换算并发

1.4 留余量

1.5 设计降级路径

2、这套推算真正的价值

九、工程落地:Java 服务里的模型接入

(一)四层切分

(二)超时、重试与幂等

(三)该埋哪些指标

(四)把模型行为纳入交付闸门

十、常见误区与上线前自检

十一、结语

参考资料


干货分享,感谢您的阅读!

把一个大模型接进 Java 服务,今天已经不算难事:加一个依赖,填一个密钥,拼一段字符串,解析一段 JSON,半天就能跑通。但难的是接通之后的第二个月——成本曲线莫名其妙地翻了两倍,同一张工单两次分类结果不一样,客服会话到了第三十轮开始张冠李戴,凌晨的批处理任务突然大面积被拒,而所有人都只能给出同一个结论:「模型不太行」。

这个结论之所以站不住,是因为它把一整条可观测、可度量、可断言的工程链路,压缩成了一个不可解释的黑盒。事实上,从一段文本被送进模型到一段答案被写回数据库,中间有五个量是完全确定的:分词后的 Token 数、上下文窗口的占用比例、采样参数决定的分布形状、向量检索的召回位次、输出校验的通过率。这五个量对应六个基础概念——Token、上下文窗口、温度与采样、Embedding、幻觉、能力边界。它们不是六个孤立的名词解释,而是一条从「计量」到「生成」再到「判定」的链条。

这次我们要做的,就是把这条链条逐段拆开,用 Java 工程师熟悉的语言重新表述:什么是硬约束,什么是可调旋钮,什么该埋成指标,什么该写进配置中心,什么该在装配阶段就拦掉,以及——哪些活从机制上就不该交给它。全文不涉及训练,也不涉及模型内部结构的细节,只讨论调用侧看得见、摸得着、改得动的部分。

一、为什么这六个名词值得认真对待

(一)三起线上问题,同一层理解缺口

先看三起真实形态的问题。它们表面上毫无关联,根因却全部落在同一层。

1、凌晨批处理突然大面积被拒

现象是:同一段代码,白天在线服务跑得好好的,凌晨批量任务一起来,大量请求返回限流错误。团队第一反应是供应商悄悄收紧了配额。

真相是:配额的计量口径是每分钟 Token 数,而不是每分钟请求数。批量任务为了「一次多处理几条」,把单次请求的上下文拉长了六倍——请求数一个没多,Token 数翻了六倍。团队盯着 QPS 看板,看到的是一条平线,于是完全无法把现象和原因对上。

这里缺的是对 Token 作为限流计量单位的理解。

2、客服会话越到后面越离谱

现象是:一段客服会话,前十轮的摘要与回答都准确,第三十轮开始把甲客户的政策安到乙客户头上。团队第一反应是模型的「记忆力」随对话变长而衰减。

真相是:会话历史超过上下文窗口之后被从头截断,最早那几轮里客户自报的「企业版、华东大区、合同号 C-8871」被整段切掉了,而系统提示里仍然写着「请参考上文中的客户信息」。模型看到的上下文里根本没有这段信息,它只能按最常见的情况——个人版政策——来回答。

这里缺的是对上下文窗口是一个共享额度的理解。

3、同一张工单两次分类结果不同

现象是:工单分类接口重试一次就换了个类型,导致下游对账系统天天报不一致。团队第一反应是「把温度调到 0 就好了」。

调到 0 之后,不一致率从百分之三降到了百分之零点二——问题变小了,但没有消失。团队于是陷入困惑:温度都 0 了,为什么还会变?

真相是:确定性采样并不等价于确定性输出。批处理时的浮点累加顺序、并发批次的构成、稀疏路由的选择,这三件事都会在极小的概率上翻转前两名的排序。而真正能解决业务问题的修法,根本不在温度上,而在两件事上:把输出空间收成枚举,让抖动落不到非法值;以及给每个业务实体加一个幂等键,第一次的结果落库之后,重试直接返回已有结果。

这里缺的是对随机性来源与可锁定性的理解。

(二)这三起问题的共同结构

三起问题的报障语言都在描述「模型的表现」,而所有可操作的旋钮都在「调用侧的约束」上。这种错位会带来两个后果:一是定位时间被拉长,因为团队在一个没有旋钮的地方找旋钮;二是采取的动作往往是「换个更大的模型」或者「再改改提示词」,而这两个动作对上面三起问题里的任何一起都不会有实质帮助。

破解的办法不神秘:把那五个可观测量埋成指标,把六个概念之间的关系理清楚。理清楚之后,你会发现绝大多数「模型变笨了」的工单,根因都落在计量层——被窗口截断、被限流排队、被成本护栏降级——而报障描述停留在判定层。

二、Token:一切账目的计量单位

(一)分词器在请求发出前做了什么

模型的输入端从来没有见过「字符」。它见到的是一串整数——词表里的编号序列。从一段人类可读的文本到这串整数,中间要走完一条完整的流水线:规范化、预切分、子词合并、查表编号。

1、子词合并是关键的一步

分词器的词表不是按「字」建的,也不是按「词」建的,而是按「高频子串」建的。构建词表时,算法从单个字符起步,反复统计相邻单元的共现频率,把最常见的组合合并成一个新单元,直到词表规模达到预设值。使用时则反过来:从单字起步,自底向上贪心合并,能合就合。

这带来的直接结果是:常见的东西短,罕见的东西长。「订单」在中文语料里高频出现,多半会被合成一个 Token;一个生僻字可能反而被拆成两到三个字节级 Token。英文里 understanding 是一个 Token,而一个随机生成的标识符 x7kq2mz 可能要占五六个。

2、切分点由词表决定,不由语义决定

这一点对工程实践的影响远比想象中大。

举个例子:ORD-20260911-0042 这个订单号,因为有连字符做边界,多半会被切成 ORD、-、2026、0911、-、0042 这样与语义边界一致的片段,模型可以稳定地把中间那段识别成日期。而 ORD202609110042 没有任何分隔符,会被切成 ORD、202、609、110、42 这种跨越语义的碎片——问它「这单是哪天的」,它就要在一堆不对齐的数字块上做推理,出错概率显著上升。

同样的道理适用于所有高熵短串:UUID、哈希值、Base64、压缩后的 JSON。它们不但占 Token 多,而且切分结果与语义完全无关,模型在它们上面做精确比较的能力接近于零。

一条可以立刻用起来的规则:凡是希望模型能理解、能比对、能引用的标识符,都要带上人类可读的分段边界。这不只是可读性问题,也是模型可用性问题。

(二)Token 密度:同一屏内容可以差出三倍

既然切分由词表决定,那么「一个 Token 等于多少个字符」就不是一个常数,而是一个随内容类型剧烈变化的量。

三个反直觉的地方值得单独点出来。

第一,中文不是「一字一 Token」。这是最常见的误解。常用词会被合成一个 Token,所以「上下文窗口」四个字可能只占两三个 Token;但生僻字、特殊符号反而会退化到字节级切分,一个字占两三个 Token。综合下来,中文散文的均值大致落在「一个 Token 约一点五个字」这个量级上,但方差很大。

第二,结构化数据最贵。JSON 的每一个引号、冒号、逗号、缩进空格都是 Token。一个长字段名在一千行数组里重复一千次,就是实打实的一千次计费。把格式化 JSON 换成紧凑 JSON,再把重复的对象键换成表头加数组的形式,体量常常可以对半砍。

第三,Base64 是最坏情况。它没有任何可合并的高频子串,几乎退化成按字节切分;而且模型对它的理解能力接近于零。把一个附件 Base64 之后塞进提示词,等于用最贵的价格买了最差的效果。正确做法永远是:先在 Java 侧抽取出文本或结构化字段,再把抽取结果送进去。

由此可以得到三条硬规则:附件不要原文塞、结构化数据要压紧、任何按字符数估算成本的看板都要打上误差标注。

(三)同一个 Token 数,落在三本完全不同的账上

这是 Token 这个概念最容易被简化的地方。很多团队只把它当成「计费单位」,于是所有优化都围绕「省钱」展开。实际上同一个 Token 数会同时出现在三本账上,而这三本账的口径与优化手段各不相同。

1、计费账:按总量结算,输入输出不同价

输入 Token 与输出 Token 的单价通常相差三到五倍,输出更贵。命中前缀缓存的输入段往往还有一档折扣单价。所以「省钱」这件事至少有三个着力点:压缩输入、限制输出上限、把稳定前缀放在最前面吃缓存折扣。

2、限流账:按速率结算,而且常常预扣

这是最容易踩坑的一本。限流额度通常同时设置「每分钟请求数」与「每分钟 Token 数」两条线,任意一条触顶都会被拒。更关键的是:输出 Token 往往按 max_tokens 预扣,而不是按实际用量结算。

这意味着一个很反直觉的事实:如果你习惯性地把 max_tokens 开到模型上限(比如 4096),那么即使你的回答平均只有 200 个 Token,限流账上也会按 4096 扣。同样的并发下,你的有效吞吐量可能只有实际需要的二十分之一。

把 max_tokens 从「开到最大反正用不完」改成「按场景估算后设一个贴身的值」,是限流层面性价比最高的一次改动,而且不需要改任何业务逻辑。

3、延迟账:输入决定首字,输出决定总时长

这一本在下一节单独展开。

(四)输入段与输出段:两条形状完全不同的曲线

一次生成在时间上被切成两段:输入段(一次并行的前向计算,把整段提示词「读」进去)和输出段(逐个 Token 的串行循环,每生成一个字都要完整走一遍前向)。

两段对长度的敏感度完全不同:

  • 输入段的计算量随长度增长,但可以并行铺开。长度从八千涨到八万,时间不会是十倍,通常落在十五到二十五倍之间——超线性,但远没有「逐 Token」那么陡。命中前缀缓存时,这一段可以近乎归零。
  • 输出段几乎严格正比于输出长度。480 个 Token 的输出,按每 Token 十二点五毫秒算,就是六秒,而且这六秒无法通过任何缓存手段消掉。

对 Java 服务的直接含义是:接口层至少要埋两个耗时指标,首字耗时与总耗时。只埋一个总耗时,会让「检索片段塞太多」与「让模型写太长」这两类完全不同的问题长得一模一样。流式接口还要额外埋一个「Token 间隔」——它突然变大通常意味着服务端在排队,而不是模型在「思考」。

这里还藏着一个体验上的大机会:流式返回不省一分钱,也不缩短一毫秒的总时长,但它把用户感知的等待从总时长变成了首字延迟。在上面那个例子里,这是从 7.3 秒降到 1.2 秒。这可能是整条链路上投入产出比最高的一次改动。

(五)Java 侧怎么数 Token

知道了 Token 的重要性,接下来的问题是:在 JVM 里怎么拿到这个数。

1、四条路,误差与代价各不相同

  • 字符数除以常数:零成本,误差常常超过百分之三十。只能用来在日志里标个量级,绝不能用来做窗口裁剪。
  • 本地分词器库:引入与服务端同版本的词表,在 JVM 内跑一遍。误差可以做到百分之一以内。代价是需要维护词表版本、首次加载占几十兆内存。这是请求路径上唯一正确的选择。
  • 服务端计数接口:精确,但多一次网络往返,而且这个接口本身也可能被限流。适合离线校准,不适合放在请求路径上。
  • 响应回填:从响应体的用量字段里读出真实消耗,精确但事后。它是计费对账与误差监控的基准值。

推荐的组合是「本地为主,服务端为辅」:请求路径上只用本地分词器;把响应回填的真实值与本地估算值做差,按天算相对误差,超过百分之二就告警——这通常意味着对方换了词表版本;限流预扣按本地估算值乘以 1.05 取,留一点保守余量;计费对账按响应回填值取,两者不要混用。

词表文件要跟着应用一起打包并锁版本,不要运行时去网上拉。这一条看起来啰嗦,但一旦线上出现「本地算出来的数突然和实际对不上」,排查起来非常费劲。

2、一个够用的计数抽象

接口先定死,实现可替换:

public interface TokenCounter {
    int count(String text);                 // 单段文本
    int count(List<ChatMessage> msgs);      // 含角色开销的整段会话
    String modelFamily();                   // 词表版本标识,用于校准比对
}

这里最关键的一点是第二个重载:会话计数不等于各段计数之和。每条消息都有固定的角色包裹开销,工具定义、函数签名也会被编码进提示词,必须一起算。

3、四个容易漏掉的扣减项

  • 消息角色包裹。每条消息前后都有固定标记,几十条消息累计起来能到几百 Token。
  • 工具定义。函数名、参数描述、枚举值全都算输入。十几个工具的定义很容易吃掉三五千 Token,而它们在你的业务代码里完全不以「提示词」的形式出现,最容易被忘掉。
  • 多模态占位。一张图片按分辨率折算成数百到数千 Token,这部分在字符串里一个字符都看不见。
  • 模型自带的隐式前缀。部分服务会注入固定的系统层文本。实测值与自算值之间那个稳定的差额,通常就是它。把这个差额测出来记成常量,比每次纠结「为什么总差几十」要省事得多。

(六)省 Token 的五个真杠杆与两个伪杠杆

五个真杠杆分别是:去掉重复模板(多轮会话里每次都重发的固定说明,改成依赖前缀缓存)、压紧结构化数据、用检索代替全量、限制输出长度、把长历史摘要化。它们的共同点是:减少的是表达信息所需的符号,而不是信息本身。

两个伪杠杆要特别警惕。

第一个是「把提示词写得极简」。表面逻辑是字少就便宜,实际后果是任务描述不清、模型自由发挥、返回格式漂移,然后靠重试补回来——一次重试的成本是整个请求,远超省下的那点前缀。提示词该长就长,要省去动那些真正重复、真正冗余的部分。

第二个是「换更小的模型跑全部流量」。表面逻辑是单价低就总成本低,实际后果是小模型在复杂样本上需要更多轮次、更长的思考铺陈、更高的返修率,端到端成本可能不降反升。正确做法是按难度分流:简单样本走小模型,复杂样本走大模型,用一个便宜的分类器或几条规则做前置判断。

任何省 Token 的改动,都要同时看「省下的 Token 数」与「返修率的变化」。只报前者不报后者的优化,有一半概率是负收益。

三、上下文窗口:额度、结构与失败形态

(一)窗口里装的不只是用户问的那句话

上下文窗口是一次请求能塞进去的 Token 上限。这个定义人人都知道,但真正需要理解的是:这个额度被四段内容共享,而其中三段的长度都不由用户控制。

系统提示、工具定义、检索证据、会话历史、本轮输入——这五段之和必须小于「窗口上限减去输出预留」,而输出预留这一段在请求发出前就要扣掉。只有「本轮输入」由用户写,其余四段全部由你的代码决定长度。

所以「用户问得太长导致超窗」几乎从来不是真实原因。真实原因永远在装配逻辑里。

(二)溢出的四种失败形态

  • 硬拒绝:服务端直接返回长度超限错误。这是最友好的一种失败——至少它是显式的。
  • 静默截断:部分实现会悄悄砍掉超出的部分。模型照常返回,答案却少了关键前提。
  • 历史被从头砍:最早的几轮被丢掉,而系统提示里还写着「参考上文的客户信息」。
  • 证据被挤掉:历史太长,检索片段被压到只剩一条,模型没有证据只好自己编。

最危险的是第二和第三种。它们不抛异常、不进错误日志、不触发告警,只表现为「模型答得不对」。等到业务方反馈上来,往往已经跑了几周。

防住它们的唯一办法,是在装配器的终检里自己数一遍,并且把「本次请求丢弃了多少历史、多少证据」作为结构化字段打进日志。这一个字段能省掉后面所有的猜测。

(三)长上下文不是免费的:三条同时抬高的曲线

窗口开得大,不代表用到大窗口是免费的。

首字延迟超线性增长,单次成本严格线性增长,这两条都可以用预算和限速管住。真正的设计难点是第三条:答案质量先升后降。

证据从零到有时,质量提升明显;但超过某个密度之后,无关片段开始与正确片段争夺注意力,准确率反而回落。这条曲线管不住——它要求你在装配阶段就做取舍:宁可少给两段证据,也不要把「可能相关」的十段一起塞进去。

这也直接否定了一种很有诱惑力的懒办法:「窗口这么大,干脆把整份文档塞进去让它自己找」。窗口能装下,不等于它能在装下的东西里找准。

(四)位置也是一个旋钮

同一条信息,放在上下文的不同位置,被用上的概率不一样。开头与结尾的召回明显优于中段,这在长上下文评测里是一个反复出现的稳定现象。

四条可以直接落地的推论:

1. 最重要的约束写在系统提示的开头,最重要的问题写在整段上下文的最后。

2. 检索片段按相关度排序时,不要简单地降序铺开——把最相关的那一条放在最后一个位置,效果常常更好。

3. 「请参考以上材料」这种指代要谨慎。当材料很长时,「以上」这个词的指向会变得模糊,明确写出「材料编号 3」这类锚点更可靠。

4. 不要用「把文档全塞进去让它自己找」代替检索。

验证方法很简单:把一条确定的事实插到上下文的不同位置,各跑五十次,统计答对率。这是一个两小时能做完的实验,却能直接决定装配器的排序策略。

(五)会话变长之后的四种处置策略

1、四种策略各自保住了什么、丢掉了什么

滚动窗口只保留最近 N 轮,实现最简单,延迟与成本可预测;代价是早期确立的前提、身份与约束全部消失。保头保尾永远保留首轮与最近 N 轮,任务设定不会丢,但中段的事实与决策仍然丢失。摘要压缩把中段压成结构化摘要随会话一起带,事实与决策以压缩形式保留,细节与原话丢失。外部状态把关键事实写进业务表、每轮按需查回来,事实精确、可审计、可修改,代价是工程量最大。

这四种不是互斥的,正确做法通常是叠加:系统提示与任务设定永远固定在最前;金额、身份、权限、已承诺事项写进外部状态表;中段的过程性对话做摘要压缩;最近三到五轮原文保留。这样一来,会话再长,上下文长度也是有上界的。

2、摘要压缩的两个坑

第一,摘要本身会幻觉。它是模型生成的,一旦摘要里写错了一个金额,后面所有轮次都会继承这个错误,而且越往后越难被发现。对策是限制摘要的内容边界:只允许写「从结构化字段抄来的事实」加「明确的决策项」,不允许写推断与评价。

第二,反复摘要会漂移。对摘要再摘要,三五次之后内容会退化成空泛的套话。对策是摘要只从原始历史生成,不要在上一版摘要的基础上迭代。这需要保留原始历史(存在数据库里,不占上下文),实现上多一步,但能避免一类很难察觉的退化。

3、一个二十轮会话的对照

这张对照想说明的不是「摘要更好」,而是:会话里存在两类信息——可以丢的过程,与绝不能丢的事实。裁剪策略的第一步不是选算法,而是把这两类区分开来,并且为第二类建立一条不依赖上下文窗口的存储路径。做完这一步之后,用哪种裁剪算法反而不再关键。

(六)前缀缓存:把不变的放前面

前缀缓存按「从第一个 Token 起完全一致」匹配。中间插一个时间戳,它后面的全部内容都会失效。

落地清单很短,把这五类内容后置就行:时间戳、请求号、追踪 ID;用户昵称、座席工号这类每次不同的称呼;随机打乱顺序的少样本示例(顺序要固定);检索片段;任何带「今天是」「当前」字样的动态说明。

反过来,系统提示与工具定义要做到字节级稳定。这里有一个非常容易翻车的细节:用 HashMap 存工具定义再遍历输出,JVM 重启后遍历顺序可能变化,缓存命中率会莫名塌掉,而且这种塌陷没有任何报错。对策是工具列表按名字排序后再序列化,或者干脆用 LinkedHashMap 并显式指定顺序。

另一个细节是缓存有存活时间。低频场景下缓存可能在两次请求之间就过期了,命中率看起来永远上不去。所以先看命中率指标,再决定值不值得为它改结构——命中率本身要埋成指标,它是长期成本曲线的主要解释变量。

(七)把装配做成一个有预算的组件

前面所有的讨论,最终都要落到一个组件上:上下文装配器。它的职责是让「超出窗口」这件事永远不发生。

核心逻辑是先分配额度,再按优先级填充,最后校验:

int hardLimit   = model.contextWindow();        // 例如 128000
int reserveOut  = req.maxTokens() + 256;        // 输出预留 + 安全余量
int budget      = hardLimit - reserveOut;

budget -= counter.count(systemPrompt);          // 固定段:不可裁
budget -= counter.count(toolDefinitions);       // 工具定义:不可裁
if (budget < MIN_WORKING_BUDGET) {
    throw new ContextOverflowException("固定段已吃掉可用预算,检查系统提示与工具定义");
}

int forRetrieval = (int) (budget * 0.55);       // 证据段:占大头
int forHistory   = budget - forRetrieval;       // 历史段:拿剩下的

List<Chunk> evidence = packer.fill(chunks, forRetrieval);   // 按分数降序装包
List<Msg>   history  = trimmer.trim(msgs, forHistory);      // 保头保尾,中间摘要

这段代码有三个设计要点值得说明。

一是输出预留必须在最前面扣。很多实现是「先把输入拼满,剩下多少给输出」,这会导致在输入接近上限时输出被压到只剩几十个 Token,答案生成到一半就被截断——而截断后的答案往往仍然是合法 JSON,解析不报错,只是内容不完整。

二是固定段与可裁段要显式区分。系统提示和工具定义不可裁,如果它们本身就把预算吃光了,应该立刻抛异常而不是去裁证据——后者会让问题以「答得不准」的形式出现在几周之后。

三是证据段要有保底配额。上面给了百分之五十五,具体比例要按场景标定,但关键是不能让历史无限挤压证据。一个常见的正确做法是给证据段设一个绝对下限(比如至少三条片段),不满足就优先砍历史。

最后,第六步的终检不是形式主义:把拼好的完整消息列表再数一遍,不通过就拒绝发出。任何一段都不允许「先拼起来再看长度」——那会让终检变成唯一防线,而它只能拒绝,不能补救。

四、温度与采样:随机性从哪来,到哪去

(一)从分数到字:四道处理的次序

「温度」这个参数被讨论得最多,也被误解得最多。要把它讲清楚,必须先把它放回它所在的那条链路里。

模型在每个位置上输出的不是一个字,而是对词表里每个候选的一个实数分数。从这组分数到一个具体的字,中间要走完四道处理。

由这个次序可以直接推出三件事:

第一,温度在截断之前生效。所以温度会改变 top-p 截出来的候选集合大小——高温下更多候选挤进累计概率 p 之内,随机性被双重放大。这解释了一个常见现象:只把温度从 0.7 调到 1.0,输出的发散程度增加得比预期更多。

第二,温度不改变排序。它只改变各候选之间的相对差距。所以温度为 0 时无论怎么调 top-p,结果都一样——这是一个很有用的排查线索:如果你调 top-p 完全没效果,先看看温度是不是 0。

第三,两个旋钮同时调等于把随机性乘起来。生产环境的通行做法是「固定一个、只调另一个」,一般固定 top-p,调温度。

(二)温度改变的是分布形状

看这三档分布最直观的收获是:第一名始终是第一名,变的只是它领先多少。温度 0.2 时第一名吃掉了百分之九十九点六的概率;温度 1.5 时它只剩百分之四十四点七,第四第五名合起来也有两成机会。

由此推出一条纪律,它可能是整节里最重要的一句话:如果一个任务在温度 1.0 下经常答错,把温度降到 0 并不会让它答对——它只会让它每次都用同样的方式答错。

温度能解决的是「不稳定」,解决不了「不正确」。看到「结果不稳定」先调温度;看到「结果不对」要去补证据、改提示、换约束手段。这两类问题的混淆,是参数调优里浪费时间最多的一种。

(三)top-k 与 top-p 的区别

两者截的是同一批候选,但截法的稳定性差别很大。

当分布很尖(模型很确定)时,top-k=3 会保留三个候选,其中两个概率几乎为零,等于把噪声也留在了候选池里;top-p=0.9 则只保留一个,正确地识别出「这里没什么可选的」。

当分布很平(模型不确定)时,top-k=3 只保留三个,硬生生丢掉了两个同样合理的候选;top-p=0.9 保留四个,正确地识别出「这里确实有多种可能」。

生产环境更常用 top-p 的原因就在这里:它是自适应的。模型确定时它自动收紧,模型犹豫时它自动放宽。top-k 是一个固定数字,在不同位置上的含义完全不同。除非有特殊需要,固定 top-p,只调温度。

(四)按任务类型定参数基线

全系统一个默认参数值,是几乎所有团队初期都会犯的错。分类和写文案对随机性的需求方向完全相反,共用一组参数只能两头都不讨好。

这张表是起点,不是终点。每一行都要在自己的评测集上复核一次再固化进配置。用法上有三点:

1. 把它写进配置中心,按「场景键」而不是「全局」下发。

2. 每个场景键都要有一个对应的评测集(哪怕只有五十条)。改参数之前先跑一遍,改完再跑一遍,对比通过率。

3. 参数变更走与代码变更同样的评审与灰度流程。一次把温度从 0 改成 0.7 的配置推送,影响面等同于一次发版。

三个不要:不要在业务代码里硬编码温度(它一定会需要调整,而重新发版的成本会让你放弃调整);不要让不同场景共用一组参数;不要靠调温度解决格式问题。

(五)温度设成 0,也不能承诺「同样的输入一定得到同样的输出」

1、五个不确定性来源

确定性采样仍然不确定的五个来源:

  • 浮点累加顺序:批处理时不同请求被拼在一起计算,拼法不同则累加顺序不同。浮点加法不满足结合律,极小的差异可能翻转第一二名的排序。
  • 并发批次构成:同一请求在空载时与满载时会被放进大小不同的批次。这一项你完全无法控制。
  • 稀疏路由:混合专家结构会按批次内的负载在多个专家之间做路由,同一 Token 在不同批次里可能走到不同的专家。
  • 服务端版本漂移:模型权重、推理引擎、系统层提示词都可能被静默更新。模型别名指向的具体版本不保证长期不变。
  • 上下文本身在变:时间戳、会话历史、检索结果任何一项变化都会改变输入。这时输出不同是正确行为,却常常被误记成「模型不稳定」。

第五项值得特别注意:在排查「为什么结果变了」之前,先做一件成本极低的事——把两次请求的完整输入做一次 diff。经验上,相当一部分「模型不稳定」的报障,diff 一做就结束了。

2、seed 能给到什么保证

部分服务支持传入随机种子并返回一个系统指纹。它的实际含义是:在系统指纹相同、输入完全相同、参数完全相同的前提下,尽最大努力返回相同结果。

注意这里的三个前提与那句「尽最大努力」。它足以支撑调试与问题复现,不足以支撑对账。工程上的正确姿势是:把系统指纹记录下来,指纹变了就重跑评测集。

3、把「可复现」换成「可锁定」

追求严格可复现在这条技术路线上是一场必输的仗。更划算的做法是换一个目标:可锁定、可追溯、可回放。

  • 幂等键。同一个业务实体(工单、订单、文档)的同一类推理,第一次的结果落库,后续重试直接返回已有结果。这一条解决了「重试导致结果变化」这个真实痛点的九成。
  • 枚举约束。把输出空间收成有限集合,即使采样有抖动,落点也只在合法值里,对账系统不会炸。
  • 多次投票。对高价值判断跑三次取多数,既提高准确率也压低方差,代价是三倍成本。
  • 留证。把输入快照、参数、系统指纹、输出一起存档,争议时可回放。

这个观念转换,可能是大模型接入层设计里最有价值的一次。它把一个物理上不可达的目标(比特级复现),换成了一组完全可以工程化实现的性质。

(六)结构化输出:换约束手段比调温度有效得多

温度只影响「挑哪个候选」,约束手段直接删掉不合法的候选。前者是概率,后者是保证。

很多团队的实际演进路径是这样的:格式不稳 → 调低温度 → 还是不稳 → 加重试 → 重试也不稳 → 写正则去抠 JSON → 正则越写越长。

正确的顺序应该反过来:先上 Schema 约束或工具调用 → 再用少样本统一风格 → 最后才用温度做微调 → 重试只作为兜底,且必须限次。

即使开了 Schema 约束,解析层也仍然要做三件事:

1. 校验语义而不只是结构。金额是负数、日期在未来、枚举值合法但与上下文矛盾——这些 Schema 管不了。

2. 限制重试次数并区分错误类型。格式错可以重试;内容错重试往往还是错,要走降级而不是重试。

3. 把解析失败率埋成指标。它突然抬升通常意味着服务端模型版本变了,是最灵敏的漂移探针之一。

(七)参数是配置,不是常量

参数下发要按场景键组织,不按全局组织。理由有四条:不同场景对随机性的需求方向相反,全局值必然折中;场景键让灰度可以做到「只灰度分类链路」,爆炸半径从整个应用收缩到一条链路;场景键天然对应评测集的划分,改哪个键就跑哪个集;场景键也是成本归因的维度,哪条链路花钱最多一眼可见。

变更流程也要固化下来:改前留基线 → 小流量灰度 → 对照判据(通过率不降、成本不升、延迟不升,三者同时满足才允许扩量)→ 全量与留痕 → 自动回滚。

判断一个团队是否真的把模型接入做成了工程,看一件事就够了:改一次温度,需要几个人、几分钟、留下几条记录。如果答案是「改代码、发版、无记录」,那它还停留在试用阶段。

五、Embedding:把语义变成坐标

(一)它是什么,不是什么

Embedding 把一段文本压成一个定长的数字向量,让「意思相近」变成「坐标相近」。

它是三样东西:一个确定性函数(同样的输入、同样的模型,永远同样的向量);一次有损压缩(几百上千字被压成几百个浮点数,保留的是整体语义方向,丢掉的是细节、数量与否定);检索的召回层(职责是把可能相关的捞上来,而不是判断哪一条是对的)。

它不是三样东西:不是理解(向量接近只说明用词与话题接近,不说明逻辑上能回答这个问题);不是检索的全部(精确匹配、时间过滤、权限过滤这些事向量做不了);不是跨模型通用的坐标系(A 模型的向量和 B 模型的向量不在同一个空间里,混用等于乱码)。

对 Java 工程师最实用的心智模型是:把它当成一个「语义哈希」。它不像 MD5 那样输入变一点输出就面目全非,而是输入变一点输出就挪一点。于是「找相似」变成了「找最近邻」,而最近邻是一个有成熟索引结构、有明确复杂度、有工程可控参数的经典问题。整条检索链路的工程性,就建立在这一层转换上。

(二)检索链路的五个环节

切片、嵌入、索引、召回与重排、拼装——五个环节每一个都会出错,而线上「答得不准」的根因分布里,前两个环节合计占了一多半,团队的注意力却通常全在最后一个。

原因也不难理解:只有最后一环的产物(提示词)是可读的、可直接改的;前四环的产物是向量和索引,看不见也改不动。

破解办法是把中间产物显式化:把每次请求召回的片段 ID、分数、重排后位次、最终是否入选,全部结构化落日志。有了这张表,诊断可以从人工抽样变成自动统计。

一个便宜且有效的诊断办法是:拿三十个答错的样本,人工标注「正确答案所在的片段」,然后逐环节回答一个问题——这个片段在这一步还在不在?

  • 切片后就不完整 → 问题在环节一;
  • 完整但没被召回 → 问题在环节二或三;
  • 召回了但排在第十二位 → 问题在环节四;
  • 排在前三却没进上下文 → 问题在环节五。

这套方法的好处是它把一个模糊的「效果不好」,拆成了四个各自有明确修法的具体问题。

(三)相似度不等于相关性

四类失效在指标上都表现为「召回率还行,准确率上不去」,但修法完全不同。

否定被抹平。查询「哪些商品不支持七天无理由退货」,召回「本商品支持七天无理由退货」。否定词在语义向量里权重极低,「支持」与「不支持」几乎落在同一个点上。修法是把否定型问题改写为正面条件检索,或在重排阶段用一个判别模型专门处理否定。

数量与时间被抹平。查询「2026 年第三季度的退款率」,召回「2024 年第一季度的退款率」。数字与日期对向量的影响远小于主题词。修法是把时间、金额、编号抽成结构化元数据,用过滤条件而不是相似度来处理。

话题接近但意图不同。查询「怎么申请发票」,召回「发票申请失败的常见原因」。两者共享几乎全部关键词,一个问流程一个问故障。修法是切片时保留标题路径与文档类型,在重排阶段把意图类型作为特征。

专有名词失配。查询「C-8871 合同的服务范围」,召回一堆通用条款。合同号这类高熵短串在向量里几乎没有信号。修法是必须叠加关键词检索——这一类问题向量检索天然无解。

共同结论很清晰:向量检索擅长「话题级召回」,不擅长「条件级判定」。凡是能写成 WHERE 条件的东西,就不要交给相似度。

(四)维度、归一化与距离度量必须配套

有一条自检是三个数字要对得上:嵌入模型输出的维度、向量库表结构里声明的维度、查询时传入的向量维度。这三个对不上会报错——这是好事。

真正危险的是「度量方式」与「是否归一化」这两项。它们对不上时系统照常工作,只是排序悄悄退化,而且没有任何日志会告诉你。一个典型场景:索引按内积建立,但写入的向量没有单位化,结果长文档因为模长更大而系统性地排在前面,短小精准的片段永远召不回来。

验收方法是先建一个小而真的评测集:从真实问题里挑一百条,人工标注出「正确答案在哪个片段」,然后只看两个数——召回率@20(正确片段有没有进入前二十)与命中位次中位数(它一般排在第几)。调任何参数都以这两个数为准。没有这个集,所有调参都是自我安慰。

(五)混合检索与重排

单靠向量检索会漏,单靠关键词检索会偏,生产系统几乎都是混合的。

两路召回的分工很清楚:向量召回负责「问法和原文不一样」的情况(用户说「钱什么时候回来」,文档里写的是「退款到账时效」);关键词召回负责「必须精确命中」的情况(合同号、错误码、接口名、型号、法条编号)。

融合时有一个关键细节:不要直接比分数。向量相似度和关键词得分不在同一个量纲上,直接加权相加会被其中一路的分数分布主导,而且换个模型就要重调权重。通行做法是只用「名次」不用「分数」:一条片段在某一路里排第 r 名,就贡献 1/(k + r) 的分数,两路相加后重排,常数 k 取 60 左右。这一步几乎零成本,却能稳定拿到两三个点的召回提升。

重排为什么值得单独加一层?因为召回阶段为了快,用的是「问题向量」与「片段向量」各自独立编码后比距离——两段文本从未同时被模型看到。重排阶段把「问题 + 片段」拼在一起送进一个小模型打分,模型能看到两者的交互,判断准确得多。代价是重排逐对打分,一百个候选就是一百次前向,所以只对召回结果的前几十条做。

(六)换一个 Embedding 模型,等于把整个索引作废重来

这是检索系统里最容易被低估的一次运维动作。

错误做法是只对新写入的片段用新模型。这会让库里同时存在两套坐标系的向量,距离计算在两套向量之间毫无意义,表现为「新文档总是排前」或「老文档再也召不回」——而且这两种表现都不会报错。

正确做法是双索引并行:新模型全量重嵌写入一个独立的新索引,两套索引并行接收写入,读流量按开关切,评测集对比通过后切读,观察一周再删旧索引。

这里有一个设计期就要留的字段:向量表里必须有一列记录「这条向量是哪个模型、哪个版本生成的」。没有这一列,上面整套流程无从下手——你甚至不知道库里到底有几种向量。这个字段的成本是每行几个字节,收益是把一次可能的重大事故降级成一次常规运维。

六、幻觉:成因、分类与四层防线

(一)它不是一个可以修掉的缺陷

先把最重要的一句话说在前面:幻觉不是 bug,它是生成机制的自然产物。理解这一点之后,工程目标就会从「消灭幻觉」转成「把幻觉率压到可接受,并让残余的那部分可被发现」——后者是可达的,前者不是。

三条成因值得逐条说清楚。

第一,它的目标是「接着写下去」,不是「说真话」。 模型被训练来预测下一个 Token 的分布。在任何位置上它都会给出一个分布,也就一定能采样出一个 Token——它没有「我不知道」这个内建出口。所以「编造」与「正确回答」在机制上是同一件事,区别只在于那个分布对不对。

第二,训练语料的长尾没有支撑。 高频事实在语料里出现成千上万次,分布很尖,模型几乎不会错;长尾事实可能只出现过一两次,甚至从未出现,此时分布很平,采样出的内容形式上完全合理——人名像人名、编号像编号、条款号落在常见区间——内容却是虚构的。这解释了一个令人不安的现象:模型编出来的东西,往往比真实的东西看起来更「标准」。

第三,后训练奖励了「像样的答案」。 人类偏好训练让模型倾向于给出流畅、完整、语气确定的回答。在「说不知道」与「给一个像样的答案」之间,后者历史上更容易拿到高分。结果是模型的语气确定性与它的实际把握程度并不相关。

由此得到三条工程结论:

1. 不要指望提示词里写「不确定就说不知道」能解决问题。它有效,但只在边际上有效,无法改变分布本身。

2. 语气不能作为置信度。「根据规定第 17 条」这句话里,「第 17 条」和「根据规定」拥有同样的自信,但前者极可能是编的。

3. 能校验的地方一定要校验。校验成本远低于一次错误答复的业务成本,这笔账在绝大多数场景都成立。

这里还有一个非常有用的区分:外源幻觉与内源幻觉。外源幻觉是编造了上下文里根本没有的内容,可检测——把生成内容与给定材料做归因比对即可;这是检索增强场景里最主要的一类,也是最好治的一类。内源幻觉是上下文里有材料,但推理或引用搞错了,比如把甲条款的时效安到乙条款上,更难检测。先治外源,再治内源,投入产出比差一个数量级。

(二)六类幻觉的判别指纹

把线上错例按这张表打标,两周之后就能看出本系统的主要失效模式集中在哪一类。

很多团队在「模型不准」这个笼统结论上停留很久,原因就是错例没有类型。一旦打上类型标签,你会发现三件事:绝大多数系统的错例高度集中在一到两类;这一到两类往往有一个非常具体、代价很低的修法;而通用手段(换更大的模型、写更长的提示词)对它们收效甚微,却要付出持续的成本。

打标的最小实现不需要任何平台。一张表、六个枚举值、一个人工标注入口即可:

错例 ID | 问题 | 模型输出 | 正确答案 | 幻觉类型 | 召回片段 ID

每周花两小时标三十条,一个月就有足够的分布数据。这张表同时是评测集的来源——标过的错例天然就是最有价值的回归用例。

(三)四层防线与加固顺序

四层防线成本递增、覆盖面递减,正确的做法是从下往上加。

输入层:给足证据。 检索质量、切片粒度、来源标注、有效期标签。覆盖外源幻觉的大部分。成本是一次性工程投入,运行期几乎不增加开销。这一层做好,后面三层的工作量会显著下降。

解码层:收紧输出空间。 降低温度、Schema 约束、枚举化、工具调用。覆盖格式类与取值越界类问题。成本低,主要是改调用参数与定义 Schema。

输出层:逐条校验。 引用核对、存在性查验、数值回算、语义校验。覆盖虚构实体、数值错误、无来源推理。成本中等,每次请求增加若干次查询或一次判别模型调用。

流程层:人在环与可撤销。 高风险动作需人工确认、所有动作可撤销、留痕可追溯。覆盖所有残余风险。成本高,直接影响自动化率与人力投入,但它是唯一一层能提供「上限保证」的防线。

顺序为什么重要?因为输出层校验的成本与召回质量成反比:证据给得越差,模型编得越多,校验器要拦的就越多,误杀也越多。一个反复出现的反面案例是:团队跳过检索优化,直接上一个「事实核查模型」做二次判别,结果核查模型自己的准确率也只有八成,两层叠加后整体准确率不升反降,成本却翻了一倍。

关于目标设定,还有一条务实的建议:不要给「幻觉率」定一个绝对数字目标,要按业务动作的可逆性分级。

  • 不可逆动作(退款、发货、对外承诺)→ 必须人工确认,模型只出建议;
  • 可逆但有成本(发通知、改状态)→ 自动执行 + 可一键撤销 + 抽检;
  • 无副作用(摘要、分类、建议)→ 自动执行 + 事后统计。

同一个模型、同一个幻觉率,在这三档里的可接受程度完全不同。把「我们的幻觉率能不能降到百分之一」这个无法回答的问题,换成「这个动作可不可逆、不可逆的那部分有没有人工闸门」,讨论立刻就能推进下去。

(四)把校验写成一条责任链

1、链的骨架

public interface AnswerValidator {
    ValidationResult validate(AnswerContext ctx);
}

// ctx 里至少要有:原始问题、召回片段(含 ID 与原文)、模型输出、
//                解析后的结构化结果、本次调用的参数与系统指纹

List<AnswerValidator> chain = List.of(
        new SchemaValidator(),           // 结构与类型
        new EnumValidator(),             // 枚举值必须在允许集合内
        new CitationValidator(),         // 每个事实句都要能指到一个片段 ID
        new EntityExistenceValidator(),  // 条款号 / 接口名 / 工单号必须真实存在
        new NumericRecomputeValidator(), // 金额与比例由代码重算,不采信模型
        new FreshnessValidator(),        // 引用片段的有效期必须覆盖当前时刻
        new PolicyValidator()            // 敏感承诺、绝对化措辞的黑名单
);

ValidationResult result = chain.stream()
        .map(v -> v.validate(ctx))
        .filter(ValidationResult::failed)
        .findFirst()
        .orElse(ValidationResult.ok());

三条设计纪律:

1. 校验器不修改答案,只给结论。「自动改写成正确答案」会让问题永远藏着,指标上看着很好,实际上你失去了发现问题的能力。

2. 失败结论必须携带定位信息:哪一句、期望什么、实际什么。没有这三样,校验器的告警会迅速退化成被忽略的噪声。

3. 每个校验器的拦截率单独埋点。拦截率为零的校验器要么多余,要么写错了——后者远比前者常见。

2、失败之后做什么

关键在于不要一律「重试」,而要按失败类型分流:

  • 结构类失败 → 可以重试一次(限次);
  • 引用类失败 → 退回检索,扩大召回后重跑;
  • 存在性失败 → 直接降级为标准话术或转人工;
  • 策略类失败 → 直接拦截并告警,不重试。

无差别重试是一个隐蔽的成本黑洞:它对格式类问题有效,对内容类问题几乎无效,但两者在代码里长得一模一样。

3、最有价值的两个校验器

如果只能先做两个,做这两个。

引用核对。 要求模型在每个事实句后标注片段编号,校验器逐句检查该编号是否存在、以及该句的关键实体是否真的出现在那个片段里。这一个校验器能拦住外源幻觉的大部分,而且实现只需要字符串匹配,不需要任何模型。

数值回算。 凡是金额、比例、期限、数量,一律不采信模型输出的数字,而是从结构化字段取值后由代码计算。模型负责的是「该用哪个公式、哪些字段」,不是「算出多少」。这条规则一旦立住,数值类错误会直接归零。

七、能力边界:哪些活不该交给它

(一)四类系统性弱点

精确计算与长串比对。 多位数乘法、跨行汇总、长编号逐位比对、日期区间运算。根因是这些任务需要精确的符号操作,而分词把数字切成了不对齐的碎片。正确做法是让它生成表达式或调用函数,由代码执行,绝不采信它口算的结果。

严格的多约束满足。 排班、配载、路径规划、同时满足七八条硬约束的方案生成。根因是它逐 Token 生成,无法回溯,也无法保证全局一致。正确做法是让它做约束的自然语言抽取,求解交给规划器或约束求解库。

时效性与私有知识。 最近发生的事、内部系统的数据、本公司特有的流程与口径。根因是训练数据有截止时间,也不可能包含你的内部系统。正确做法是检索或工具调用——这一类不是能力问题,是供给问题,也是四类里最好解决的一类。

自我认知与置信校准。 「你有多确定」「你是怎么算出来的」这类关于自身的提问。根因是它生成的是一段「像解释的文本」,而不是对内部计算过程的如实报告。正确做法是用外部信号估计置信度:召回分数、多次采样的一致率、校验通过率。

这四类的共同点是:它们都不是「再聪明一点就能做对」的任务,而是「机制上就不适合」的任务。把它们交出去,剩下的部分模型会做得相当好。

(二)三个「看起来能做」的陷阱

陷阱一:它算对了几次。 小样本上的成功率具有极强的误导性。多位数运算在简单样本上经常对,在位数增加后断崖下跌。验证方法是按难度分层各取五十条,看的是最难那一层的通过率,而不是总体通过率。

陷阱二:它解释得头头是道。 解释文本与实际生成过程没有因果关系。一个错误答案配一段完美解释,是这类模型最常见的表现形态。验证方法是只看结论对错,不要把解释的质量当成证据。这一条在技术评审里特别重要——一段流畅的推理过程很容易让评审者放松警惕。

陷阱三:换个提示词就好了。 提示词调优在单条样本上几乎总能生效,但很多时候只是过拟合到了那一条。验证方法是提示词改动必须在固定评测集上验证,并且同时看「修好了几条」与「弄坏了几条」——后者是最容易被跳过、也最能说明问题的一个数。

(三)判断与执行分离

把边界写进架构,落到具体做法上就是一句话:让模型做判断,让代码做执行。

以「计算本单应退金额并给客户一段说明」为例。

全交给模型的写法是:把订单详情和退款政策一起塞进提示词,让它算出金额并写说明。输出看起来很完整——「应退 213.60 元,其中运费不退……」——但有三个问题:这个数字无法验证也无法复现;政策理解错了也看不出来,因为过程不可见;政策改版之后,错误会静默地持续很久。

判断与执行分离的写法是三步:第一步由模型从政策文本里判定适用哪一条规则,输出规则 ID;第二步由代码按规则 ID 查出参数,用确定的公式算出金额;第三步再由模型拿着「规则 ID + 已算好的金额」写说明文字。

收益是双重的:金额可复现、可单测、可对账;模型只在「选规则」这一步可能出错,而这一步是一个有限分类问题,可以用评测集精确度量。

这个模式可以推广成一条通用原则:凡是能写成确定性函数的部分,都从模型的职责里拿出来。剩下给模型的,应该只有「理解自然语言」与「在有限选项中做判断」这两类它真正擅长的事。

八、把六个概念连起来:一次问答的完整账本

(一)逐环节的 Token、延迟与成本

把一次检索问答拆成账本,六个概念会同时出现在同一张表上。

三条可以直接从账本里读出来的结论:

1. 主生成吃掉了九成的时间与九成以上的成本。检索环节的性能优化收益有限,装配质量的收益却很大——这和大多数人的直觉相反,很多团队花了大力气优化向量检索的那几十毫秒。

2. 输出 Token 虽然只有 480,却贡献了约 6.4 秒里的绝大部分。「让它少写点」是延迟优化里最直接的一招,而且它同时省钱。

3. 首字延迟只有约 1.2 秒。改成流式返回后,用户感知的等待从 7.3 秒降到 1.2 秒,成本一分不变。

怎么把这张表做成自动产出的?在链路上每个环节埋一对「开始 / 结束」事件,并把 Token 数、召回数、命中缓存与否作为属性带上,然后按场景键聚合,每天出一张这样的表。有了它,「这个月成本涨了三成」这种问题可以在五分钟内定位到具体环节,而不是变成一次跨团队的排查会议。

(二)七个旋钮对三条曲线的影响

读这张矩阵的方法是:先确定当前最痛的是哪一条曲线,再在这一列里找「有利」的行。

  • 质量不够 → 先开重排、再补证据,最后才考虑换模型;
  • 成本太高 → 先做前缀缓存、再压 max_tokens,最后才降召回数;
  • 延迟太长 → 先开流式改善感知,再压输出长度,最后动召回。

每一列的顺序都是「先免费的、再便宜的、最后才是贵的」。

这里要单独点出一个反复出现的错误优先级:很多团队的第一反应是换更大的模型。它确实有效,但它是这张表里成本弹性最大、收益最不确定的一格。如果问题出在证据没召回,换模型完全无效;如果问题出在格式不稳,换模型收益远小于加 Schema;如果问题出在数值算错,换模型只是把错误率从高变成较高。换模型应该是排除掉前面所有选项之后的动作,而不是第一个。

(三)容量与并发怎么推算

有了账本,容量估算就不再是拍脑袋。

1、五步推算

1.1 算单请求的 Token 占用

注意这里要用「限流口径」而不是「计费口径」——输入 Token 加上 max_tokens(预扣)。用上面的例子:3200 + 2048 = 5248。如果把 max_tokens 压到 600,就是 3800,降幅接近三成。

1.2 用配额除以单请求占用,得到理论吞吐

假设每分钟 Token 配额是一百万,单请求 5248,理论上限是每分钟 190 次请求,也就是约 3.2 QPS。这个数字通常比团队预期的低得多,而且它是一个硬上限——再多加机器也不会变。

1.3 用 Little 定律换算并发

平均响应时间 7.3 秒,QPS 3.2,则稳态在途请求数约为 23。这意味着调用侧的线程池或信号量许可数设到 23 左右就够了。设成 200 只会让请求在客户端排队,把「被限流拒绝」这个明确的失败,变成「超时」这个模糊的失败。

1.4 留余量

模型服务的响应时间方差远大于普通 RPC,P99 是 P50 的三到五倍是常态。按 P95 而不是均值来算并发,再乘一个 1.3 的安全系数。

1.5 设计降级路径

触顶时应该做什么,必须在容量模型里就想清楚:是排队(有界队列 + 快速失败)、降级到小模型、还是直接回退到规则兜底。三种都可以,但不能是「不管,让它超时」。

2、这套推算真正的价值

不在于算得多准,而在于它让「我们能扛多少」这个问题有了一个可讨论、可验证的答案,而不是等到大促当天才知道。

它还会顺带暴露一个常被忽略的事实:在这条链路上,容量瓶颈几乎总是落在配额而不是机器上。加机器解决不了每分钟一百万 Token 的限制,能解决的只有三件事——压缩单请求占用、申请更高配额、把一部分流量分流到别的模型或别的通道上。这个判断会直接改变扩容方案的写法。

九、工程落地:Java 服务里的模型接入

(一)四层切分

这四层的边界与传统外部依赖接入高度相似,唯一的新东西是「模型行为」本身也要被治理。

业务编排层按业务流程决定:这一步要不要用模型、用哪个场景键、失败了走人工还是走标准话术、动作是否需要人工确认。硬约束是这一层不出现任何模型厂商的概念,也不出现提示词字符串。

能力层是一个场景键对应一个能力:工单分类、答复草稿、摘要。负责提示词模板、上下文装配、输出解析、答案校验、结果落库。硬约束是提示词与模板在这一层版本化,评测集与这一层一一对应。

接入层是统一的调用门面:参数下发、Token 计数与预算拦截、超时与重试、限流与排队、降级与熔断、成本护栏、调用留痕。硬约束是屏蔽厂商差异,所有指标在这一层产生。

驱动层是各家 SDK 或 HTTP 客户端的薄封装:协议转换、流式解析、错误码归一、连接池与超时参数。硬约束是只做翻译,不做决策。

这个切分最大的价值是让「换一家厂商」和「换一个提示词」变成两件完全不相干的事。在没有分层的实现里,这两件事都要改同一个类。

(二)超时、重试与幂等

超时与重试在这条链路上有三条特殊规则。

一、超时要按场景分档,不能全局一个值。 分类任务三秒就该超时,长文生成给三十秒也不算长。共用一个值必然两头不对:要么分类任务卡住三十秒拖垮线程池,要么长文生成还没写完就被掐断。

二、流式调用的超时要拆成两个:首字超时与 Token 间隔超时。 只设总超时,会让「服务端卡住不吐字」这种情况迟迟不被发现——在用户看来是界面一直转圈,在监控上是一条正常的长耗时请求。

三、长输出任务默认不重试。 一次重试等于再付一次全额成本,而长输出失败多半不是偶发抖动。改为降级或转人工。

幂等键按「业务实体 + 能力名 + 输入指纹」构造。输入指纹要覆盖提示词模板版本与参数——模板一改,指纹就变,结果自然重算。这一点很容易漏:如果指纹只算用户输入,那么改了提示词之后所有历史结果都不会刷新,你会在很长一段时间里以为新提示词没生效。

留痕方面,每次调用落一条记录:输入快照、参数、系统指纹、输出、Token 用量、校验结论、耗时。这张表是事后所有分析的唯一数据源,它的缺失会让每一次争议都变成口头推测。存储成本通常远低于想象——真正占空间的是输入快照,可以按天归档或只存哈希加引用。

(三)该埋哪些指标

四类指标各有各的用途:计量类回答「用了多少」,质量类回答「对不对」,性能类回答「快不快」,成本类回答「值不值」。

如果只能埋三个,埋这三个:上下文占用率、解析失败率、单次成本。它们分别是计量、质量、成本三条线上最灵敏的先行指标,绝大多数问题在它们身上都会先露出苗头。

  • 上下文占用率持续爬升 → 会话治理策略要调整了,否则迟早撞窗口;
  • 解析失败率突然抬升 → 大概率是服务端模型版本变了;
  • 单次成本突然抬升 → 要么是输入变长了,要么是缓存命中率掉了。

(四)把模型行为纳入交付闸门

最后一件事,也是最容易被推迟的一件事:评测集与回归。

传统服务的交付闸门是单元测试加集成测试,它们验证的是「代码逻辑对不对」。模型接入之后多了一类风险:代码一行没改,行为却变了。来源可能是提示词改动、参数改动、检索库更新、或者服务端模型版本漂移。这类风险现有的测试体系完全覆盖不到。

补法不复杂,分三步:

第一步,每个场景键建一个评测集。 五十到两百条,来源优先用线上标过的错例。每条包含输入、期望输出(或期望的判定标准)、以及一个可自动判定的断言。

第二步,把评测跑成一条可重复的命令。 输出三个数:通过率、平均 Token、P95 延迟。这条命令要能在本地跑,也能在流水线上跑。

第三步,定义什么情况下必须跑。 至少四种:提示词模板变更、参数配置变更、检索库或切片逻辑变更、系统指纹发生变化。前三种是主动触发,第四种需要一个定时任务去比对指纹。

做到这三步之后,「改一次提示词能不能在半小时内跑完回归」这个问题就有了肯定的答案,而这个答案会直接决定团队敢不敢持续优化。做不到的团队最终都会停止改动——因为每一次改动都是一次赌博。

十、常见误区与上线前自检

把前面各节的反面案例集中起来,形成一份误区清单。

关于 Token:

  • 用「字符数除以常数」做窗口裁剪。误差三成,迟早截断。
  • 把 max_tokens 开到模型上限。限流按预扣计算,有效吞吐会被砍到几分之一。
  • 忘记算工具定义与消息角色包裹。它们在代码里不以字符串形式出现,最容易漏。
  • 把 Base64 附件原文塞进提示词。最贵的价格,最差的效果。

关于上下文窗口:

  • 先拼字符串再看长度。终检只能拒绝,不能补救。
  • 输出预留放在最后扣。答案会在生成到一半时被截断,而且往往仍是合法 JSON。
  • 把整份文档塞进大窗口让它自己找。装得下不等于找得准。
  • 在提示词前缀里放时间戳。整段前缀缓存全部失效。
  • 用 HashMap 遍历拼工具定义。JVM 重启后顺序变化,缓存命中率无声塌陷。

关于温度与采样:

  • 用调低温度来解决「答得不对」。它只能解决「答得不稳」。
  • 同时调温度和 top-p。随机性被乘起来,调参变成盲试。
  • 把温度写成代码里的常量。它一定需要调整,而发版成本会让你放弃调整。
  • 指望 temperature=0 带来严格可复现。换成幂等键与枚举约束。
  • 用正则从自由文本里抠 JSON。先上 Schema 约束或工具调用。

关于 Embedding 与检索:

  • 用相似度处理时间、金额、编号这类条件。抽成元数据用过滤条件。
  • 只取 top-3 就送进上下文。先召回几十条再重排。
  • 向量相似度与关键词得分直接加权相加。用名次融合,不用分数融合。
  • 换嵌入模型只重嵌新数据。两套坐标系混在一起,排序彻底失真。
  • 向量表里不记录模型版本。升级时你会发现自己无从下手。

关于幻觉与边界:

  • 把模型的语气当成置信度。两者不相关。
  • 跳过检索优化直接上事实核查模型。两层八成叠加可能不升反降。
  • 采信模型算出来的金额。让它选公式,让代码算数。
  • 用「它解释得很有道理」作为验收依据。解释与生成过程没有因果关系。
  • 给幻觉率定绝对数字目标。按动作可逆性分级更可操作。

上线前的十四个问题(对应本文最后一张图):能说出单次请求的 Token 中位数与 P95 吗?上下文装配有没有独立组件?系统提示与工具定义是否字节级稳定?每个场景键有没有独立配置与评测集?采样参数是配置项还是代码常量?结构化输出用的是 Schema 约束还是祈使句?向量表有没有记录模型版本?检索中间产物落日志了吗?答案校验是一条可枚举的链吗?金额是代码回算的吗?不可逆动作有没有人工确认与撤销路径?改一次提示词能否半小时内跑完回归?系统指纹变化时有没有机制触发重跑?成本看板能否下钻到场景键?

有任何一条答不上来,就说明那一块还没有被工程化。

十一、结语

这六个概念放在一起,指向的其实是同一件事:大模型不是一个「更智能的服务」,而是一个有明确计量单位、明确容量上限、明确随机性来源、明确失效模式与明确能力边界的外部依赖。

一旦用这个视角去看它,Java 工程师积累的所有经验都能直接迁移过来:容量要估算,配额要治理,参数要配置化,调用要幂等,失败要分类,变更要灰度,行为要有回归闸门。这些东西一样都不新,只是对象换了一个。

真正需要新建的能力只有两样。

一是把模型的行为纳入可观测体系。传统依赖的可观测停留在「调用成功与否、耗时多少」,模型依赖还要加上「用了多少额度、证据给够了没有、输出能不能解析、答案有没有依据」。这四个问题都能量化,也都值得量化。

二是建立一套关于「不确定性」的工程语言。传统系统里,同样的输入得到不同的输出是 bug;在这里它是常态。团队需要把讨论从「怎么让它确定」转向「哪些环节必须确定、哪些环节允许抖动、抖动落在哪里是安全的」。这个转换一旦完成,绝大多数关于「模型靠不靠谱」的争论都会自动消失,取而代之的是一组具体的、可以排期的工程任务。

最后回到标题那句话:会调接口不等于懂模型。这里的「懂」不是指理解它的内部结构,而是指知道它的账怎么算、边界在哪里、出错时往哪一层去找。这层理解不需要任何数学背景,只需要把它当成一个需要认真对待的外部依赖——而这恰好是后端工程师最擅长的事。

参考资料

基础概念与分词

上下文窗口与长文本

采样参数与确定性

Embedding 与检索

幻觉与评测

Java 生态的工程落地

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/xiaofeng10330111/article/details/166736880

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--