推理模型与测试时计算 Reasoning & Test-Time Compute

阶段总览

1. 推理模型到底是什么

1.1 长思维链与思考预算

推理模型的核心变化不在架构，而在后训练目标与输出形态：模型被训练成在给出答案前先生成一段（可能很长的）思考过程，这段过程会被后续的自我检查反复审视。训练方式的关键是用可验证奖励做 RL，让「想对了才答对」这件事被奖励直接塑造。

1.2 涌现的自我纠错与长度增长

RL 训练中会自然出现两种现象：一是模型开始写出类似 「等一下，我前面这一步好像不对，让我重新检查」 的反思语句，并据此修正；二是输出长度随训练增长，因为更长的思考在可验证奖励下更容易碰对答案，但长度增长会带来成本问题——这就是 GFPO、Dr.GRPO 这类工作的动机。

• 反思词很脆弱：CISPO 的观察是，标准的裁剪机制会把「wait / recheck / hmm」这类低概率 token 的梯度裁掉，反而不利于学习反思行为，因此改为只裁剪权重不裁剪 token。
• 难度自适应：理想情况下简单问题短思考、困难问题长思考。但实际中模型常常在简单问题上也冗长，需要通过训练信号或推理端控制来纠偏。
• 长度不等于能力：把长度当作代理指标会误导。要同时看准确率、token 效率（每正确一次的 token 成本）。

python# 监控「长度 vs 准确率 vs 熵」：判断长思考是能力还是凑长度
import numpy as np

def diagnose(lengths, correct, entropy):
    L, C, H = np.array(lengths), np.array(correct, float), np.array(entropy)
    print("长度-正确 相关:", round(float(np.corrcoef(L, C)[0, 1]), 3))
    bins = np.digitize(L, np.quantile(L, [0.25, 0.5, 0.75]))
    for b in range(4):
        m = bins == b
        if m.sum():
            print(f"箱{b}: 均长={L[m].mean():.0f} 准确率={C[m].mean():.2f} "
                  f"token/correct={L[m].sum()/max(1, C[m].sum()):.0f}")
    print("熵是否崩塌:", H[-1] < 0.5 * H[0])

# 预期输出（示意）
# 长度-正确 相关: 0.31           <- 弱正相关, 长度并非主导因素
# 箱0: 均长=210 准确率=0.96 token/correct=219
# 箱3: 均长=4200 准确率=0.63 token/correct=6667   <- 难题确需长思考但收益递减
# 熵是否崩塌: False
# 判读: 相关弱 + 难题 token/correct 飙升 = 长思考对难题必要, 简单题则是浪费

1.3 动手练习与自测

1. 给定「思考 token 数与最终准确率」散点，如何判断模型是「真在推理」还是「在凑长度」？写出判据与两条对照实验。
2. 同一问题用 temperature=0 与 0.8 各采样 8 次，准确率 82% / 79%，但后者 8 次里 6 次答案一致。这说明什么？
3. 「长思维链一定是模型的真实推理」错在哪？给出至少两条反例场景。
4. 把一次思考的边际收益量化：若第 k 次采样新增正确率 Δp≈0.02、单次成本 C，写出「是否值得再采样」的判据。
5. 为什么 2026 年很多产品用「多采样 + 一致性检验 + 外部验证器」而非相信单次 CoT？

2. 怎么训练出推理能力

2.1 四步标准流程

python# 可验证奖励的典型组合：正确性 + 格式 + 语言一致
import re

def extract_boxed(text):
    m = re.findall(r"\\boxed\{([^}]*)\}", text)
    return m[-1].strip() if m else None

def reward(prompt, completion, gold):
    r = 0.0
    # 1) 正确性：主要奖励，权重占绝对主导
    if extract_boxed(completion) == gold:
        r += 1.0
    # 2) 格式合规：必须有思考段与最终答案段
    if "思考" in completion and "答案" in completion:
        r += 0.1
    else:
        r -= 0.1          # 格式不对要惩罚，否则模型会绕开格式约束
    # 3) 语言一致性：避免中英混杂（按目标语言判断）
    if re.search(r"[\u4e00-\u9fff]", completion):
        r += 0.05
    return r

# 注意：绝不要用「长度」或「看起来自信」作为奖励 —— 那就是奖励黑客的入口

2.2 动手练习与自测

1. 写出 RLVR 三段奖励（正确性 / 格式 / 语言）的典型权重，并说明为什么正确性必须占绝对主导。
2. GRPO 的优势 A_i = (r_i − mean(r)) / std(r)。若某 prompt 的 8 条轨迹全对（std=0）会怎样？工程上如何处理？
3. 奖励曲线上升但熵骤降、长度暴涨，最可能是哪一步出错？给出排查顺序。
4. 设计「长度惩罚 reward −= alpha × len」，说明 alpha 取 1e-4 与 1e-1 各会造成什么后果。
5. 为什么格式奖励权重过高会导致「奖励被 hack」？给一个可观测的监控指标。

3. 测试时计算扩展：把算力花在推理上

3.1 六种手段与成本收益

python# 自洽性（Self-Consistency）：最简单、最实用的测试时扩展手段
import asyncio, re, collections

def normalize(ans):
    if ans is None: return None
    return re.sub(r"[,\s$%]", "", str(ans)).lower()

async def self_consistency(llm, question, n=9, temperature=0.8):
    async def one():
        text = await llm.chat(
            [{"role": "system", "content": "分步推理，最后一行输出「答案: XXX」"},
             {"role": "user", "content": question}],
            temperature=temperature)
        m = re.search(r"答案[:：]\s*(.+)", text)
        return normalize(m.group(1) if m else None)

    answers = await asyncio.gather(*[one() for _ in range(n)])
    answers = [a for a in answers if a]
    if not answers: return None, 0.0
    top, cnt = collections.Counter(answers).most_common(1)[0]
    return top, cnt / len(answers)          # 一致性比例可以当置信度用

