Skip to content

思维链与推理时计算扩展 (CoT & Test-Time Compute)

解析推理时扩展法则:CoT、Self-Consistency、PRM 重排、MCTS 与 o1/R1 内化长思维链。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是思维链(CoT)与推理时扩展(Test-Time Compute)?

过去提升模型智力的唯一办法是在训练阶段堆更大模型和更多数据;而 推理时扩展(Test-Time Compute) 开辟了第二条增长曲线——让模型在回答难题前多花时间“打草稿、反思和验算”。

从最简单的提示写步骤(CoT 思维链)、多写几遍少数服从多数(Self-Consistency)、配合过程裁判做树搜索(ToT / MCTS),一直演进到 OpenAI o1 与 DeepSeek-R1 通过强化学习内化出的自主长思维链(Long-CoT)。

01 为什么要发明它:别逼模型用直觉做奥数 ​

早期的 LLM 有一个非常反直觉的毛病:不管你问它“法国首都是哪儿”,还是让它证明一道国际数学奥林匹克(IMO)压轴题,它吐出下一个字时所花的计算量(FLOPs)居然是一模一样的。

从计算理论上看,一个固定层数 L 的标准自回归 Transformer 如果不写中间步骤、只靠一次前向传播直接吐出最终答案,它的“电路深度”被层数死死封顶在了常数级(复杂度类 TC0)。它根本来不及做多步进位乘法、图连通性判断或回溯试错,只能靠海量预训练语料背下来的统计直觉去“蒙”。

类比 · 没收草稿纸的考场

要求大模型不经思考直接吐出复杂数学题的答案,就像把考生的草稿纸全收走,要求他看一眼四位数乘法题就必须在 1 秒内脱口报出结果。

心理学把人类大脑分为“系统 1(直觉快思考)”和“系统 2(逻辑慢思考)”,而直接作答等于强迫模型全程只用“系统 1”硬扛竞赛压轴题。

核心设问

在训练阶段砸算力(预训练 Scaling Laws)之外,我们能不能开辟第二条增长曲线——在考试(推理)阶段按题目难度动态追加算力,给模型递上草稿纸,让它“想得越久,答得越准”?

02 核心直觉:从一张草稿纸到“内化树搜索” ​

顺着“给模型发草稿纸”这个朴素念头,推理时计算扩展(Test-Time Compute Scaling) 走出了三条精彩纷呈的演进路线:

第一代:递一张草稿纸 + 集思广益(CoT & Self-Consistency) ​

Chain-of-Thought(Wei et al., 2022) ↗ 发现只要引导模型“一步步写推导”,它写出来的每个中间字都会流回上下文窗口,成为下一步前向计算的输入——这相当于把上下文变成了一条外接“图灵机纸带”,瞬间突破了固定层数的计算天花板。

更进一步,Self-Consistency(arXiv:2203.11171 ↗)干脆让模型用较高温度平行写 16 份草稿,最后少数服从多数投票。哪怕单条路径偶尔算错小数点,只要大多数路径走对了,随机误差立刻被投票抹平。

第二代:请一位逐行批改的阅卷老师(PRM + Best-of-N / MCTS) ​

碰到真正的奥赛难题,16 份草稿里可能有 13 份都会掉进同一个陷阱,少数服从多数反而会投给高频错误答案。于是 Let's Verify Step by Step ↗ 引入了过程奖励模型(PRM)——不等交卷看总分,而是每写完一行推导就打一个逻辑正确概率分。

配合 Tree-of-Thoughts ↗ 或 MCTS(蒙特卡洛树搜索),搜索器像下围棋的 AlphaGo 一样在思维树上展开分支:哪条推导逻辑连贯就多给预算深挖,哪条半路算歪就立刻剪枝,把算力死死聚焦在最有希望的解空间里。

第三代:把整棵搜索树装进大脑里(o1 / DeepSeek-R1 内化 Long-CoT) ​

外挂树搜索虽然强大,却有两个硬伤:第一,给数学步骤逐行人工标对错贵到离谱,神经 PRM 换个领域就容易失灵;第二,树分支调度延迟高。

