同一份权重，换个用法能差出十几分，也能差出十倍成本。推理时策略（test-time 策略）就是这样一类东西：不改模型，只改"怎么问、问几次、要不要它自己检查"。麻烦在于三种策略的成本结构完全不同——Chain-of-Thought 加长输出，Self-Consistency 乘以调用数，Self-Refine 乘轮次，三者叠起来是乘积关系。先把这笔账算清楚，再决定开哪一档。

1. 推理时算力花在哪三个地方

四条加起来，最坏情况是 输入 × 调用数 × 轮次。这个乘积是所有"推理成本失控"事故的共同形状。

2. Chain-of-Thought：它买到的是"可中断的中间状态"

CoT 有效的机制解释：让模型把中间量写进上下文，后续 token 就能以这些中间量为条件，而不是在单步里同时完成"回忆 + 计算 + 组织答案"。它换来的是可分解性，不是"更聪明"。

COT_TMPL = """按下面四步作答，每步一行，最后一行只输出结论：
1) 已知条件：从题面摘出全部给定值与单位
2) 目标：要求的是什么，单位是什么
3) 推导：写出用到的关系式，逐步代入
4) 结论：只写最终值，带单位

题面：{q}"""

一个反直觉的实测倾向：CoT 会放大"题目本身有歧义"的影响。模型会把歧义沿着推理链一路放大，最后给出一个看起来很严谨的错误答案。歧义题的正确处理是先追问澄清，不是加推理链。

3. Self-Consistency：票数与温度是同一个旋钮的两半

Self-Consistency 的做法：同一问题采样 N 条推理链，对最终答案取多数。它成立的前提有两个——答案可归一化（能判等）、错误分布不是系统性同向。

from collections import Counter

def self_consistency(q, llm, n=5, temperature=0.7):
    answers = []
    for _ in range(n):
        chain = llm(COT_TMPL.format(q=q), temperature=temperature)
        answers.append(normalize(chain.strip().splitlines()[-1]))
    top, cnt = Counter(answers).most_common(1)[0]
    return top, cnt / n          # 一致率是重要信号，不只是副产品

两个必须注意的点：

• 温度太低时多票没有意义。temperature=0 采样出的链几乎相同，等于用 5 倍成本做一次调用。
• 一致率要当指标看。一致率低于 0.6 说明题目本身歧义或模型没有该能力，加票只是把错误答案投票得更自信。

import re
UNITS = ("元", "美元", "kg", "公里")

def normalize(ans):
    a = ans.strip().replace(",", "").replace("，", "")
    a = re.sub(r"\s+", "", a)
    for u in UNITS:
        a = a.replace(u, "")
    # 数值型统一到同一精度，文本型转小写去标点
    try:
        return f"{float(a):.4g}"
    except ValueError:
        return re.sub(r"[。．.!！?？]", "", a).lower()

答案归一化是最容易漏的一步：1,200、1200元、1200 是同一个答案，不归一化就变成三票分散。

4. Self-Refine：收益全在"反馈是否可判定"

Self-Refine 是"生成 → 自我批评 → 修订"的循环。它能起作用的唯一条件是批评环节引入了新信息：要么来自外部校验器（编译、单测、schema 校验），要么来自明确的评分标准。

def self_refine(task, llm, check, max_rounds=3):
    draft = llm(task)
    for r in range(max_rounds):
        ok, report = check(draft)          # 可判定反馈：单测 / schema / 规则
        if ok:
            return draft, r
        new = llm(f"{task}\n\n上一版问题：{report}\n只修这些问题，不要重写：\n{draft}")
        if new.strip() == draft.strip():    # 修订无效，早停
            return draft, r
        draft = new
    return draft, max_rounds

弱反馈下的 Self-Refine 是典型的"看起来在工作"：每轮都有改动，质量不动甚至下降。判断方法很简单——把轮次从 3 降到 1，指标如果没有明显变化，那两轮就是白花钱。

5. Thought-Action-Observation 与 CoT 的分界

CoT 是"想"，Thought-Action-Observation 是"想一步、做一步、看结果"。区别在于信息是否来自环境。

判据：需要环境里的事实就走向 Observation，纯靠已知条件推就走 CoT。用 CoT 猜数据库里的值，是最常见的误用。

6. 成本账：三种策略的乘法关系

# 粗略成本估算：in/out 单价按供应商单价表核对，此处只示范结构
def cost(in_tok, out_tok, calls, price_in, price_out):
    return calls * (in_tok * price_in + out_tok * price_out)

base = dict(in_tok=800, out_tok=200, calls=1)
cot  = dict(in_tok=800, out_tok=900, calls=1)              # CoT 拉长输出
sc   = dict(in_tok=800, out_tok=900, calls=5)              # 5 票
both = dict(in_tok=800, out_tok=900, calls=5)              # 5 票 + 2 轮修订
print(cost(**base, price_in=1e-6, price_out=4e-6))
print(cost(**both, price_in=1e-6, price_out=4e-6) * 2)

表中的倍数是结构推演的量级，具体倍数按实际 token 分布与单价核对。能承受的只有离线任务与低 QPS 场景；在线高并发链路上开满三件套，账单会先于质量出事。

7. 路由：不是所有请求都配得上重推理

路由实现上，先做一个便宜的分类器（规则 + 小模型），把请求分到档位，再按档位设不同的超时与预算上限。没有预算上限的推理策略一定会被长尾请求打穿。

TIERS = {                      # 每档：票数、轮次、输出上限
    "direct":   dict(n=1, rounds=1, max_out=300),
    "cot":      dict(n=1, rounds=1, max_out=1200),
    "vote":     dict(n=5, rounds=1, max_out=1200),
    "refine":   dict(n=1, rounds=3, max_out=2000),
}

def route(req):
    if req.hit_cache:                     return "direct"
    if req.has_verifier and req.is_code:  return "refine"
    if req.answer_is_unique:              return "vote"
    return "cot" if req.needs_calc else "direct"

8. 排错：六种"策略开了但没用"

9. 边界：推理时策略改不了的东西

10. 自测

1. Chain-of-Thought 与 Self-Consistency 的成本分别按什么方式增长？两者叠加是什么关系？
2. temperature=0 时做 5 票 Self-Consistency，问题出在哪？
3. 一致率 0.55 说明什么？继续加票能解决吗？
4. Self-Refine 在什么条件下才有正收益？如何用一次实验判断那两轮是否白花钱？
5. 什么时候必须用 Thought-Action-Observation 而不能用 CoT？
6. 给在线高并发链路设计推理档位路由时，除了任务特征还必须限制什么？