# 实用技巧：把「一致性比例」作为置信度，低于阈值就升级到更强模型或转人工

python# 采样温度与 top-p：控制探索多样性的两个旋钮（自洽性采样的核心超参）
import numpy as np

def softmax(logits, temperature=1.0):
    z = np.asarray(logits, dtype=float) / max(temperature, 1e-6)
    z -= z.max()                          # 数值稳定
    e = np.exp(z)
    return e / e.sum()

def top_p_filter(probs, p=0.9):
    order = np.argsort(probs)[::-1]       # 按概率降序
    csum = np.cumsum(probs[order])
    keep = order[:np.searchsorted(csum, p) + 1]   # 最小的高概率集合
    out = np.zeros_like(probs); out[keep] = probs[keep]
    return out / out.sum()                # 重新归一化

logits = [3.0, 2.0, 1.0, 0.5, -1.0]
for T in [0.1, 0.7, 1.0, 2.0]:
    print(f"T={T}:", np.round(softmax(logits, T), 3))
# 预期输出（示意）：
# T=0.1: [1. 0. 0. 0. 0.]            <- 几乎贪心，多样性≈0
# T=0.7: [0.66 0.24 0.09 0.01 0.]
# T=1.0: [0.52 0.19 0.07 0.04 0.01]
# T=2.0: [0.34 0.21 0.12 0.09 0.04]  <- 更均匀，适合多采样投票
# 经验：自洽性采样用 T=0.7~1.0 + top_p=0.9~0.95；温度过高会引入低级错误

3.2 过程奖励模型（PRM）与验证器

结果奖励只看最终答案，问题是在几十步推理里无法定位是哪一步错了。过程奖励模型（PRM）对每一个中间步骤打分，从而支持逐步搜索与早期剪枝。代价是需要过程级标注，人工成本高，且标注标准难以统一。

3.3 动手练习与自测

1. 设单次正确率 p=0.6、k=9 自洽性投票（独立采样），用二项分布估算「多数正确」的概率，并解释 p<0.5 时投票为何反而有害。
2. Best-of-N 与自洽性的区别是什么？分别需要什么前提才能生效？
3. 写出用 PRM 给一条含 5 步的轨迹打分的连乘公式，并解释为什么用连乘（log 求和）而非平均。
4. 「有世界模型不等于会用」这一发现，对 Agent 与推理系统设计有什么直接启示？
5. 把「一致性比例」当置信度时，阈值该定多少？给出依据。

4. 推理效率：把长思考的代价降下来

4.1 产品化的四层策略

python# 推理预算路由器：按难度与置信度决定「花多少算力」
from dataclasses import dataclass

@dataclass
class Budget:
    model: str
    max_think_tokens: int
    samples: int

ROUTES = {
    "trivial":  Budget("qwen3-8b",            0,    1),   # 不思考
    "normal":   Budget("qwen3-8b",          512,    1),
    "hard":     Budget("claude-sonnet-4-5", 4096,   3),
    "critical": Budget("claude-opus-4-7",  16384,   9),
}

def classify(question: str, signals: dict) -> str:
    """信号可来自：问题长度、是否含数学/代码、检索命中度、历史失败率。"""
    if signals.get("is_high_stakes"):        return "critical"
    if signals.get("has_math") or signals.get("needs_planning"): return "hard"
    if len(question) < 20 and signals.get("cached_similar"):     return "trivial"
    return "normal"

def route(question, signals):
    b = ROUTES[classify(question, signals)]
    return b, {"estimated_cost": b.samples * (b.max_think_tokens + 512)}

4.2 动手练习与自测

1. 给一个 100 万日请求、简单题占 80% 的流量模型，估算「全部开 high 档」与「按难度路由」的成本比。
2. 写出推理成本的近似公式（含输入 token、思考 token、答案 token、采样次数），指出哪个变量最敏感。
3. 思考不落库、缓存命中、蒸馏到小模型，三者各降的是哪部分成本？
4. 路由器把 5% 的简单题误判成难题，代价是多少？把 5% 的难题误判成简单题呢？哪个更严重？
5. 为什么「思考 token 分布」比「平均思考 token」更适合做上线前的容量规划？

5. 评测与污染：怎么知道模型真的会推理

5.1 关键基准与它们的局限

python# 污染检查：训练集与评测集的 n-gram 重合检测（上线前必做）
import re, collections

def ngrams(text, n=13):
    t = re.findall(r"\w+", text.lower())
    return {" ".join(t[i:i + n]) for i in range(max(1, len(t) - n + 1))}

def contamination_rate(train_texts, eval_texts, n=13):
    train_ng = set()
    for t in train_texts:
        train_ng |= ngrams(t, n)
    hits = sum(1 for e in eval_texts if ngrams(e, n) & train_ng)
    return hits / max(1, len(eval_texts))

# 经验阈值：>1% 就要警惕；>5% 说明指标基本不可信，必须换评测集
print("contamination:", contamination_rate(pretrain_docs, eval_set))

5.2 动手练习与自测

1. 用 13-gram 重合率检查评测集污染，说明为什么阈值通常设在 1%（>5% 不可信）。
2. 报告 AIME 分数时为什么必须同时给「样本数 + 置信区间」？举例说明小样本的方差风险。
3. 影子评估（Shadow Eval）为什么能规避污染？它的代价是什么？
4. 「模型怀疑自己在被测试」这类现象会如何影响分数？如何检测？
5. 自建评测集时，样本该如何按难度与场景分层？

