Test-Time Compute Scaling:推理时计算扩展的系统性解析

传统 LLM 的局限

传统大语言模型(如 GPT-4、Claude 3)在推理时采用"一次性生成"策略:给定输入,模型直接生成输出。这种方式类似于人类的"系统 1 思维"--快速、直觉、但容易出错。

对于简单任务(如文本分类、翻译),这种方式足够好。但对于复杂推理任务(如数学证明、代码调试、逻辑推理),人类会"慢下来思考"--列出步骤、尝试不同方法、验证中间结果。

Test-Time Compute Scaling 的核心洞察

2024 年 9 月,OpenAI 发布 o1 模型时提出了一个关键观察:性能随训练时计算(train-time compute)和推理时计算(test-time compute)的增加而平滑提升。

这意味着:

• 训练时:通过大规模强化学习(RL)教会模型"如何思考"
• 推理时:模型生成更长的 Chain-of-Thought,探索多条推理路径,自我验证

这种范式转变被称为 Test-Time Compute Scaling(推理时计算扩展),或 Inference-Time Scaling(推理时扩展)。

为什么这是突破?

1. 预训练 Scaling Laws 遇到瓶颈:数据质量下降、 diminishing returns
2. 推理时扩展的新维度:不增加模型参数,只增加推理时的计算量
3. 复杂推理任务的突破:在数学、代码、逻辑推理等任务上取得显著进展

OpenAI 的实验表明,o1 在 AIME 2024 数学竞赛上的准确率从 GPT-4o 的 ~12% 提升到 ~74%(pass@1),这正是 Test-Time Compute Scaling 的成果。

根据 ICLR 2025 论文 "Scaling LLM Test-Time Compute Optimally"(Snell et al.),Test-Time Compute 扩展主要分为两类:

机制一:并行扩展(Parallel Scaling)

生成多个候选答案,然后选择最好的。

核心方法:

• Best-of-N Sampling:生成 N 个独立答案,用奖励模型选择最佳
• Self-Consistency:生成多条推理路径,多数投票决定最终答案
• Majority Voting:多个模型或多次采样的结果投票

优势:

• 实现简单,无需修改模型
• 性能随 N 增加而提升(但边际收益递减)

局限:

• 推理成本线性增长(N 倍)
• 无法利用推理过程中的中间反馈

机制二:序列扩展(Sequential Scaling)

在生成过程中逐步改进,利用中间反馈。

核心方法:

• Chain-of-Thought(CoT):生成详细的推理步骤
• Self-Refinement:生成初稿 → 自我批评 → 改进 → 重复
• Beam Search:在推理树的每个节点选择最优路径
• Monte Carlo Tree Search(MCTS):用树搜索探索推理空间

优势:

• 可以利用中间步骤的反馈
• 更高效的计算使用(相比并行扩展)

局限:

• 需要模型具备自我评估能力
• 实现复杂度更高

Compute-Optimal 策略

Snell et al. 的关键发现:最优策略是根据问题难度动态分配计算资源。

• 简单问题:少思考,快速回答
• 中等问题:适度思考,平衡成本与准确率
• 困难问题:深度思考,探索多条路径

这种自适应策略比固定预算策略效率高 4 倍以上。

Test-Time Compute Scaling 不是简单的"推理时多生成 token"。要让模型有效利用长 Chain-of-Thought,需要在训练时教会模型"如何思考"。

OpenAI o1 的训练方法

OpenAI 在 2024 年 9 月的博客中透露了关键信息:

"Our large-scale reinforcement learning algorithm teaches the model how to think productively using its chain of thought."

核心流程:

1. 预训练:在大规模文本语料上训练基础模型
2. 强化学习:用可验证奖励(Verifiable Rewards)训练模型生成长 Chain-of-Thought
3. 推理时扩展:模型生成详细推理步骤,探索多条路径

关键技术:

• Process Reward Model(PRM):对每个推理步骤给予奖励信号
• Reinforcement Learning with Verifiable Rewards(RLVR):用数学/代码的正确性作为奖励

