多模型路由的成本收益:路由误判的代价是不对称的,所以别拿分类准确率当指标

举报
yd_232401777 发表于 2026/11/16 07:56:47 2026/11/16
【摘要】 给问答服务加一层"简单问题走小模型、复杂问题走大模型"的路由,账单确实会降,但降多少、以及有没有把质量换掉了,多数团队算不清。问题出在两处:成本侧只看了单价,漏掉了输出长度、重试、缓存切碎这些真实开销;收益侧把路由当成分类任务,用准确率评估,而两类误判的代价差着量级——把简单题送进大模型只是多花钱,把难题送进小模型是答错。本文给出一个「质量下界约束下最小化成本」的评估框架、一个

前言

我做过一个双模型分流的问答服务。上层挂一个大模型,能扛多步推理和长文档;底层挂一个小模型,便宜、快,简单事实问答够用。中间加了个路由器:输入先过一遍规则和轻量分类器,判成"简单"就走小模型,判成"复杂"就升级。

上线第一周的账单很漂亮,单位请求成本明显下来了一截。第二周开始收到一类奇怪的反馈:不是"报错了",也不是"答得太长",而是"回答变浅了"——本来会给三段推导的问题,现在给一句结论就完了,用户还得再问一遍才拿到想要的东西。

把日志拉出来对,问题很集中:被分到小模型的请求里,有一批是需要跨两三个文档片段做比较的问题。这类问题的表面特征很像简单问答——句子短、没有明显的"分析""对比"字样、实体只有一个。路由器看到的是表面,用户的真实难度在语义里。

更麻烦的是我怎么证明这件事。分类器在标注集上有八十几的准确率,单看这个数字它没什么毛病。可上线之后体验变差是确定的。这说明一件事:当两类错误的代价差着量级时,分类准确率不是个有用的指标。 后面我重做了评估口径,也改了路由的决策逻辑,这篇把方法记下来。

一、先算清成本,不然收益是假的

1.1 单价差不是成本差

大多数这类方案的立项依据是一句话:"小模型单价是大模型的十几分之一,一半流量分过去,成本减半。" 这句话里藏了三个漏项。

第一,输出长度不一样。 小模型为了显得可靠,往往话更多、铺垫更长。同一个问题,大模型可能 200 token 收尾,小模型写 500 token 还没进入正题。单价差 15 倍,但如果输出 token 是 2.5 倍,实际单请求成本差就变成 6 倍。这个差异在 prompt 短、回答长的场景里尤其致命——输出 token 才是成本主项。

第二,重试成本。 小模型答不到点上,用户重问一次,这一次请求的成本是小模型 + 大模型(因为重问往往伴随更明确的表述,会被判成复杂)。一次误判的实际成本是"省下的钱"的负数。

第三,缓存被切碎。 这是最容易被忽略的一项。原来所有请求都打同一个模型,前缀缓存和语义缓存的命中率是自然累积的;分流之后,同一类问题被分到两个池子,每个池子的缓存都在冷启动和小规模区间。如果原本的缓存命中率贡献了相当一部分成本节省,分流会把这块收益反过来吃掉。

所以正确的算式不是"单价 × 流量占比",而是:

单请求成本 = (输入token × 输入单价 + 输出token × 输出单价) × (1 - 缓存命中率) × (1 + 重试率)

四个因子,分流会同时影响后三个。任何一个不算,结论都可能是反的。

1.2 路由本身有成本

第二类漏项是路由器自己的开销。

  • 规则路由几乎零成本,但覆盖率和准确率都有限,只适合识别"明显"的类别(超长输入、带代码块、带明确指令词)。
  • 轻量分类器(几百万参数的小模型、或者 embedding + 逻辑回归)成本可忽略,但它的能力上限决定了它能识别多细的难度差异。
  • 用大模型判难度是最贵的一种,等于每个请求先付一次大模型的输入钱。如果被判成简单的请求占了七成,你等于给七成流量加了一道固定税。
  • 用 embedding 相似度打难度分看起来便宜,但真正的工作量在维护那批"难度锚点"样本上,是长期人力成本。

我在第一版里用的是"用大模型判难度"加"再看它的输出"。后来改成规则 + 小分类器,主要不是因为钱,是因为链路里多一次模型调用,延迟和故障面都变大了——路由器的可用性必须高于被路由的模型,否则它就成了单点。

1.3 一次成本对比的正确姿势

评估时必须同时量三条基线,缺一条都没有意义:

配置用途关注点
全走大模型质量上界 / 成本上界这是"如果不管钱"的水平
全走小模型质量下界 / 成本下界这是"如果不管质量"的水平
路由待评估方案必须落在两点之间,且靠近你想要的那一端

只看"路由比全大模型省了多少"是常见错误——它可能是把质量整体拉到了"全小模型"那一侧,只是没那么明显。要同时看质量落在哪。 如果路由的质量和全小模型几乎一样,那它不是路由器,它是个很贵的开关。