6. 推理模型谱系与训练路径

6.1 公开做法对比：不只是「多想一会儿」

2024–2026 年主流推理模型在思考可见性、训练数据、RL 方式、是否开源上差异很大。理解这些差异能帮你判断「该用哪个、能不能自部署、思考过程要不要给用户看」。

6.2 长 CoT 是怎么被 RL「涌现」出来的

关键机制：当奖励只对最终正确性给出稀疏信号，而探索空间足够大时，模型在 RL 中会自动发现「多写几步、自我检查、回溯」能提高奖励，于是长思维链作为获得高奖励的策略被强化，而非被人工写进数据。这解释了为什么 R1-Zero（无任何 CoT 冷启动）也会自发出现反思语。

以 GRPO 为例，其优势函数不依赖独立价值网络，而是用同一 prompt 的组内奖励做基线：

text# GRPO 的优势估计（无 critic）：组内相对优势
# 对同一个 prompt 采样 G 条轨迹 {o_i}，得到奖励 {r_i}
# 优势 A_i = (r_i - mean(r)) / std(r)        # 组均值与标准差
# 策略梯度目标（截断）：
#   L(θ) = -E[ min( ρ_i * A_i, clip(ρ_i, 1-ε, 1+ε) * A_i ) ]
#   ρ_i = exp( log π_θ(o_i) - log π_old(o_i) )     ε 常取 1e-2 ~ 2e-2
# 奖励只来自答案是否正确（RLVR），长度不被直接奖励
# → 模型为了「更可能答对」主动拉长思考、引入自我检查

• 涌现的副作用：长度随训练单调增长；熵可能先升后崩（过早收敛到少数套路）。监控曲线必须同时看 奖励 / 长度 / 熵 / 通过率。
• 稀疏奖励难题：纯结果奖励在长链里信用分配困难。PRM（9 节）或过程奖励是把信号「铺到每一步」的主流解法。
• 为什么是 RL 而不是 SFT：SFT 只能模仿已有 CoT，上限是示范数据；RL 能探索出示范里没有的更长、更绕但更准的路径。

6.3 冷启动 SFT + RL 的两条路线：R1-Zero vs R1

结论：R1-Zero 证明了长 CoT 可以被纯 RL 涌现（回答了「是不是必须人工写 CoT」）；R1 证明加一点冷启动 SFT 能换来可读性、稳定性与更快收敛，且几乎不损上限。2026 年的工业实践几乎都走 R1 路线：冷启动数据量不大（几十万条即可），但格式一致性要求极高。

6.4 动手练习与自测

1. 写出 GRPO 的组内优势与截断目标，并说明 ε 的典型取值与作用。
2. R1-Zero（纯 RL）与 R1（冷启动 + RL）的主要差异是什么？为什么工业界几乎都选 R1 路线？
3. 长 CoT 为什么能被 RL「涌现」出来，而不是被人工写进数据？给出机制解释。
4. 若没有验证器（开放式任务），能否复刻 R1 的 RLVR 流程？为什么？
5. DAPO / GSPO 相对原始 GRPO 各解决了什么问题？

7. 提示侧推理技术：不训练也能变强

7.1 零样本 / few-shot CoT

最便宜的推理增强是提示本身。零样本 CoT 仅加一句「让我们一步步思考」（Let us think step by step）就能在多数推理任务上提升 10–30 个百分点；few-shot CoT 再给出 2–4 个带推理过程的范例，进一步稳定。其本质是把「分步推理」的行为从模型先验里激活出来。

python# 零样本 CoT 的最小封装：用系统提示激活分步推理
SYSTEM_COT = (
    "你是一个严谨的推理助手。回答前先一步步思考，"
    "每步只做一件可验证的事，最后用「答案: 」给出结论。"
)

def zero_shot_cot(llm, q, temperature=0.0):
    # temperature=0 让单条轨迹更确定；要多样性则用 >0 配合自洽性(7.2)
    return llm.chat([
        {"role": "system", "content": SYSTEM_COT},
        {"role": "user",   "content": q},
    ], temperature=temperature)

# few-shot：把 2-4 个「问题→思考→答案」示范放进消息历史
DEMO = [
    {"role": "user",      "content": "若 3x+2=11，求 x。"},
    {"role": "assistant", "content": "思考: 3x=11-2=9，所以 x=3。答案: 3"},
    # 再补 1-3 个同风格示范
]

7.2 自洽性 Self-Consistency：用投票换准确率

思路：同一个问题采样 k 条独立 CoT 轨迹，对最终答案做多数投票。它不要求每条都对，只要「对的方向」占多数即可。数学上相当于用 k 次独立试验降低方差。

python# 自洽性收益的解析：k 次采样多数投票的期望正确率
from math import comb

def majority_correct(p, k):
    """单次正确率 p，k 次独立采样(取奇数)后多数正确的概率"""
    need = k // 2 + 1
    return sum(comb(k, i) * p**i * (1 - p)**(k - i) for i in range(need, k + 1))

for k in [1, 3, 5, 9, 15, 31]:
    print(f"k={k:2d}  p=0.5 -> {majority_correct(0.5, k):.3f}  p=0.4 -> {majority_correct(0.4, k):.3f}")