DeepSeek R1 的开源实现

2025 年 1 月,DeepSeek 发布 R1,首次开源了推理模型的完整训练流程。

核心创新:Group Relative Policy Optimization(GRPO)

GRPO 是 PPO 的改进版本,关键区别:

• 无需价值网络(Critic):PPO 需要 4 个模型(策略、参考、奖励、价值),GRPO 只需 2 个(策略、参考)
• 组内相对优势:对同一问题生成 G 个答案,用组内相对排名计算优势

GRPO 的训练流程

GRPO 的训练过程如下：

1. 对每个问题，策略模型生成 G 个候选答案（通常 G=8 或 16）
2. 用可验证奖励（如数学题的正确性、代码的测试通过率）评估每个答案
3. 计算组内归一化的优势值：Aᵢ = (rᵢ - mean(r)) / std(r)
4. 用 PPO-clip 目标更新策略模型，同时施加 KL 散度惩罚防止偏离参考模型太远

这种设计的优势在于：

• 无需价值网络：减少了模型复杂度和训练成本
• 组内归一化：消除了不同问题难度带来的奖励尺度差异
• 可验证奖励：无需人工标注，自动获得奖励信号

GRPO 的数学形式:

GRPO 目标函数：

J_GRPO(θ) = E[ 1/G Σᵢ min(rᵢ(θ)Aᵢ, clip(rᵢ(θ),1-ε,1+ε)Aᵢ) - β·D_KL(π_θ || π_ref) ]

其中：rᵢ(θ) = π_θ(oᵢ|q) / π_θ_old(oᵢ|q) 是重要性采样比率；Aᵢ = (rᵢ - mean(r)) / std(r) 是组内归一化的优势；rᵢ 是第 i 个答案的奖励（正确=1，错误=0）。

RLVR vs RLHF

DeepSeek R1 的训练细节

1. 基础模型:DeepSeek-V3(671B 参数 MoE)
2. 强化学习:GRPO 算法,用数学/代码正确性作为奖励
3. 训练成本:约 100,000 H800 GPU hours(预训练的 3.75%)
4. 关键发现:纯 RL 训练(无需 SFT 预热)也能产生推理能力

R1 的突破:

• AIME 2024:71% → 86.7%(多数投票)
• MATH-500:97.3%
• 成本比 o1 低 70%

# GRPO 简化实现伪代码

def grpo_training(policy_model, ref_model, questions, G=8):
    """
    Group Relative Policy Optimization

    Args:
        policy_model: 策略模型 π_θ
        ref_model: 参考模型 π_ref
        questions: 训练问题集
        G: 每个问题生成的答案数量
    """
    optimizer = Adam(policy_model.parameters())

    for question in questions:
        # 1. 生成 G 个候选答案
        answers = []
        for _ in range(G):
            answer = policy_model.generate(question, max_tokens=4096)
            answers.append(answer)

        # 2. 计算每个答案的奖励(可验证奖励)
        rewards = []
        for answer in answers:
            # 数学题:检查答案是否正确
            # 代码题:运行测试用例
            reward = verify_answer(question, answer)  # 1 or 0
            rewards.append(reward)

        # 3. 计算组内归一化优势
        mean_reward = mean(rewards)
        std_reward = std(rewards)
        advantages = [(r - mean_reward) / (std_reward + 1e-8)
                     for r in rewards]

        # 4. 计算 GRPO 损失
        loss = 0
        for i, (answer, advantage) in enumerate(zip(answers, advantages)):
            # 重要性采样比率
            ratio = policy_model.log_prob(answer) - ref_model.log_prob(answer)
            ratio = exp(ratio)

            # PPO-clip 目标
            clipped_ratio = clip(ratio, 1-ε, 1+ε)
            objective = min(ratio * advantage, clipped_ratio * advantage)

            # KL 散度惩罚
            kl_penalty = kl_divergence(policy_model, ref_model, answer)

            loss += -(objective - β * kl_penalty)

        loss /= G

        # 5. 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    return policy_model

奖励模型是 RLVR 的核心组件。根据奖励信号的粒度,分为两类:

Outcome Reward Model(ORM)

只在最终答案上给予奖励。

特点:

• 稀疏奖励:只有最终结果(正确/错误)
• 训练简单:只需要最终答案标签
• 适用场景:答案容易验证的任务(数学、代码)

ORM 示例： 问题「计算 2 + 3 * 4」→ 模型生成步骤 1: 2+3=5 → 步骤 2: 5×4=20 → 最终答案 20 ✓ → ORM 奖励 +1（最终答案正确）

Process Reward Model(PRM)

对每个推理步骤给予奖励。

特点:

• 密集奖励:每个中间步骤都有反馈
• 训练复杂:需要逐步标注
• 适用场景:多步推理任务(数学证明、代码调试)

PRM 示例： 问题「证明 √2 是无理数」→ 7 个推理步骤，每步由 PRM 独立评分 +1，总共 +8（含结论步）。密集奖励信号可精确引导模型找到信用分配。

PRM 的实际应用价值

PRM 的核心优势在于信用分配（Credit Assignment）。在长 Chain-of-Thought 中，如果只有最终答案正确才给奖励（ORM），模型很难学到哪些中间步骤是关键的正确推理。PRM 通过逐步反馈，让模型明确知道「第 3 步的假设是正确的」「第 5 步的推导出现了错误」。

这种细粒度反馈对于复杂推理任务至关重要。例如在代码调试场景中，PRM 可以识别出「变量初始化正确 → 循环条件正确 → 边界条件处理错误」，从而引导模型专注于修复特定步骤，而非盲目重试整个推理过程。

Implicit PRM 的突破

2025 年 ICML 发表的 FreePRM 研究表明，无需显式逐步标注也能获得 PRM 的效果。核心洞察是：训练良好的 ORM 在内部已经学会了逐步评估能力。通过提取模型在每一步的 log-likelihood ratio，可以隐式获得逐步奖励信号。

这一发现大幅降低了 PRM 的训练成本——不再需要昂贵的逐步标注数据，只需训练一个 ORM 即可在推理时提取 PRM 级别的引导信号。

PRM vs ORM 的权衡

最新进展:Implicit PRM

2025 年的研究发现,无需显式逐步标注也能获得 PRM 的效果。

核心思想:

• 训练 ORM 时,模型隐式学会了逐步评估
• 通过 log-likelihood ratio 提取逐步奖励
• 无需额外的逐步标注数据

这大幅降低了 PRM 的训练成本。

Test-Time Compute 不是越多越好。关键问题是:如何最优分配推理计算资源?

问题难度的异质性

不同问题需要不同的计算量:

• 简单问题(2 + 3 = ?):几乎不需要思考
• 中等问题(解方程):需要几步推理
• 困难问题(数学竞赛):需要深度思考、多条路径探索

固定预算的问题

如果对所有问题使用相同的推理预算:

• 简单问题:过度思考(overthinking),浪费计算
• 困难问题:思考不足(underthinking),准确率不够

Compute-Optimal 策略

Snell et al. (ICLR 2025) 提出了最优分配策略:

核心思想:根据问题难度动态分配计算资源

实现方式:

1. 难度估计:用模型的不确定性或小模型的预测准确率估计难度
2. 预算分配:
   • 简单问题:少分配(如 512 tokens)
   • 中等问题:适度分配(如 2048 tokens)
   • 困难问题:多分配(如 8192 tokens)
3. 自适应生成:模型在预算内生成推理过程

实验结果:

• 比固定预算策略效率高 4 倍以上
• 在相同计算预算下,准确率提升 10-15%

经济视角：推理计算的市场化

2026 年的研究将推理计算分配建模为资源优化问题：

目标函数是最大化总效用（所有问题的准确率提升之和），约束条件是总 token 预算有限。通过拉格朗日乘子法求解，得到最优分配条件：每个问题的边际效用相等（∂Uᵢ/∂tᵢ = λ）。