以 OpenAI o1 和 DeepSeek-R1(2025) ↗ 为代表的新范式走出了一条极其优雅的路:直接用代码单测、数学符号等价校验这种零噪声的客观结果裁判做大规模强化学习(GRPO / RLVR)。模型居然在纯结果奖励的倒逼下,自发涌现出了“顿悟时刻(Aha Moment)”——在隐藏的 <think> 独白里,自己拆题、自己举反例验算、发现矛盾自己说一句“等等,我这里假设漏了边界条件,退回去重算!”把外部树搜索彻底内化成了一条单流长思维链。

类比 · 象棋大师的脑内复盘
  • 普通 CoT 像新手下棋:想到一步走一步,一步走臭满盘皆输;
  • 外部 MCTS + PRM 像拿了十副棋盘摆在桌上,找教练在每张棋盘边逐招打分,最后挑赢面最大的一盘;
  • 内化 Long-CoT(o1 / R1) 像特级大师闭目沉思:所有试探、反证、悔棋与复盘都在脑海里一条长思维流中一气呵成,落子时只交出最干净、经得起推敲的最终答案。

03 把关键公式读成人话 ​

先看 加权 Best-of-N(Weighted Best-of-N) 如何把过程打分与投票合二为一:

y^W-BoN=arg⁡maxy∑i=1NI(y(i)=y)⋅∏k=1Kpk(i)

把公式读成直觉:- 模型平行做了 N 份草稿,第 i 份草稿算出的最终答案是 y(i),过程奖励模型给它每一步逻辑打出的正确概率是 pk(i)。

  • ∏k=1Kpk(i) 是“木桶连乘”:只要中间哪怕有一步逻辑崩坏(pk≈0.1),整份草稿的权重就会暴跌,杜绝“错错得正”的瞎蒙。
  • 最后把算出相同答案 y 的所有草稿权重加起来,总分最高者胜出——哪怕正确路径只出现过 2 次、错误路径出现过 5 次,只要正确路径步步严谨,照样能反杀夺冠。

再看 MCTS 树搜索 中决定“下一步该深挖哪条分支”的 PUCT 公式:

a∗=arg⁡maxa∈A(s)[Q(s,a)+cpuct⋅P(s,a)⋅∑bN(s,b)1+N(s,a)]

把公式读成直觉:- 前半项 Q(s,a) 是 “吃老本(利用)”:这条思路以前试过多次、回传的平均价值都很高,值得继续顺着深挖。

  • 后半项是 “探新路(探索)”:如果某个候选步骤 a 看起来很顺眼(策略先验概率 P(s,a) 高)但几乎没怎么试过(访问次数 N(s,a) 很小),分母 1+N(s,a) 就很小,探索加分暴涨,迫使搜索器别在一棵树上吊死。
  • 系数 cpuct 就像好奇心旋钮:调大更爱广撒网试新路,调小更爱顺着高分路径一钻到底。

04 它在模型里怎么工作 & 与上下游的关系 ​

推理时扩展不是孤立的提示技巧,它把训练、采样和推理引擎串成了一条全新管线:

  • 上游驱动力:多样化路径采样建立在 解码与温度采样 之上;外部搜索打分依赖 奖励模型(ORM / PRM);而 o1/R1 风格的内化深度思考,直接由基于可验证规则的 GRPO / RLVR 强化学习 练成,区别于传统偏重文风喜好的 RLHF。
  • 底座协同:动辄生成 1 万到 3 万字思考过程的 Long-CoT,极其考验 长上下文建模 的稳定性;同时并行搜索的所有分支共享同一段题干,线上部署必须配合 KV Cache 前缀复用 才不会烧干算力。
  • 下游爆发点:一旦模型学会了自主拆解、试错与反思,它就成了 LLM Agent 智能体 最强的大脑,能在真实代码库修 Bug、写科研报告等开放任务里稳步推进。

05 演化对比与避坑备忘 ​

Snell 等人(Scaling LLM Test-Time Compute, 2024 ↗)给出了一个里程碑式的结论:按题配算力,小模型多想一会儿甚至能打赢 14 倍大的模型——简单题适合串行自我修正,难题适合并行探索加验证。