# 预期输出（示意）：
# k= 1  p=0.5 -> 0.500  p=0.4 -> 0.400
# k= 3  p=0.5 -> 0.500  p=0.4 -> 0.352     <- p<0.5 时投票反而下降
# k= 9  p=0.5 -> 0.500  p=0.4 -> 0.266
# k=31  p=0.5 -> 0.500  p=0.4 -> 0.130
# 结论：p=0.5 是分水岭；p>0.5 投票放大正确，p<0.5 投票放大错误 -> 应先升级模型再投票

7.3 思维树 ToT：把推理展开成可搜索的树

CoT 是单链，自洽性是多条独立单链取多数；思维树 ToT 则把推理显式建成树：每个节点是一个「思考步」，从节点扩展出多个候选下一步（分支），用一个评估函数给每个节点打分，再用搜索（BFS / DFS + 回溯）找通往答案的路径。它把「探索 + 评估 + 回溯」正式工程化。

python# ToT 的极简骨架：扩展 → 评估 → 选择/回溯
def tree_of_thoughts(problem, expand, evaluate, breadth=3, depth=4):
    root = {"state": problem, "children": []}
    frontier = [root]
    for d in range(depth):
        next_frontier = []
        for node in frontier:
            candidates = expand(node["state"], k=breadth)   # 从当前步生成 b 个候选
            scored = [(c, evaluate(c)) for c in candidates] # 评估每个候选(0~1)
            scored.sort(key=lambda x: -x[1])
            node["children"] = [{"state": c, "score": s} for c, s in scored[:breadth]]
            next_frontier += node["children"]
        frontier = next_frontier
    return best_leaf(root)   # 回溯：从叶子里选评分最高路径

# 评估函数可以是：PRM 打分 / LLM-as-Judge / 一个可执行的 checker
# 成本 ≈ (b ^ d) 次 LLM 调用 —— 见 10 节「算力爆炸」

7.4 思维图 GoT：在图上聚合多条推理

ToT 的分支彼此独立；思维图 GoT 允许不同分支在后续节点汇聚（合并），把多个推理路径的中间结论聚合起来。例如先并行探索「代数法」「几何法」两条路，再在某一层把两条路的结论融合。它对「多个子结论要汇总的复杂任务」更友好，但工程复杂度也最高。

• 聚合操作：sum（拼接再让 LLM 综合）、vote（多路结论投票）、keep-best（保留最优分支）。
• 代价：需要定义「哪些节点可以合并」（相似性 / 子目标一致），以及合并后如何重新评估。
• 现实取舍：多数团队在 2026 年用的是「自洽性 + 少量 ToT 回溯」，GoT 主要用于研究或特定规划场景——它的工程 ROI 通常不划算，除非问题天然是图结构。

7.5 动手练习与自测

1. 零样本 CoT 通常能提升多少个百分点？它的原理是「让模型变强」还是「激活已有能力」？
2. 写出 self-consistency 的 majority vote 伪代码，并说明它与 pass@k 的区别。
3. ToT 成本是 b^d；取 b=3、d=4 时完整展开需多少次评估？每层剪枝保留 3 个能降到多少？
4. GoT 相比 ToT 多了什么操作？什么任务才值得上 GoT？
5. 为什么说「模型本来不会的，提示救不了」？

8. 测试时计算缩放（Test-Time Scaling）

8.1 核心思想：把算力从训练搬到推理

预训练规模的边际收益在递减（chinchilla 之后每翻倍参数换来的能力提升越来越小），而在推理时给难题多分配算力往往能更划算地提升准确率。这就是 test-time scaling：固定模型参数，靠「多采样 / 多搜索 / 长思考」把难样本做对。o 系列、DeepSeek 的实证都表明：在难题上，推理算力增加带来的收益可以超过单纯加大模型。

8.2 预算分配：难度自适应

最优分配不是「每个问题都算到极限」，而是简单问题少花、难题多花。可证明（compute-optimal 思路）：给定总推理预算，应把更多采样/搜索资源投向「模型在边界上、加一点算力就能做对」的中等难度问题，而不是已经必对或必错的题。

python# 难度自适应预算：用一次「探针」估计难度，再决定算力
def allocate(p_true_estimate, total_budget):
    # p_true_estimate: 模型一次答对的估计概率(0~1)
    # 难度 d = 1 - |2p - 1| : p=0.5 最难(d=1)，p=0/1 最易(d=0)
    # 把预算按难度平方加权分配，难题拿到更多采样/搜索次数
    d = 1 - abs(2 * p_true_estimate - 1)
    n_samples = max(1, int(round(total_budget * (d ** 1.5))))
    return n_samples

# 探针可以很便宜：用一个小模型或 1 次低温度调用估 p，
# 再用大模型的 k 次采样填满预算。整体仍比「全量 k 次」便宜。

8.3 与模型规模扩张的收益对比

经验结论：当你的模型在目标分布上已达「简单题 95%+ 对、难题只有 50%」时，加推理算力比换更大模型更划算。因为大模型对简单题的提升微乎其微，却要你永久承担训练与部署成本；而测试时算力的成本只在「真正难的请求」上发生。2026 年许多团队的解法是中等模型 + 强测试时缩放，而非一味堆参数。

8.4 动手练习与自测

1. 难度自适应预算里 d=1−|2p−1|，解释 p=0.5 与 p=1 分别对应什么难度、应分多少预算。
2. 给定总预算 B=100 次采样，两个问题估计 p=0.5 与 p=0.9，按 d^1.5 分配各得多少次？
3. 什么条件下「加推理算力」比「换更大模型」更划算？给出量化判据。
4. 测试时缩放与训练缩放的本质区别是什么？这如何解释难度路由的省钱原理？
5. 把「探针」设计得很便宜有哪些做法？

9. 奖励模型与验证器：从 ORM 到 GenRM

9.1 ORM vs PRM：再细化