二、误判为什么不能一视同仁

2.1 两类错误,代价差几个量级

路由器有两种错:

  • 把简单题判成难题(误升级):请求被送进大模型,多花钱。代价可测、有上界、与单价成正比。
  • 把难题判成简单题(漏升级):请求被送进小模型,答案质量掉下来。代价不可测、没有上界——用户流失、二次提问、人工兜底、错误的结论被当真用下去。

这两件事在业务上的重量完全不同。一个可以算进预算,一个会变成事故。所以在设计目标函数时,加权必须极端不对称。

用统一口径写出来:设漏升级一次的相对代价是 C_fn,误升级一次是 C_fp,在问答场景里 C_fn / C_fp 落到 10 到 100 之间是常见的量级——因为一次误升级的成本就是"两个模型的差价",而一次漏升级的成本至少是"用户重问一次的完整开销",再加上体验损失。

这个比值不需要精确,它只需要大于 1 且明显大于 1,就足以改变最优阈值的方向:最优策略会系统性地偏向"宁可升级"。

2.2 别用准确率,用加权代价

分类准确率隐含了 C_fn = C_fp 的假设。把这个假设换掉,评估指标跟着换:

加权代价 = C_fn × 漏升级数 + C_fp × 误升级数

再把它归一化成"每个请求的平均代价",就能和纯成本直接比。实际用的时候我会画一条曲线:横轴是升级率(被判成复杂、送进大模型的流量比例),纵轴是加权代价。曲线通常是个 U 形——升级率太低,漏升级代价压不下来;升级率太高,成本顶上来。U 形的最低点就是路由器该工作的位置。

这条曲线还有个好处:它把"路由器好不好"和"阈值定在哪"分开了。同样一个分类器,阈值挪一挪,U 形的位置完全不同。很多团队抱怨路由器效果差,实际是阈值定错了,而不是分类器不行。

2.3 给路由器留一个"我不确定"的出口

比调阈值更有效的一招:允许路由器输出第三种答案——"不确定"。

不确定的请求直接按复杂处理。这不是偷懒,是把一个二分类问题变成了"分类 + 拒识"的问题。拒识区间的宽度可以单独调,而且它天然符合代价不对称的要求:不确定的时候,成本更高的那类错误必须先避免。

实现上这个出口有很多种做法:分类器输出的概率落在中间区间、规则命中冲突、输入长度落在某个模糊带、检索召回分数偏低。任一条件触发就升级。我后来把"检索阶段召回分数低"也接进了这个出口——这个信号比分类器自己靠谱得多,因为它是检索链路真实产生的,不是猜的。

三、评估集怎么搭,才不会被自己骗

3.1 难度分布要对齐线上

离线评测集最常见的失真:它是人工挑出来的,难题比例远高于线上。于是在这个集合上,"路由器把四成请求升级"看起来合理;放到线上,四成升级意味着成本几乎没降。

两个修法:一是给评测集分层,按难度桶(事实查询 / 单文档归纳 / 跨文档比较 / 多步推理)分别统计升级率和质量差,再看线上各桶的真实占比做重加权;二是直接抽线上日志做样本,用大模型加人工抽检打标,哪怕只有几百条,分布是对的。

我倾向第二种。分布对的五百条,比分布错的五千条有用。

3.2 质量不能只看"对不对"

问答场景里,"判对错"只能覆盖一部分。更实用的做法是三维打分:事实正确性、完整性、是否直接回答。小模型的典型短板不在事实正确性上——它经常把事实说对,但只说了一半,或者绕了一圈没落到用户问的那一点上。只测正确性会把这类问题全部漏掉,而这恰好是漏升级最主要的伤害形式。

如果用大模型当裁判,要注意裁判本身的偏好:它对"更长、更结构化"的回答有系统性偏好,而这正好是小模型吃亏的地方。缓解办法是成对比较(同一个问题两个答案,问哪个更好)而不是单边打分,并且把顺序随机的两份都跑一遍,看结论是否稳定。不稳定的样本直接剔掉,别硬算。

3.3 看分桶,不看总分

汇总一个总准确率,几乎一定会掩盖问题。我关注三张表:

  1. 按难度桶:每桶的升级率、漏升级率、质量差。漏升级集中在哪个桶,就是路由器缺哪种信号。
  2. 按输入长度:短输入里藏难题的比例经常被低估。长度不是难度,但很多路由器实际上就是在用长度当难度。
  3. 按业务意图:某些意图(比如"这个报错什么意思")看起来简单,实际需要跨版本知识;某些("帮我写个总结")看起来重,实际是套模板。意图维度的误判率往往比整体高一截。

四、一个能用的最小实现

下面这段是路由决策的骨架,重点是那个不确定性出口和影子记录——影子记录是后面能持续改进的唯一依据,别省。

# 示意:路由决策。真实项目里 classify() 换成自己的分类器或规则集
from dataclasses import dataclass, field