扩展范式算力花在哪里需要外挂 PRM 吗核心优势主要短板
Standard CoT (arXiv ↗)单条浅层草稿否零成本即插即用无容错,一步算错全盘皆输
Self-Consistency (arXiv ↗)并行多条投票否抹平采样随机方差难题易被高频错解淹没
Weighted BoN / MCTS (arXiv ↗)并行/树搜索 + 审稿是精准捞出稀有正解、早剪死枝PRM 训练贵,树分支工程复杂
内化 Long-CoT (arXiv ↗)单流深度反思回溯否(推理期)统一端到端,无外挂依赖简单题易“想太多”浪费 Token

三个最容易踩的实战坑:

  1. 小心“过度思考(Overthinking)”:问推理模型“1+1 等于几”,它有时会反复自我怀疑消耗上千字思考块甚至陷入“等等,我再确认一遍”的死循环。生产接口务必配置 thinking_budget 硬上限,超限就强制截断进入作答。
  2. 别给原生推理模型喂冗长的 Few-Shot CoT 模板:像 o1、DeepSeek-R1 这类模型已经把搜索策略内化进权重里了,你在 Prompt 里手把手教它“第一步请做 X、第二步请做 Y”,反而会绑住它的手脚导致掉分——直接讲清目标和验收标准效果最好。
  3. 并行采样千万别用超低温度:跑 Self-Consistency 或 Best-of-N 时,如果把温度设成 0.0 或 0.1,采出来的 16 条草稿长得一模一样,花 16 倍钱买回 1 倍效果;通常设在 T∈[0.6,0.8] 才能真正激发路径多样性。

想查看电路复杂度 TC0 理论背景、完整 RLVR 目标函数以及可运行的 Python run_mcts_reasoning 与 weighted_best_of_n 代码?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

传统大语言模型在回答问题时,无论题目难易,对每个输出 token 消耗的浮点计算量(FLOPs)都是完全固定的。思维链(Chain-of-Thought, CoT) 与推理时计算扩展(Test-Time Compute Scaling) 打破了这一限制:允许模型在输出最终答案前动态分配额外的“思考 token”或并行搜索预算,使推理能力随测试时算力的投入呈现类似预训练 Scaling Law 的对数线性提升。

直观理解

心理学将人类思考划分为“系统 1”(快思考、直觉反射)与“系统 2”(慢思考、严谨推演)。直接让大模型吐出数学题答案如同强迫它用“系统 1”心算微积分;而 CoT、过程奖励搜索以及 o1/R1 的长思维链,则是为模型递上一张草稿纸,让它把复杂问题拆解成一系列浅层逻辑步,甚至在出错时划掉重算。

问题动机与演进背景 ​

从计算复杂性视角看,固定层数 L 的标准自回归 Transformer 每次前向传播的电路深度(Circuit Depth)是常数级 O(1)(处于复杂度类 TC0)。这意味着若不生成中间 token,单步前向传播在理论上无法求解任意长度的多步组合推理、图连通性判断或多位整数乘法。

通过将中间推导步骤写回 上下文窗口,Transformer 获得了一个外部可读写的“图灵机纸带”(Scratchpad),有效串联起 T 次前向传播,将计算表达能力提升至图灵完备级别。围绕“如何更高效地利用测试时算力”,技术路线经历了三个关键阶段:

  1. 提示引导与并行投票:从 Few-shot/Zero-shot CoT 出发,通过 Self-Consistency 结合 温度采样 并行抽取多条路径并多数投票。
  2. 验证器引导的显式搜索:引入 结果奖励模型(ORM)与过程奖励模型(PRM),结合 Best-of-N、Tree-of-Thoughts(ToT) 与 MCTS(蒙特卡洛树搜索) 在推理树上剪枝寻优。
  3. 强化学习内化的串行深度思考:以 OpenAI o1 和 DeepSeek-R1 为代表,利用 RLVR / GRPO(可验证奖励强化学习) 将原本由外部树搜索完成的“探索—验证—回溯”策略直接内化进单条超长思维链(Long-CoT)的参数权重中,进而驱动高阶 LLM Agent 的复杂规划。