结果奖励模型（ORM）只判最终答案；过程奖励模型（PRM）对每一步判对错。两者不是替代关系，而是按需求选择：

9.2 生成式奖励模型（GenRM）

传统 RM 是一个回归头输出标量；GenRM 把「判断正确性」本身变成生成任务：让一个 LLM 生成「该答案是否正确」的推理，再从其输出里读出判定。好处是：① 可解释（给出判错理由）；② 能借 LLM 的通用能力处理开放式、主观任务；③ 可用已有 SFT / RL 基础设施训练。

python# GenRM 的最小形态：用 LLM 生成「评判」再抽取结论
GENRM_PROMPT = (
    "下面有一个问题、一个标准答案、一个待评判答案。"
    "请逐步判断待评判答案是否正确，最后一行输出「判定: 正确/错误」。"
)

def genrm_score(llm, question, gold, candidate):
    out = llm.chat([{"role": "user", "content":
        f"问题: {question}\n标准答案: {gold}\n待评判: {candidate}"}])
    if "判定: 正确" in out: return 1.0
    if "判定: 错误" in out: return 0.0
    return 0.5   # 不确定 -> 不强制排序

# 进阶：把多个 GenRM 的判定做集成（类似 self-consistency 的验证版）

9.3 可验证奖励：数学与代码单测

可验证奖励（RLVR）是推理训练最稳的奖励来源，因为它不依赖另一个模型打分、不会被 hack 得那么容易：数学有程序化答案比对，代码有单元测试通过率。

python# 数学：抽取答案做规范化比对（避免 "3" vs "3.0" 误判）
import re, ast, math

def norm_num(s):
    s = s.replace(",", "").replace("$", "").strip()
    try: return float(ast.literal_eval(s))
    except Exception: return s.lower()

def math_reward(pred, gold):
    p, g = norm_num(pred), norm_num(gold)
    if isinstance(p, float) and isinstance(g, float):
        return 1.0 if math.isclose(p, g, rel_tol=1e-3) else 0.0
    return 1.0 if p == g else 0.0

# 代码：直接跑单元测试，通过率即奖励
def code_reward(solution, tests):
    # 把 solution 写进临时文件，执行 pytest 收集的 tests
    # 奖励 = passed / total
    return run_pytest(solution, tests)   # 0.0 ~ 1.0

9.4 用 PRM 做 Best-of-N 重排与逐步搜索

PRM 的两种用法：① Best-of-N 重排——生成 N 条完整轨迹，用 PRM 对轨迹整体打分（或逐步累积分）选最优；② 逐步搜索——在每个推理步用 PRM 当价值函数，beam / MCTS 只保留高分分支，做早期剪枝。

python# 用 PRM 给一条轨迹打分（逐步累积分）
def score_trajectory(prm, steps):
    scores = [prm(s) for s in steps]          # prm(step)->(0~1) 正确概率
    import math
    log_p = sum(math.log(max(s, 1e-3)) for s in scores)
    return math.exp(log_p)                    # 乘积：任一步错都显著拉低

def best_of_n(prm, trajectories):
    return max(trajectories, key=lambda t: score_trajectory(prm, t))

# 逐步搜索（beam）：每步只保留 PRM 分数最高的 b 个前缀
def beam_with_prm(prm, expand, breadth=4, depth=6):
    beams = [[]]
    for _ in range(depth):
        candidates = []
        for prefix in beams:
            for nxt in expand(prefix):
                candidates.append((prefix + [nxt], prm(nxt)))
        candidates.sort(key=lambda x: -x[1])
        beams = [c[0] for c in candidates[:breadth]]
    return beams[0]

9.5 动手练习与自测

1. ORM 与 PRM 在「信用分配」上的差别是什么？举一个 ORM 会失败的具体例子。
2. 写出数学答案规范化的关键步骤，说明为什么 "3" 与 "3.0" 需判等、而 "x=3" 需先抽取。
3. GenRM 的两次用法（粗排 + 精排）如何组合以控制成本？
4. 为什么 RLVR 比「用另一个模型打分」更抗 hack？
5. PRM 被 hack 的表现是什么？给出至少两条缓解措施。

10. 推理搜索算法：beam / 多样束 / MCTS

10.1 Beam Search 与多样性 Beam

标准 beam search 每步保留概率最高的 b 个前缀，能稳定生成高质量单链，但容易塌缩到单一风格。多样性 beam（diverse beam）在分组或加 diversity 惩罚，让不同 beam 走不同路线——这对推理很有用，因为「换条路想」常能绕过局部错误。

python# 多样性 beam：不同组之间加相似度惩罚，逼出不同思路
def diverse_beam(model, prompt, groups=4, beam_per_group=3, lambda_div=0.5):
    # 把 b = groups*beam_per_group 个 beam 分成 groups 组
    # 组间：已选 token 序列越相似，惩罚越大
    beams = [{"seq": prompt, "score": 0.0, "group": i % groups}
             for i in range(groups * beam_per_group)]
    # 简化：实际实现用分组约束，每组独立扩展后再做组间去重/惩罚
    # 关键参数：lambda_div 越大，各组越不相似（多样性↑、单链质量可能↓）
    return beams

# 经验：推理里 beam=4~8 常足够；太大反而因相似前缀收益递减

10.2 MCTS 在推理中的应用

蒙特卡洛树搜索把推理建模成树：节点 = 一个推理步，边 = 从一步到下一步的动作，价值估计 = PRM 给出的该步正确概率（或 Rollout 到底后的 ORM）。四个阶段：选择（按 UCB 走高分低访问节点）→ 扩展（生成候选下一步）→ 模拟（Rollout 到答案）→ 回溯（用结果更新路径上的价值）。

