测试时计算缩放与推理模型

1. 引言

传统深度学习的训练-推理范式中，模型的”智能”主要由训练时投入的计算资源决定，推理时则尽可能高效执行。然而，2024-2025年间，一种新的范式兴起：测试时计算缩放（Test-Time Compute Scaling）—— 通过在推理时投入更多计算资源来提升模型性能。

这一范式的典型代表是：

• OpenAI o1：通过强化学习训练的长推理链模型
• DeepSeek-R1：纯RL训练，无需SFT监督
• Kimi k1.5：长CoT与短CoT的混合策略

本文系统介绍测试时计算缩放的理论和实践进展。

2. 测试时计算范式

2.1 从训练到推理的范式转变

传统深度学习的计算分配：

$$\text{Total Compute}=\underset{\text{训练计算}}{\underbrace{C_{\text{train}}}}+\underset{\text{推理计算}}{\underbrace{C_{\text{inference}}}}$$

传统观点认为 $C_{\text{train}}\gg C_{\text{inference}}$，因此关注训练缩放定律。

测试时计算缩放的核心洞察：在推理时分配更多计算（生成多个候选、搜索、迭代）可以显著提升性能。

2.2 计算模式分类

模式	描述	示例
训练时计算缩放	增加模型参数、训练数据、训练步数	GPT-4、Chinchilla
测试时计算缩放（推理）	推理时增加计算（token数、采样数）	o1、o3
混合计算	训练和推理时都增加计算	DeepSeek-R1

2.3 测试时计算的方式

1. 顺序缩放：生成更长的思维链（更多推理token）
2. 并行缩放：生成多个候选答案，使用验证器选择
3. 自适应计算：根据问题难度分配不同计算量
4. 搜索算法：束搜索、MCTS等探索策略

3. 测试时计算的理论框架

3.1 问题形式化

设给定输入 $x$，模型需要输出正确答案 $y^{\ast }$。测试时计算的目标是：

$$\underset{a\in \mathcal{A}(x)}{\max }\mathrm{Pr}(y^{\ast }|x,a)$$

其中 $\mathcal{A}(x)$ 是给定 $x$ 的可能动作/推理序列，$|a|$ 表示计算量。

3.2 顺序缩放 vs 并行缩放

定理（计算等价性）¹：

对于具有有限推理深度的任务，以下两种计算方式存在渐近等价关系：

1. 顺序缩放：生成长度为 $T$ 的单个推理链
2. 并行缩放：生成 $T$ 个长度为1的独立推理

然而，非渐近情况下存在指数级差异：

• 顺序缩放利用自回归的依赖结构
• 并行缩放缺乏依赖，但可探索更多样本

3.3 自适应计算分配

Setlar等人²的研究表明：均匀计算分配是次优的。

定理（最优计算分配）：

设问题集合 $\mathcal{Q}$ 的难度分布为 $p(q)$，计算预算为 $C$。最优分配满足：

$$c(q)\propto \frac{\partial \text{性能}}{\partial c}{|}_{c=c(q)}\cdot p(q)$$

即高难度问题应获得更多计算资源。

class AdaptiveComputeAllocator:
    """Adaptive compute allocation based on problem difficulty"""
    
    def __init__(self, model, verifier, compute_budget):
        self.model = model
        self.verifier = verifier
        self.budget = compute_budget
    
    def solve(self, problem):
        """Solve problem with adaptive compute"""
        
        # Initial quick attempt
        answer = self.model.generate(problem, max_tokens=100)
        if self.verifier.check(problem, answer):
            return answer, 'easy'
        
        # Medium compute
        for _ in range(4):
            answer = self.model.generate(problem, max_tokens=500)
            if self.verifier.check(problem, answer):
                return answer, 'medium'
        
        # High compute
        answers = []
        for _ in range(16):
            answer = self.model.generate(problem, max_tokens=2000, temperature=0.8)
            answers.append(answer)
        
        # Use verifier to select best
        best = self.verifier.select_best(problem, answers)
        return best, 'hard'

4. 推理模型：o1与DeepSeek-R1

4.1 OpenAI o1的突破

o1是首个大规模商用的推理模型，其关键特征：

1. 长思维链：内部生成详细的推理步骤
2. RL训练：使用过程奖励模型（PRM）训练
3. 测试时搜索：结合波束搜索和自验证