直观理解：当问题 A 的边际效用高于问题 B 时，应该把 B 的预算转移给 A，直到两者边际效用相等。这类似于金融市场中的套利机制——资金从低收益资产流向高收益资产，直到风险调整后收益相等。

实际实现机制

1. 难度估计器：用小模型或不确定性估计预测问题难度
2. 预算分配器：根据难度查表或计算最优 token 预算
3. 动态调整：推理过程中根据中间反馈调整剩余预算

这种机制类似于经济学中的「影子价格」——每个资源约束对应一个对偶变量，反映资源的边际价值。当某个任务的边际回报高于影子价格时，增加其资源分配；反之则减少。

实验效果

在 MATH 数据集上，Compute-Optimal 策略相比固定预算策略：

• 相同准确率下节省 60% 推理成本
• 相同成本下准确率提升 15%
• 对于困难问题（需要 >4096 tokens），自适应策略能智能分配更多资源

实际系统中的实现

OpenAI o1/o3:

• 提供 "reasoning effort" 参数(low/medium/high)
• 用户可根据任务选择推理深度

DeepSeek R1:

• 模型自动估计难度
• 动态调整 Chain-of-Thought 长度

Claude 3.7 Sonnet:

• "Thinking" 模式:模型先思考再回答
• 用户可设置 thinking budget

Token 级别的预算控制

最新研究(2025-2026)探索更细粒度的控制:

SelfBudgeter(ACL 2025):

• 模型先预测需要的 token 数量
• 然后在预算内生成推理过程
• 减少不必要的过度思考

Budget Forcing:

• 硬性截断:达到预算后立即停止
• 简单但有效,被多个系统采用

经济视角:推理计算的市场化

2026 年的研究将推理计算分配建模为资源优化问题:

Compute-Optimal 分配原理： 每个问题的效用函数 Uᵢ(tᵢ) = 准确率提升，最优分配条件为边际效用相等（∂Uᵢ/∂tᵢ = λ），实现方式为「影子价格」机制平衡各任务资源。

这类似于经济学中的资源配置问题,为推理计算的高效使用提供了理论基础。

Test-Time Compute Scaling 在多个领域取得了突破性进展。

数学推理

关键观察:

• o1 相比 GPT-4o 提升 6 倍(AIME)
• R1 用 70% 更低的成本达到 o1 水平
• 推理模型在数学任务上接近人类专家

代码生成

推理模型的优势:

• 能理解复杂需求
• 能自我调试和修复
• 能处理多文件修改

科学推理

GPQA Diamond(博士级科学问题):

• GPT-4o:~50%
• o1:~65%
• o3:~75%

P1 模型(2025 年 11 月):

• 首个开源模型获得国际物理奥林匹克金牌
• 21.2/30 分,排名第三(仅次于 Gemini 2.5 Pro 和 GPT-5.2)
• 用 RL + Test-Time Agents 实现

推理的局限性

尽管进展显著,Test-Time Compute Scaling 仍有局限:

1. 成本问题:

   • 推理模型生成 10x 更多 token
   • 推理成本显著增加
   • R1 消耗 token 是 Claude 3.7 的 10 倍,但准确率仅略低

2. 过度思考(Overthinking):

   • 简单问题也生成长 Chain-of-Thought
   • 浪费计算资源
   • 2025 年研究发现,推理模型在简单数学题上消耗 18x tokens,但无准确率提升

3. 准确性下降:

   • Chain 越长,出错概率越高
   • 控制难度后,准确率随 Chain 长度下降
   • 存在"拐点"(knee point),超过后收益递减

4. 最难问题无效:

   • 对极难问题(如 FrontierMath),增加推理时间帮助有限
   • o3 在 FrontierMath 上仅 25%
   • 可能需要其他方法(如外部工具、知识库)

将 Test-Time Compute Scaling 应用到生产系统需要考虑多个方面。

系统架构

一个典型的推理系统包含以下组件:

推理系统 pipeline 流程详见下方 Mermaid 图。

# 推理系统简化实现

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