python# MCTS 推理的极简骨架（价值由 PRM 提供）
import math, random

def mcts_reason(root, prm, expand, rollout, iters=200):
    # 节点: {state, visits, value, children}
    for _ in range(iters):
        node = select(root)                  # UCB 选择
        if not node["children"]:
            node["children"] = [{"state": s, "visits": 0, "value": 0.0, "children": []}
                                for s in expand(node["state"])]
        leaf = random.choice(node["children"]) if node["children"] else node
        reward = rollout(leaf["state"])       # 跑到底拿 ORM/PRM 终值
        backup(leaf, reward)                  # 回溯更新 value/visits
    return best_child(root)

def ucb(node):
    # 价值估计 + 访问惩罚（鼓励探索少走的步）
    return node["value"] + 1.0 * math.sqrt(math.log(node["parent_visits"] + 1) / (node["visits"] + 1e-6))

10.3 树搜索的算力爆炸

搜索的算力随分支因子 b 和深度 d 指数增长：完整展开需 b^d 次调用。即使做了剪枝，大 b、大 d 依然会失控。这是测试时缩放的硬约束。

• 控制手段：① 限制 b（每步只扩 2–4 个候选）；② 限制 d（超过 N 步强制收敛）；③ 用 PRM 早停剪枝（低分分支不展开）；④ leaf 并行化（搜索天然可并行）。
• 现实经验：多数生产推理搜索把 b 控制在 2–5、d 控制在 5–10，再配合 PRM 强剪枝，否则单次请求的延迟与成本会超出承受范围。

10.4 动手练习与自测

1. 计算 b=5、d=6 的完整展开调用数，并说明为什么实际要剪枝到每层 2–4 个分支。
2. 写出 MCTS 的四个阶段（选择 / 扩展 / 模拟 / 回溯），并说明 UCB 中「探索项」的作用。
3. beam search 与 MCTS 在「能否回溯纠正早期错误」上的本质区别是什么？
4. 多样性 beam 的 lambda_div 调大 / 调小分别有什么后果？
5. 什么任务不该用树搜索？给出判据。

11. 推理蒸馏：把思考能力压进小模型

11.1 用大模型 CoT 微调小模型

推理蒸馏的核心：用强推理模型（如 DeepSeek-R1 / o 系列）对大量问题生成带思考链的轨迹，再用这些轨迹做 SFT 微调小模型（Qwen / Llama 系列）。小模型从未做过 RL，却通过模仿学会了「先思考再答」。DeepSeek 的报告显示，蒸馏后的 Qwen-1.5B / 7B / 32B 在数学上远超同尺寸直接用 RL 训的版本。

11.2 蒸馏与 RL 的效果对比

工业上常见组合：先蒸馏打底，再轻量 RLVR 微调。这样既拿到教师的推理模式，又有机会在特定领域超越教师。

11.3 拒绝采样（Rejection Sampling）

拒绝采样是连接「生成」与「筛选」的桥梁：用教师（或当前模型）对一批 prompt 采样，只保留答对的轨迹作为训练数据。它把 RL 探索到的正样本固化为 SFT 数据，是 R1 流程里「RL 之后」的关键一步。

python# 拒绝采样：只保留正确的轨迹，用于后续 SFT
def rejection_sample(teacher, prompts, verifier, per_prompt=8):
    kept = []
    for p in prompts:
        for _ in range(per_prompt):
            traj = teacher.generate(p)              # 含思考链
            if verifier(traj.answer, p.gold):       # 只对答案做硬判定
                kept.append({"prompt": p.text, "completion": traj.text})
        # 每个 prompt 最多留 1~2 条，避免分布偏斜
    return kept

# 进阶：不只看对错，还按 PRM/长度过滤（保留「短且对」的轨迹）
# -> 这能顺带缓解学生学到的过度思考(见 12 节)

11.4 动手练习与自测

1. 为什么蒸馏小模型常比小模型自己做 RLVR 更划算？列出至少三条原因。
2. 蒸馏的上限是什么？什么条件下 RLVR 能超越教师？
3. 拒绝采样的保留比例通常多少？太严 / 太松分别有什么问题？
4. 写出「短且对」双重过滤的拒绝采样逻辑，说明它如何顺带缓解过度思考。
5. R1 蒸馏到 Qwen-1.5B/7B/32B 的 AIME 分数大致呈什么规律？

12. 长度控制与过度思考（Overthinking）

12.1 Overthinking 现象与证据

Overthinking：推理模型在本可一步答对的简单题上仍生成超长思考（几百到上千 token），造成无谓的延迟与成本。2025–2026 年的实测显示，部分模型在简单题上平均多花 3–10 倍 token，而准确率并无提升。

12.2 长度惩罚与 Budget Forcing

两类克制手段：长度惩罚在 RL 奖励里对 token 数加负项（length penalty），抑制无意义拉长；Budget Forcing 在推理端强制预算——如「再想不超过 N token 就收尾」，或在思考过长时注入「是时候给出最终答案了」的指令。

python# Budget Forcing：推理端强制收尾，避免无限思考
def budget_forcing(llm, q, max_think=1000, final_trigger="现在请给出最终答案。"):
    text = ""
    think = 0
    while True:
        chunk = llm.generate(q, max_new_tokens=128)
        text += chunk
        think += len(chunk)
        if "答案" in text or think >= max_think:     # 自然收敛或触顶
            break
    if think >= max_think and "答案" not in text:
        text += "\n" + final_trigger                  # 强制收尾
        text += llm.generate(text, max_new_tokens=256)
    return text