核心原理与数学推导 ​

1. 思维链(CoT)与自洽性(Self-Consistency) ​

给定问题 x,模型不直接建模 P(y∣x),而是引入隐变量推理路径 z=(z1,…,zT),对最终答案 y 进行边缘化:

P(y∣x)=∑zP(y∣z,x)P(z∣x)

由于直接求和不可计算,Self-Consistency(Wang et al., 2022) 通过带温度采样独立抽取 N 条推理轨迹 {(z(i),y(i))}i=1N,以蒙特卡洛频率估计后验众数(即多数投票):

y^SC=arg⁡maxy∑i=1NI(y(i)=y)

2. Best-of-N 与过程奖励模型(PRM)重排 ​

当难题的正确路径采样概率较低时,多数投票容易被高频错误答案淹没。此时可引入外部验证器 Rϕ 对每条候选轨迹打分:

  • ORM(Outcome Reward Model):仅对完整轨迹输出单一标量得分 RORM(x,z(i),y(i))。
  • PRM(Process Reward Model):将轨迹切分为 K 个推理步骤 z(i)=(s1,…,sK),对每一步判断逻辑正确概率 pk=P(step k is correct∣x,s1:k)。轨迹聚合得分常用乘积或最小值(木桶效应,一步算错则全盘皆错):
RPRM(x,z(i))=∏k=1Kpk或min1≤k≤Kpk

结合加权投票(Weighted Best-of-N),将属于同一最终答案 y 的所有轨迹得分累加,往往显著优于单纯取单条最高分(Max Best-of-N):

y^W-BoN=arg⁡maxy∑i=1NI(y(i)=y)⋅RPRM(x,z(i))

3. Tree-of-Thoughts(ToT)与 MCTS(PUCT 算法) ​

为了在推理中途尽早剪掉死胡同并将算力集中于有前景的分支,ToT 将问题求解建模为状态空间树搜索(支持 BFS / DFS / Beam Search),每个节点代表部分推理状态 s。

在更通用的 MCTS(Monte Carlo Tree Search) 框架中,每次模拟包含四个阶段:选择(Selection)→ 扩展(Expansion)→ 评估/模拟(Evaluation)→ 回传(Backpropagation)。在选择阶段,节点 s 依据 PUCT(Predictor + Upper Confidence Bound applied to Trees) 公式平衡利用(高历史价值) 与探索(低访问次数或高先验概率):

a∗=arg⁡maxa∈A(s)[Q(s,a)+cpuct⋅P(s,a)⋅∑bN(s,b)1+N(s,a)]

其中:

  • Q(s,a)=W(s,a)N(s,a) 是边 (s,a) 的平均累计价值(可由 PRM 分数或终端正确率回传更新);
  • P(s,a) 是策略模型给出的候选步骤先验概率(如归一化对数似然);
  • N(s,a) 是该动作的访问计数;
  • cpuct>0 控制探索强度。

4. 内化 Long-CoT 范式(o1 / DeepSeek-R1) ​

外部 MCTS 虽然强大,但依赖高质量 PRM(标注成本极高且易被 Reward Hacking),且树搜索分支间存在大量冗余计算。内化 Long-CoT 范式通过在数学、代码等拥有客观确定性验证器(Unit Tests / SymPy 等价校验)的任务上进行大规模强化学习(如 GRPO),直接优化整条包含隐藏思考块 `<think>` ... `</think>` 的生成策略:

maxπθEx∼D,(z,y)∼πθ(⋅∣x)[rverify(x,y)+rformat(z,y)]−βDKL(πθ∥πref)

在纯结果奖励的驱动下,模型自发涌现出“顿悟时刻(Aha Moment)”:学会在单条自回归流中执行子目标分解、极端值验算、假设反证以及发现矛盾后主动回溯重写(即在文本流内部隐式模拟了线性化的树搜索)。

算法架构与数据流图 ​

下图对比了外部并行/树搜索(External Search) 与内化长思维链(Internalized Long-CoT) 两种推理时算力扩展路径:

图表加载中...

复杂度与横向对比表 ​