UPGRADE_RATE_CEILING = 0.45   # 升级率上限,防止成本失控
UNCERTAIN_BAND = (0.35, 0.65)  # 概率落在这区间视为"不确定",直接升级

@dataclass
class RouteDecision:
    model: str
    score: float
    reason: str
    shadow: dict = field(default_factory=dict)

def route(query: str, hard_rules, classify, retrieval_score=None) -> RouteDecision:
    # 1) 硬规则:命中即升级,成本几乎为零,先吃掉最明显的部分
    hit = hard_rules.match(query)
    if hit:
        return RouteDecision("large", 1.0, f"rule:{hit}")

    # 2) 分类器给难度概率
    p_hard = classify(query)

    # 3) 不确定性出口:中间地带 + 检索召回偏低,都往难的方向倒
    if UNCERTAIN_BAND[0] <= p_hard <= UNCERTAIN_BAND[1]:
        return RouteDecision("large", p_hard, "uncertain_band")
    if retrieval_score is not None and retrieval_score < 0.30:
        # 检索都没召到像样的片段,说明问题可能需要推理而不是查找
        return RouteDecision("large", p_hard, "weak_retrieval")

    model = "large" if p_hard > UNCERTAIN_BAND[1] else "small"
    return RouteDecision(model, p_hard, "classifier",
                         shadow={"p_hard": p_hard, "retrieval_score": retrieval_score})

第二段是离线评估,用来画那条 U 形曲线。关键在于把升级率当自变量扫描,而不是只算一个点:

# 示意:用标注集扫描阈值,输出加权代价曲线
def cost_curve(samples, c_fn=20.0, c_fp=1.0, thresholds=None):
    """samples: [(p_hard, is_hard_truth, cost_large, cost_small)]
    c_fn / c_fp 是相对代价,只需比值有意义。"""
    thresholds = thresholds or [i / 20 for i in range(21)]
    rows = []
    for t in thresholds:
        fn = fp = 0
        cost = 0.0
        for p_hard, truth, cost_large, cost_small in samples:
            decided_hard = p_hard > t
            cost += cost_large if decided_hard else cost_small
            if truth and not decided_hard:
                fn += 1
            if not truth and decided_hard:
                fp += 1
        weighted = cost + c_fn * fn + c_fp * fp
        rows.append({
            "threshold": t,
            "upgrade_rate": sum(1 for s in samples if s[0] > t) / len(samples),
            "fn": fn, "fp": fp,
            "cost": round(cost, 2),
            "weighted_cost": round(weighted, 2),
        })
    return rows

跑完之后不要只取最低点。我实际的选法是:在加权代价不超过最低点 5% 的阈值区间里,选升级率最低的那个。 理由很实际——加权代价里的 C_fn 是个估计值,估高了会推着阈值往上走;选区间内的低升级率点,等于给"我把 C_fn 估过头了"这种情况留了余量,同时成本更好看。

上线阶段的动作顺序也值得说一句。别一上来就全量切:先影子模式跑一周,只记录路由决策不实际分流,拿到线上真实的难度分布和升级率,重新校准阈值;然后按 5%~10% 灰度,把"回滚判据"提前写死(比如漏升级的人工抽检比例超过某个阈值就回滚),而不是等投诉来了再开会决定。

做了什么

这篇里的成本拆解、误判代价不对称的结论,来自我自己做双模型分流时的实际返工——第一版确实是按"单价 × 流量占比"立的项,也确实在上线两周后被"回答变浅"的反馈推翻,重做了评估口径。那条"多步比较类问题被误判"的具体现象、以及把检索召回分数接进不确定性出口这个改法,都是踩出来的。

需要说清楚的是规模:我没有大规模流量可以跑 A/B 显著性检验,文里的收益量级是按单价与 token 结构推导的,不是实测出来的百分比;那个以 20:1 为 C_fn/C_fp 的默认值也只是个示例参数,实际该按业务里"一次答错的完整成本"去估。两条代码是能跑的骨架,分类器和规则集要换成自己的。

一些体会

  1. 路由不是分类问题,是决策问题。 分类器只要输出一个概率,怎么用它才是钱和质量的分界线。把阈值和分类器分开评估,能省掉大量无效的模型迭代。
  2. 先量"全小模型"的质量。 如果它已经够用,你不需要路由器,你需要直接把大模型从链路上摘掉——这比任何路由策略都省钱且稳定。
  3. 误判要向"贵的那一侧"倒。 不确定性出口不是补丁,它是把代价不对称写进决策逻辑的唯一位置。没有它,调阈值永远在走钢丝。
  4. 成本要按单请求全量算。 输出长度、重试、缓存命中率这三个因子会同时被分流影响,任何一个不进来,算出来的收益都可能偏高。
  5. 别忽略路由器的可用性。 它挡在所有请求前面,一旦它挂了,整个服务就挂了。规则优先、分类器兜底、模型判定放最后,这条顺序能救你一次线上事故。
【声明】本内容来自华为云开发者社区博主,不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0)

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。