# 长度惩罚(训练侧)：reward -= alpha * len(completion)
#   alpha 太大模型会「偷懒过早停」，太小则压不住过度思考；典型 1e-4~1e-3

• Budget forcing 的优点：不改模型权重、可在线调；缺点是对「真需要长想」的题可能截断。
• 长度惩罚的优点：从训练根上治；缺点是 α 难调，且与「更长=更准」的探索目标冲突，需配合难度路由。
• 2026 前沿：按难度路由（12.3）+ 动态 budget 是主流组合，比单纯全局惩罚更稳。

12.3 按难度路由：简单问题不开启思考

最干净的解法：先用廉价探针判断难度，简单问题直接走非推理模型或不思考档位，只有难题才进入长思考。这与 8.2 的难度自适应预算、1.1 的预算路由器一脉相承。

12.4 动手练习与自测

1. Overthinking 的定义是什么？举一个「简单题却生成上千 token」的例子并说明代价。
2. 对比长度惩罚（训练侧）与 Budget Forcing（推理侧）的优缺点。
3. 写出按难度路由的四档（简单 / 中等 / 困难 / 关键）对应的思考 token 与典型准确率。
4. 长度惩罚的 alpha 取太大或太小分别会怎样？
5. 为什么「按难度路由」降本的同时还能降低延迟？

13. 评测进阶：pass@k 与 majority@k

13.1 pass@k：模型「会不会」与「稳不稳」

普通准确率是「采样 1 次对不对」；pass@k 衡量「采样 k 次里至少有 1 次对」的概率，反映模型能力上限（会不会），而非稳定性。其无偏估计为：

text# pass@k 的无偏估计
# n 次采样中 c 次通过，则
#   pass@k = 1 - C(n-c, k) / C(n, k)
# 当 k<=n 时成立；常用 n=20, k=1/5/10
# 直觉：k=1 是普通准确率；k 越大越接近「模型能否做对至少一次」
# 注意：若 n 次里有 c 次对，C(n-c,k)/C(n,k) 是「k 次全错」的概率

pythonimport math
from math import comb

def pass_at_k(n, c, k):
    """n: 总采样数, c: 通过数, k: 取前 k 次"""
    if n - c < k:
        return 1.0
    return 1.0 - comb(n - c, k) / comb(n, k)

# 例：n=20 采样，c=8 通过
print(pass_at_k(20, 8, 1))    # ~0.40  (≈ 单次准确率)
print(pass_at_k(20, 8, 10))   # ~0.93  (采 10 次基本必对一次)

13.2 majority@k：投票视角

与 pass@k 互补，majority@k 看「k 次采样里最多数答案是否对」，衡量自洽性投票后的表现。它更接近部署形态（因为部署常用多数投票）。关系：majority@k 通常 < pass@k（因为投票会丢掉「只有 1 次对但答案独特」的情况），但更反映实际收益。

13.3 数学与代码评测的陷阱

13.4 动手练习与自测

1. 写出 pass@k 的无偏估计，并算 n=20、c=8、k=1 与 k=10 的结果。
2. pass@k 与 majority@k 哪个更接近部署形态？为什么？
3. 答案抽取有哪些坑？至少举两种格式不一致导致误判的例子。
4. 污染检查除了 13-gram 还能怎么做？
5. 为什么不建议用「严格输出格式」的 prompt 去刷基准分？

14. 生产化：何时开思考、如何控成本

14.1 什么时候开思考模式

• 开：数学/代码/逻辑题、多步规划、复杂分析、需要可追溯推理的高风险决策。
• 关：常识问答、摘要、翻译、闲聊、创意写作、以及「简单且高并发」的请求。
• 混合：默认关，路由器检测到难信号（含数学/代码/规划、低首次一致性）才开——见 1.1 / 12.3。
• 用户可控：提供「深度思考」开关，把成本决策交还给用户（尤其高 stakes 场景他们愿意等）。

14.2 延迟与成本权衡

成本公式上，思考 token 单价通常与输出 token 同档，而思考量可能是答案的 10–50 倍。所以控制思考 token 比控制答案长度重要一个数量级。上线前务必统计真实流量的思考 token 分布，而不是用均值拍脑袋。

python# 推理成本估算：把四个变量都算进去，找出最敏感的旋钮
def infer_cost(n_req, c_in, c_out, c_think, p_hard, l_think_hard, l_think_easy, n_sample):
    # n_req: 日请求; c_*: 每 token 单价; p_hard: 难题占比
    easy = n_req * (1 - p_hard)
    hard = n_req * p_hard
    think_easy = easy * l_think_easy * c_think
    think_hard = hard * l_think_hard * n_sample * c_think   # 难题多采样
    ans = n_req * 120 * c_out
    inp = n_req * 300 * c_in
    return {"think": round(think_easy + think_hard, 1),
            "ans": round(ans, 1), "in": round(inp, 1)}

# 例：100 万请求，20% 难题，难题思考 4000 token 且 3 次采样，简单题 0
print(infer_cost(1_000_000, 0.001, 0.002, 0.002, 0.2, 4000, 0, 3))
# 预期输出（示意）：
# {'think': 4800.0, 'ans': 240.0, 'in': 300.0}   <- 思考成本是答案的 20 倍
# 结论：最大杠杆是「把简单题(占 80%)的思考降到 0」+「限制难题采样次数」

14.3 思考内容的展示与缓存