4.2 DeepSeek-R1-Zero：纯RL的力量

DeepSeek-R1-Zero³展示了令人惊讶的结果：无需任何SFT监督，纯RL即可诱导出推理能力。

关键发现：

1. 涌现的反思行为：模型自发学会在推理过程中”回顾”和”修正”
2. 长思维链的涌现：推理链长度从几百token增长到数千token
3. 自我验证能力：模型学会验证自己的推理步骤

4.3 DeepSeek-R1架构

DeepSeek-R1使用以下核心技术：

1. GRPO算法：Group Relative Policy Optimization
2. 可验证奖励：数学答案为二元奖励
3. 长上下文训练：支持长达32K的思维链
4. 知识蒸馏：将推理能力蒸馏到小模型

4.4 Kimi k1.5的分层策略

Kimi k1.5⁴提出了长CoT + 短CoT的混合策略：

策略	适用场景	计算量
短CoT	简单问答、常识推理	100-500 tokens
长CoT	数学证明、代码生成	2K-32K tokens
自适应	混合任务	动态调整

5. 验证器的关键性

5.1 验证器的定义

验证器（Verifier/Discriminator）是判断给定答案正确性的函数：

$$v(x,y)\in \{0,1\}\text{或}v(x,y)\in [0,1]$$

在可验证任务中：

• 数学：答案是否等于标准答案
• 代码：代码是否通过所有测试用例
• 事实：陈述是否符合知识库

5.2 为什么验证器至关重要

Setlar等人²的核心发现：没有验证器的计算缩放是次优的。

定理（验证器必要性）：

对于难度分布为 $p(q)$ 的问题集合，无验证器的多次采样服从：

$$\text{性能}(C)\le 1-(1-p_{\text{correct}}{)}^C$$

而有验证器的束搜索可以达到：

$$\text{性能}(C)\le 1-(1-p_{\text{correct}}{)}^C+O(\text{验证质量})$$

5.3 Process Reward Model vs Outcome Reward Model

方面	ORM（结果奖励）	PRM（过程奖励）
评估粒度	最终答案	每个推理步骤
训练数据	答案正确/错误	步骤级别标注
优势	简单、无需标注	更细粒度的指导
劣势	无法指导中间步骤	标注成本高

Free PRM⁵提出从ORM蒸馏PRM的方法：

class FreePRM:
    """Distill PRM from outcome supervision"""
    
    def distill(self, dataset, outcome_model, process_model):
        """
        Distill PRM from ORM without step-level labels
        
        Key insight: If ORM gives high reward to an answer,
        intermediate steps are likely correct
        """
        for (x, y) in dataset:
            outcome_reward = outcome_model(x, y)
            
            # Split trajectory into steps
            steps = split_trajectory(y)
            
            for i, step in enumerate(steps):
                partial_answer = concatenate(steps[:i+1])
                
                # If full answer is correct, reward intermediate steps
                if outcome_reward == 1:
                    process_reward = 1.0
                else:
                    # Attribution: which step caused failure?
                    process_reward = self.attribute_blame(
                        steps[:i+1], outcome_model(x, y)
                    )
                
                process_model.update(x, step, process_reward)

6. 缩放规律：训练vs推理

6.1 训练时计算缩放

标准缩放定律：

$$L(N,D)\approx {\left(\frac{N_c}{N}\right)}^{{\alpha }_N}+{\left(\frac{D_c}{D}\right)}^{{\alpha }_D}$$

其中 $N$ 是参数量，$D$ 是训练token数，${\alpha }_N\approx 0.5,{\alpha }_D\approx 0.1$。

6.2 推理时计算缩放

定理（推理缩放定律）⁶：

模型性能随推理计算 $C_{\text{inf}}$ 的变化满足：

$$L(C_{\text{inf}})\approx L_{\infty }+\kappa \cdot C_{\text{inf}}^{-\beta }$$

其中 $L_{\infty }$ 是不可约误差（由训练决定），$\beta \approx 0.3-0.5$。

6.3 训练-推理权衡

关键洞察：存在最优的训练-推理计算分配：

$$C_{\text{total}}=C_{\text{train}}+C_{\text{inference}}=\text{常数}$$

最优分配取决于：