class ReasoningSystem:
    """
    推理系统:难度估计 + 预算分配 + 推理生成
    """

    def __init__(self, model_name: str, max_tokens: int = 8192):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForCausalLM.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto"
        )
        self.max_tokens = max_tokens

    def estimate_difficulty(self, question: str) -> str:
        """
        估计问题难度:simple/medium/hard

        简化实现:基于问题长度和关键词
        实际系统应用小模型或不确定性估计
        """
        length = len(question.split())

        # 简单启发式规则
        if length < 20 and any(kw in question for kw in ["是什么", "计算", "简单"]):
            return "simple"
        elif length > 100 or any(kw in question for kw in ["证明", "推导", "复杂"]):
            return "hard"
        else:
            return "medium"

    def allocate_budget(self, difficulty: str) -> int:
        """根据难度分配 token 预算"""
        budgets = {
            "simple": 512,
            "medium": 2048,
            "hard": 8192
        }
        return budgets[difficulty]

    def generate_reasoning(
        self,
        question: str,
        budget: int,
        num_samples: int = 1
    ) -> list[str]:
        """
        生成推理过程

        Args:
            question: 输入问题
            budget: token 预算
            num_samples: 生成样本数(用于并行扩展)
        """
        # 构建提示
        prompt = f"""请仔细思考并解答以下问题。
请展示完整的推理过程。

问题:{question}

推理过程:"""

        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)

        responses = []
        for _ in range(num_samples):
            # 生成推理过程
            outputs = self.model.generate(
                **inputs,
                max_new_tokens=budget,
                temperature=0.7,  # 适度随机性
                do_sample=True,
                pad_token_id=self.tokenizer.eos_token_id
            )

            response = self.tokenizer.decode(
                outputs[0][inputs.input_ids.shape[1]:],
                skip_special_tokens=True
            )
            responses.append(response)

        return responses

    def solve(self, question: str, use_parallel: bool = False) -> str:
        """
        解答问题

        Args:
            question: 输入问题
            use_parallel: 是否使用并行扩展
        """
        # 1. 估计难度
        difficulty = self.estimate_difficulty(question)
        print(f"估计难度: {difficulty}")

        # 2. 分配预算
        budget = self.allocate_budget(difficulty)
        print(f"分配预算: {budget} tokens")

        # 3. 生成推理
        if use_parallel and difficulty != "simple":
            # 并行扩展:生成多个答案
            num_samples = 5
            responses = self.generate_reasoning(question, budget, num_samples)

            # 简单多数投票(实际系统应用奖励模型)
            # 这里返回最长的答案作为示例
            best_response = max(responses, key=len)
        else:
            # 序列扩展:单个答案
            responses = self.generate_reasoning(question, budget)
            best_response = responses[0]

        return best_response


# 使用示例
if __name__ == "__main__":
    # 初始化系统
    system = ReasoningSystem("Qwen/Qwen2.5-7B-Instruct")

    # 解答问题
    question = "证明 √2 是无理数"
    answer = system.solve(question, use_parallel=True)
    print("\n答案:")
    print(answer)

Test-Time Compute Scaling 仍在快速发展,多个前沿方向值得关注。

方向 1:高效推理(Efficient Reasoning)

问题:推理模型消耗过多 token,成本高。

研究方向:

• Token 压缩:减少推理 token 数,保持准确率
• Chain-of-Draft:每步只写关键信息,不写完整推理
• Early Exit:检测到足够信心时提前停止

代表工作:

• LightThinker(2025):推理压缩 + 内存管理
• Chain-of-Draft(2025):每步预算控制
• TERMINATOR(2026):学习最优退出点

方向 2:多模态推理(Multimodal Reasoning)

将推理能力扩展到图像、视频、音频。

挑战:

• 视觉推理需要空间理解
• 多模态 Chain-of-Thought 如何表示?
• 验证更困难(图像答案如何验证?)

代表工作:

• Vision-R1(2025):视觉推理模型
• LLaVA-CoT(2025):多模态 Chain-of-Thought
• Skywork R1V(2025):自适应长度 CoT 蒸馏

方向 3:Agent 推理(Agentic Reasoning)