• 展示：思考过程默认折叠，仅对「想看推理」的用户/场景展开；避免用冗长思考淹没界面。
• 落库：一般不把思考存进对话历史发给模型（否则下轮上下文膨胀、成本二次叠加）；如需多轮连贯，只保留「最终答案 + 关键结论」。
• 缓存：相同/近似问题命中语义缓存，直接复用已有思考与答案；批量任务先去重再推理。
• 流式：思考阶段与答案阶段分通道（如 reasoning 字段与 content 字段），前端可分别渲染与中断。

python# 语义缓存：用嵌入相似度命中「同一个问题」，直接复用思考与答案
import hashlib, numpy as np

class ReasonCache:
    def __init__(self, embed, thresh=0.97):
        self.embed = embed; self.thresh = thresh
        self.keys = []          # 归一化后的 query 向量
        self.vals = []          # 缓存的结果（answer + reasoning）
    def get(self, q):
        if not self.keys:
            return None
        v = self.embed(q)
        sims = np.array(self.keys) @ v                 # 余弦相似度
        i = int(sims.argmax())
        return self.vals[i] if sims[i] >= self.thresh else None
    def put(self, q, res):
        self.keys.append(self.embed(q)); self.vals.append(res)

# 经验：可验证任务（同一道题被不同用户反复问）命中率常达 20%-40%，
# 命中即「零思考成本 + 极低延迟」，是推理模型降本的第一杠杆。

14.4 推理结果的可验证性

生产里最可靠的做法是不盲信 CoT，而用外部验证器兜底：数学跑计算器、代码跑单测、结构化输出做 schema 校验。验证通过才返回，否则升级模型/重试/转人工。

python# 生产闭环：推理 + 验证 + 升级
def reason_with_verify(llm, verifier, q, max_retry=2):
    for attempt in range(max_retry + 1):
        ans = llm.reason(q)                      # 带思考
        ok, detail = verifier(ans)               # 外部确定性校验
        if ok:
            return {"answer": ans, "verified": True}
        q = f"{q}\n上次的答案未通过校验: {detail}，请重新推理。"   # self-refine
    return escalate_to_human(q)                  # 仍失败 -> 人工

14.5 动手练习与自测

1. 给出「什么时候开思考模式」的一条经验法则，并区分高 stakes 与高并发场景。
2. 四档推理强度（off/low/medium/high）的相对延迟与成本大致是多少？
3. 思考内容该不该落库进对话历史？为什么？
4. 设计一个「推理 + 外部验证 + 升级 / 转人工」的生产闭环，写出关键分支。
5. 梳理本阶段哪些能力对应 Hamauls Orion M10 的交付物。

项目里程碑

阶段练习项目

常见误区

• 把「输出更长」当成「更聪明」，不监控 token 效率与准确率的联合曲线。
• 所有请求都开最高推理强度，成本爆炸却没换来相应收益。
• 相信单次思维链就是模型的真实推理过程，不做多次采样交叉验证。
• 用公开基准分数下结论，忽略训练数据污染，指标严重虚高。
• 在开放式任务上硬套 Best-of-N，却没有可靠验证器，结果只是随机选一个。
• 忽略了思考 token 会进入上下文，导致多轮对话成本与延迟快速累积。
• 把推理模型的输出直接落库或展示给用户，暴露冗长思考且增加后续成本。

面试高频问题速答

推理模型和普通模型在训练上的本质区别是什么？

普通模型主要在「预测下一个 token」的预训练目标 + SFT + 偏好对齐上训练，学的是输出形式与偏好。推理模型在 SFT 冷启动之后，关键一步是用可验证奖励做 RL（RLVR）：奖励来自程序化判定（答案是否正确、单测是否通过），模型通过探索发现更长的思考与自我纠错能提高奖励，于是「长思维链 + 反思」作为行为被强化出来，而不是靠人工写进训练数据。

测试时计算扩展有哪些手段，怎么选？

六类：Best-of-N（配验证器）、自洽性多次采样投票、思维链提示、长思考预算、树搜索回溯、多模型交叉验证。选择的第一分叉是「有没有可靠验证器」：有则用 Best-of-N，性价比最高；没有则用自洽性并把一致性比例当置信度，或引入 LLM-as-Judge 并接受其偏见。第二分叉是任务难度：难题才值得开大预算，简单题开大预算纯属浪费。

PRM 和 ORM 的取舍是什么？

ORM 只看最终结果，标注便宜、易自动化，但长推理时信用分配困难、信号稀疏。PRM 对每步打分，信号密集、支持逐步搜索与剪枝，但标注昂贵且步骤边界与正确性标准难以统一。2026 年的折中是「自动 PRM」——用强模型或规则自动标注过程，成本可控但会继承教师偏见。实践建议：先用 ORM 起量，只在确有搜索需求时才上 PRM。

RL 训练中输出越来越长是好事还是坏事？

短期看常伴随准确率提升（更多思考机会），但它是成本问题：推理成本与延迟随长度线性甚至更差地增长。要把它当成需要监控与控制的指标：用长度惩罚 / 长度归一化、采样后按 token 效率过滤（GFPO）、或裁剪方式调整（CISPO）来抑制。判断标准是「每正确一次的 token 成本」而不是绝对长度。

公开基准分数还能信吗？你会怎么做评测？

公开基准存在训练污染、题目泄露、以及模型「言语化地意识到自己在被测试」等问题（有研究报告约 20% 的样本出现这种怀疑表达），因此不能作为唯一依据。我的做法是：① 建自己的私有评测集，样本来自真实业务分布；② 做 n-gram / 嵌入级污染检查；③ 用 bootstrap 给置信区间而不是只报均值；④ 对高风险场景用影子评估思路（未公开的任务 + 独立评审）；⑤ 同时报告延迟与成本，而不是只报准确率。

学习资源