设单次完整回答平均消耗 T 个 token,采样/扩展分支数为 N,树深度为 D:

方法扩展维度计算开销是否需外部 PRM典型增益来源主要局限性
Zero-Shot / Few-Shot CoT浅层串行O(T)否降低单步推理跳跃跨度单路径无容错,首步错则全错
Self-Consistency纯并行宽度O(NT)否消除随机采样方差无法解决模型系统性盲区;难以用于开放式文本
Weighted Best-of-N (PRM)并行 + 验证O(NT+NCPRM)是精准识别稀有的正确轨迹PRM 训练昂贵,分布外泛化受限
ToT / MCTS树状深度与宽度O(NsimD⋅ΔT)通常需要早期剪枝坏分支,算力聚焦工程延迟高,KV Cache 分支复用复杂
内化 Long-CoT (o1 / R1)深度串行反思O(Tlong)否(推理期)统一内化搜索、验算与回溯简单题易“过度思考(Overthinking)”浪费 token

核心 PyTorch / Python 参考实现 ​

以下实现一个轻量级、可运行的 PUCT-MCTS 推理树搜索器 与 PRM 加权 Best-of-N 聚合器,演示测试时搜索的核心数学逻辑:

python
import math
from collections import defaultdict
from dataclasses import dataclass, field
from typing import Callable


@dataclass
class MCTSNode:
    """推理树中的一个中间思维状态节点。"""
    state: str
    parent: "MCTSNode | None" = None
    prior: float = 1.0
    visit_count: int = 0
    value_sum: float = 0.0
    children: list["MCTSNode"] = field(default_factory=list)
    is_terminal: bool = False

    @property
    def q_value(self) -> float:
        return self.value_sum / self.visit_count if self.visit_count > 0 else 0.0


def select_child_puct(node: MCTSNode, c_puct: float = 1.4) -> MCTSNode:
    """依据 PUCT 公式选择下一步最具潜力的子节点。"""
    total_visits = sum(child.visit_count for child in node.children)
    sqrt_total = math.sqrt(max(1, total_visits))

    best_score = -float("inf")
    best_child = node.children[0]
    for child in node.children:
        u_score = c_puct * child.prior * sqrt_total / (1.0 + child.visit_count)
        score = child.q_value + u_score
        if score > best_score:
            best_score = score
            best_child = child
    return best_child


def run_mcts_reasoning(
    question: str,
    propose_steps: Callable[[str], list[tuple[str, float, bool]]],
    prm_score_fn: Callable[[str], float],
    num_simulations: int = 16,
    c_puct: float = 1.4,
) -> MCTSNode:
    """
    MCTS 推理主循环。
    Args:
        question:        原始问题文本
        propose_steps:   策略模型,返回 [(下一步文本, 先验概率, 是否终止), ...]
        prm_score_fn:    过程奖励模型,评估当前状态正确概率 [0, 1]
        num_simulations: 搜索模拟预算次数
    """
    root = MCTSNode(state=question)

    for _ in range(num_simulations):
        # 1. Selection: 沿 PUCT 下降至叶节点
        node = root
        while node.children and not node.is_terminal:
            node = select_child_puct(node, c_puct=c_puct)

        # 2. Expansion: 若非终止状态,调用策略模型生成候选步骤
        if not node.is_terminal:
            candidates = propose_steps(node.state)
            for next_step, prior, is_done in candidates:
                child_state = f"{node.state}\n{next_step}"
                node.children.append(
                    MCTSNode(
                        state=child_state,
                        parent=node,
                        prior=prior,
                        is_terminal=is_done,
                    )
                )
            if node.children:
                node = node.children[0]

        # 3. Evaluation: 调用 PRM 评估节点价值
        value = prm_score_fn(node.state)

        # 4. Backpropagation: 沿父链回传累计价值与访问次数
        curr: MCTSNode | None = node
        while curr is not None:
            curr.visit_count += 1
            curr.value_sum += value
            curr = curr.parent

    # 返回访问频次或平均价值最高的终止轨迹
    best = root
    while best.children:
        best = max(best.children, key=lambda c: (c.q_value, c.visit_count))
    return best