1. 验证器质量：好的验证器允许更多推理计算
2. 问题难度分布：难题多分配推理计算
3. 延迟约束：实时应用限制推理计算

6.4 性能 plateau

Wang等人⁷发现：推理计算缩放存在plateau现象。

观察：

• 当推理计算增加 $10^2\sim 10^4$ 倍时，性能增益接近零
• 原因：达到模型能力上界，无法通过更多计算突破
• 缓解：需要更好的训练或架构改进

7. Latent Reasoning：隐空间推理

7.1 动机

传统推理在token空间进行，存在以下问题：

1. 冗长的思维链占据上下文长度
2. 离散的token生成限制了推理的表达能力
3. 推理步骤与最终答案纠缠

7.2 隐空间推理框架

Geiping等人⁸提出Latent Reasoning：

核心思想：在连续隐空间中进行推理，而非离散token空间。

设 $z\in {\mathbb{R}}^d$ 为隐变量，推理过程为：

$$z_{t+1}=f_{\theta }(z_t,x)=\text{MLP}(z_t,x)$$

最终答案从隐状态解码：

$$y=\text{Decoder}(z_T)$$

7.3 与Mamba的结合

M1模型⁹将Latent Reasoning与Mamba（状态空间模型）结合：

• 状态空间作为隐推理空间
• 选择性机制决定哪些信息保留在推理链中
• 线性复杂度允许极长推理链（100K+ tokens）

class LatentReasoningMamba:
    """Mamba-based latent reasoning"""
    
    def __init__(self, hidden_dim, state_dim, n_layers):
        self.encoder = TransformerEncoder()
        self.mamba = MambaBlock(state_dim, n_layers)
        self.decoder = TransformerDecoder()
    
    def forward(self, x, max_reasoning_steps=100):
        # Encode input to latent state
        z = self.encoder(x)
        
        # Recurrent reasoning in latent space
        for t in range(max_reasoning_steps):
            z = self.mamba(z)
            
            # Early exit if confident
            if self.confidence(z) > 0.99:
                break
        
        # Decode to answer
        y = self.decoder(z)
        return y
    
    def confidence(self, z):
        """Confidence estimation for early exit"""
        logits = self.decoder.head(z)
        probs = F.softmax(logits, dim=-1)
        max_prob = probs.max()
        return max_prob

8. 总结与展望

8.1 核心结论

1. 测试时计算是一种独立的缩放维度：与训练时计算同等重要
2. 验证器是推理缩放的关键：无验证器的计算缩放存在天花板
3. 纯RL可以诱导推理：DeepSeek-R1-Zero证明了这一点
4. Latent Reasoning开辟新方向：在连续空间推理可能更高效

8.2 开放问题

1. 最优计算分配：如何为给定任务确定训练/推理计算比例？
2. 通用验证器：如何构建适用于任意任务的验证器？
3. 隐空间推理的理论：为什么隐空间推理有效？

8.3 前沿方向

1. 自适应推理：根据问题难度动态调整推理长度
2. 多模态推理：视觉+语言的测试时计算
3. 持续推理：在长对话中累积推理状态

参考文献

Footnotes

1. Snell, C. et al. (2024). “Scaling LLM Test-Time Compute Comparatively.” arXiv:2408.03314. ↩

2. Setlur, A. et al. (2025). “Scaling Test-Time Compute Without Verification is Suboptimal.” arXiv:2502.12118. ↩ ↩²

3. DeepSeek-AI. (2025). “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.” arXiv:2501.12948. ↩

4. MoonshotAI. (2025). “Kimi k1.5: RL Scaling Study with LLMs.” arXiv:2501.12599. ↩

5. Wang, P. et al. (2024). “Free PRM: Distilling Process Reward Models from Outcome Supervision.” arXiv:2412.01981. ↩

6. Kaplan, J. et al. (2020). “Scaling Laws for Neural Language Models.” arXiv:2001.08361. ↩

7. Wang, J. et al. (2025). “Scaling over Scaling: Test-Time Compute Scaling for Large Reasoning Models.” arXiv:2505.20522. ↩

8. Geiping, J. et al. (2025). “Scaling up Test-Time Compute with Latent Reasoning.” arXiv:2502.05171. ↩

9. Anonymous. (2025). “M1: Scalable Test-Time Compute with Mamba Reasoning Models.” arXiv:2504.10449. ↩