推理模型作为 Agent,与外部环境交互。

特点:

• 推理过程中调用工具(计算器、代码解释器)
• 根据环境反馈调整推理路径
• 多步规划 + 执行

代表工作:

• Agent Q(2025):MCTS + 自我验证
• Web-Shepherd(2025):Web Agent 的过程奖励
• P1(2025):物理奥赛金牌,用 Test-Time Agents

方向 4:推理安全(Reasoning Safety)

推理模型带来新的安全挑战。

问题:

• Chain-of-Thought 可控性:长推理过程更难监控
• 越狱风险:推理过程可能被引导产生有害内容
• 隐私泄露:推理过程可能泄露训练数据

研究发现(2025):

• 增加推理计算(reasoning effort)会降低可控性
• 但相比增加模型参数,增加推理计算更安全
• 需要新的安全对齐方法

方向 5:理论基础(Theoretical Understanding)

为什么 Test-Time Compute Scaling 有效?

开放问题:

• 最优计算分配的理论界限是什么?
• 推理能力能否从预训练中涌现?
• 如何预测哪些问题受益于推理扩展?

代表工作:

• Provable Scaling Laws for Test-Time Compute(NeurIPS 2025):理论证明失败概率随计算指数/幂律下降
• The Shadow Price of Reasoning(2026):经济学视角的最优预算分配
• The Cost of Reasoning: Token-Accuracy Frontiers(2026):统一框架分析推理效率

方向 6:混合快慢系统(Hybrid Fast-Slow Systems)

结合快系统(传统 LLM)和慢系统(推理模型)。

架构:

• 路由层:判断问题类型
• 快路径:简单问题直接回答
• 慢路径:复杂问题深度推理

优势:

• 平均延迟低
• 复杂问题准确率高
• 资源利用高效

代表工作:

• FrugalGPT(2023):模型级联
• RouteLLM(2024):偏好路由
• AdaptThink(2025):自适应推理控制

未来展望

Test-Time Compute Scaling 代表了 LLM 发展的新范式:

1. 从"训练时扩展"到"推理时扩展":

   • 不再只依赖更大的模型和更多的数据
   • 推理时的计算也成为性能提升的来源

2. 从"快速回答"到"深度思考":

   • 模型学会"慢下来思考"
   • 类似人类的系统 2 思维

3. 从"通用模型"到"自适应系统":

   • 根据问题难度动态调整计算
   • 高效利用资源

4. 从"黑盒"到"可解释":

   • Chain-of-Thought 提供推理过程
   • 更容易调试和改进

对产业的影响

Test-Time Compute Scaling 正在重塑 AI 产业的多个方面:

1. 模型训练策略:

   • 预训练不再是唯一焦点
   • 强化学习成为推理能力的核心训练方法
   • 训练数据和训练目标的设计需要重新思考

2. 推理基础设施:

   • 推理成本成为重要考量
   • 需要专门的推理优化硬件和软件
   • 推理服务提供商需要支持动态预算分配

3. 应用场景:

   • 复杂推理任务(数学、代码、科学)率先受益
   • 需要高准确率的场景(医疗、法律、金融)采用推理模型
   • 实时性要求高的场景仍需权衡延迟和准确率

4. 商业模式:

   • 按 token 计费的模型需要重新定价
   • 推理质量而非速度成为差异化因素
   • 企业需要在成本和准确率之间找到平衡点

总结

Test-Time Compute Scaling 是 LLM 发展的新范式,通过推理时的计算扩展实现性能提升。核心机制包括并行扩展和序列扩展,训练关键在于用强化学习教会模型有效使用长 Chain-of-Thought。奖励模型(ORM vs PRM)和 Compute-Optimal 策略是重要支撑。性能突破显著(数学推理准确率从 12% 到 96%),但仍面临成本控制、过度思考等挑战。未来方向包括高效推理、多模态、Agent 推理、安全性和理论基础。这项技术仍在早期阶段,未来 1-2 年可能会有更多突破。

这项技术仍在早期阶段,未来 1-2 年可能会有更多突破。