def weighted_best_of_n(
    trajectories: list[tuple[str, list[float]]],
    agg: str = "prod",
) -> tuple[str, float]:
    """
    结合 PRM 步骤分数的加权多数投票(Weighted Best-of-N)。
    Args:
        trajectories: [(提取出的最终答案, [每步 PRM 概率列表]), ...]
        agg:          'prod'(乘积)或 'min'(木桶最小值)
    """
    answer_scores: dict[str, float] = defaultdict(float)
    for answer, step_probs in trajectories:
        if agg == "min":
            traj_score = min(step_probs) if step_probs else 0.0
        else:
            traj_score = math.prod(step_probs) if step_probs else 0.0
        answer_scores[answer] += traj_score

    best_answer = max(answer_scores.items(), key=lambda kv: kv[1])
    return best_answer


if __name__ == "__main__":
    # 演示 Weighted Best-of-N:虽然错误答案 "12" 出现次数多,但正确路径 "42" 步骤分更高
    samples = [
        ("12", [0.95, 0.20, 0.30]),
        ("12", [0.90, 0.25, 0.40]),
        ("42", [0.96, 0.94, 0.98]),
    ]
    ans, score = weighted_best_of_n(samples, agg="prod")
    print(f"Weighted Best-of-N Winner: {ans} (score={score:.4f})")

工程实践与常见陷阱 ​

工程实践

  • 按题目难度自适应分配算力(Compute-Optimal Scaling):Snell 等人(2024)证明,简单题用串行修正(Sequential Revision)性价比更高,难题则应把算力分配给并行探索 + 验证(Parallel Search + PRM)。现代推理 API 通常暴露 reasoning_effort(low / medium / high)或 thinking_budget(最大思考 token 预算)供按需调度。
  • 推理树与 Prefix Caching 深度绑定:在实现 Best-of-N 或 MCTS 时,所有分支共享相同的 Prompt 和前序步骤。在 vLLM / SGLang 等推理引擎中启用 RadixAttention / Automatic Prefix Caching,可将共享前缀的 KV Cache 零拷贝复用,成倍降低显存与 TTFT 延迟。
  • 结合外部可执行验证器替代神经 PRM:在代码生成、SQL 查询和形式化证明(Lean 4)领域,直接用编译器、单元测试套件或符号求解器作为零噪声验证器,远比训练神经 PRM 更可靠且彻底免疫 Reward Hacking。

常见陷阱

  • 过度思考(Overthinking)与思考死循环:内化 Long-CoT 模型在面对“1+1 等于几”等极简问题时,可能反复自我怀疑消耗上千个思考 token;在难题上也可能陷入“Wait, let me double check...”的无限循环。工程上必须对思考块设置最大 token 上限并在超限时注入截断提示强制进入最终作答。
  • 推理模型不需要显式 Few-Shot CoT 提示:对于 o1 / DeepSeek-R1 等原生推理模型,额外在 Prompt 中拼接冗长的人工 CoT 示例或强制“请一步步思考”往往会干扰其内化的探索策略,反而导致评测指标下降,直接给出清晰的目标与约束即可。
  • 低温度抹杀并行探索多样性:执行 Self-Consistency 或 Best-of-N 时,若温度 T 过低(如 T≤0.2),N 条采样路径高度雷同,额外算力完全浪费;通常推荐 T∈[0.6,0.8] 配合 p=0.95。

延伸阅读与参考论文 ​

  • Wei, J., Wang, X., Schuurmans, D., et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS 2022. arXiv:2201.11903 ↗
  • Wang, X., Wei, J., Schuurmans, D., et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. ICLR 2023. arXiv:2203.11171 ↗
  • Lightman, H., Kosaraju, V., Burda, Y., et al. (2023). Let's Verify Step by Step. ICLR 2024. arXiv:2305.20050 ↗
  • Yao, S., Yu, D., Zhao, J., et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. NeurIPS 2023. arXiv:2305.10601 ↗
  • Snell, C., Lee, J., Xu, K., & Kumar, A. (2024). Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters. ICLR 2025. arXiv:2408.03314 ↗
  • DeepSeek-AI (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948 ↗