测试时计算Scaling Plateau理论

概述

大型推理模型（Large Reasoning Models, LRM）通过内部测试时计算Scaling显著提升了推理能力。然而，当尝试进一步增加测试时计算时，模型性能会出现饱和现象——继续增加计算资源只能带来边际改进甚至没有改进。这种现象被称为测试时计算Scaling Plateau（TTSPM）。

本文基于arXiv 2505.20522的研究，系统介绍测试时计算Scaling plateau的理论分析框架。

¹

---

1. 背景：为什么需要测试时计算Scaling？

1.1 内部Scaling vs 外部Scaling

传统LLM的推理过程是单次前向传播，计算量相对固定。LRM（如o1、o3、DeepSeek-R1）引入了内部Scaling——在单个前向传播中生成更长的Chain-of-Thought推理链。

外部Scaling（即”scaling over scaling”）则是基于已Scaling的LRM，通过以下方式进一步增加计算：

类型	方法	特点
并行Scaling	多次采样、多条推理路径	独立探索、可并行
顺序Scaling	迭代优化、多轮思考	序列深化、可能误差累积

1.2 核心问题

关键问题：增加测试时计算是否总是有益的？是否存在一个饱和点，超出该点后继续增加计算收益递减？

这个问题对于资源分配和效率优化至关重要，特别是在没有监督反馈的情况下。

---

2. TTSPM理论模型

2.1 基本定义

定义：设$N$为测试时计算的预算（如采样数量、思考token数），$f(N)$为对应的性能指标（如准确率）。我们假设：

$f(N)\stackrel{N\to \infty }{\to }{F}_{\max }$

其中$F_{\max }$是最大可达性能。

2.2 饱和曲线

性能随计算预算的增长呈现饱和曲线特征：

$$f(N)=F_{\max }-\alpha \cdot e^{-\beta N}+\gamma$$

其中：

• $F_{\max }$：最大可达性能
• $\alpha$：初始性能差距
• $\beta$：收敛速率
• $\gamma$：基线性能

2.3 Scaling Unit定义

定义：Scaling Unit（缩放单元）是边际性能增益的度量：

$\Delta f(N)=f(N)-f(N-1)$

当$\Delta f(N)<ϵ$时（$ϵ$为预设阈值），称进入Scaling Plateau。

---

3. 并行Scaling分析

3.1 形式化定义

并行Scaling生成多个独立的推理路径，通过投票或选择机制决定最终答案：

# 并行Scaling示意
def parallel_scaling(model, problem, n_samples):
    responses = []
    for _ in range(n_samples):
        # 独立采样推理路径
        response = model.sample(problem, temperature=0.8)
        responses.append(response)
    # 投票决定最终答案
    return vote(responses)

3.2 成功概率建模

设单次推理成功概率为$p$，则$N$次独立采样的成功概率为：

$P_{\text{success}}(N)=1-(1-p{)}^N$

考虑性能上界$F_{\max }$：

$f_{\parallel }(N)=F_{\max }\cdot P_{\text{success}}(N)=F_{\max }\left(1-(1-p{)}^N\right)$

3.3 边际收益分析

$\frac{\partial f}{\partial N}=F_{\max }\cdot (1-p{)}^N\cdot \ln \left(\frac{1}{1-p}\right)$

关键观察：

• 边际收益随$N$指数衰减
• 收敛速率由$\ln (1/(1-p))$决定
• $p$越小，初始收益越低，但随$N$增加收益更均匀

3.4 饱和点推导

设$ϵ$为可接受的边际收益下界：

$F_{\max }\cdot (1-p{)}^N\cdot \ln \left(\frac{1}{1-p}\right)<ϵ$

解得饱和点：

$N_{\text{sat}}\approx \frac{\ln (ϵ)-\ln (F_{\max })-\ln \ln \left(\frac{1}{1-p}\right)}{\ln (1-p)}$

---

4. 顺序Scaling分析

4.1 形式化定义

顺序Scaling通过迭代优化来改进答案：

# 顺序Scaling示意
def sequential_scaling(model, problem, n_rounds):
    solution = model.generate(problem)
    for _ in range(n_rounds):
        # 反思当前解
        feedback = model.reflect(solution)
        # 基于反馈改进
        solution = model.improve(solution, feedback)
    return solution

4.2 马尔可夫链建模

设状态$S_k$为第$k$轮迭代后的解质量，转移概率为：

$P(S_{k+1}=\text{good}\mid S_k=\text{good})=q$
$P(S_{k+1}=\text{good}\mid S_k=\text{bad})=r$

其中$q>r$（好状态更容易保持或改进）。

4.3 长期行为分析

稳态分布下成功概率：

${\pi }_{\text{good}}=\frac{r}{1-q+r}$

性能函数：

$f_{\text{seq}}(N)=F_{\max }\cdot {\pi }_{\text{good}}\cdot \left(1-{\left(\frac{q+r-1}{1-r}\right)}^N\right)$

4.4 饱和点推导

顺序Scaling的饱和点由特征值决定：

$\lambda =q+r-1$

$N_{\text{sat}}\approx \frac{\ln (ϵ)-\ln (F_{\max })-\ln ({\pi }_{\text{good}})}{\ln (|\lambda |)}$

---

5. 统一理论框架

5.1 核心发现

惊人发现：尽管并行Scaling和顺序Scaling机制不同，它们的性能上界具有统一的数学结构：

$f(N)\le F_{\max }\left(1-C\cdot e^{-\kappa N}\right)$

其中$C$和$\kappa$是依赖于具体策略的参数。

5.2 统一边界

定义有效成功概率$\hat{p}$：

• 并行Scaling：$\hat{p}=1-(1-p{)}^N$
• 顺序Scaling：$\hat{p}=1-{\lambda }^N$

两者都呈现指数衰减结构，差异仅在于衰减速率。

5.3 饱和点统一公式

$N_{\text{sat}}=\frac{1}{\kappa }\ln \left(\frac{C\cdot F_{\max }}{ϵ}\right)$

这提供了一个原则性方法来估计何时应该停止增加计算。

---

6. 实践应用

6.1 自适应计算分配

基于TTSPM，可以设计自适应计算分配策略：

import numpy as np
 
def adaptive_compute(model, problem, epsilon=0.001, max_budget=100):
    """
    基于TTSPM的自适应计算分配
    """
    # 初始化
    N = 1
    f_prev = evaluate(model, problem, n_samples=1)
    
    # 迭代增加计算
    while N < max_budget:
        # 增加一个缩放单元
        N += 1
        f_curr = evaluate(model, problem, n_samples=N)
        
        # 计算边际收益
        delta_f = f_curr - f_prev
        
        # 检查是否进入饱和区
        if delta_f < epsilon:
            print(f"饱和点到达: N = {N}, Δf = {delta_f:.6f}")
            break
        
        f_prev = f_curr
    
    return N, f_curr

6.2 混合策略

结合并行和顺序Scaling的优势：

def hybrid_scaling(model, problem, total_budget):
    """
    混合Scaling策略：先并行探索，再顺序优化
    """
    # Phase 1: 并行探索（快速筛选）
    n_parallel = int(np.sqrt(total_budget))
    candidates = parallel_explore(model, problem, n_samples=n_parallel)
    
    # Phase 2: 选择top-k进行顺序优化
    k = max(3, int(np.sqrt(n_parallel)))
    top_k = select_top_k(candidates, k=k)
    
    # Phase 3: 顺序优化
    for candidate in top_k:
        candidate = sequential_refine(model, candidate, 
                                      n_rounds=total_budget // k)
    
    return vote(top_k)

6.3 资源效率评估

def evaluate_efficiency(f(N), N, F_max):
    """
    评估计算资源使用效率
    """
    achieved = f(N)
    theoretical_max = F_max
    
    # 效率 = 实际收益 / 理论最大收益
    efficiency = achieved / theoretical_max
    
    # 边际效率 = 每个计算单元的收益
    marginal_efficiency = np.diff(f(np.arange(1, N+1))).mean()
    
    return {
        'efficiency': efficiency,
        'marginal_efficiency': marginal_efficiency,
        'proximity_to_max': achieved / theoretical_max
    }

---

7. 实验验证

7.1 实验设置

论文在以下基准上验证理论：

基准	描述	难度
AIME	数学竞赛题	高
MATH-500	500道数学题	中-高
GPQA	博士级科学问题	极高

7.2 主要结果

实验验证了以下关键发现：

1. 饱和点预测准确：TTSPM预测的饱和点与实际观察高度一致
2. 边界紧度：统一边界比单一策略边界更紧
3. 效率提升：基于理论的资源分配比固定预算提升23%效率

7.3 关键数据

MATH-500基准结果：
┌─────────────────┬──────────────┬─────────────┐
│ 计算预算N       │ 准确率       │ 边际收益Δf │
├─────────────────┼──────────────┼─────────────┤
│ 1               │ 72.4%        │ -           │
│ 4               │ 81.2%        │ 2.93%       │
│ 16              │ 86.7%        │ 1.38%       │
│ 64              │ 89.1%        │ 0.40%       │
│ 256             │ 90.2%        │ 0.18%       │ ← 饱和区
│ 1024            │ 90.5%        │ 0.05%       │ ← 饱和点
└─────────────────┴──────────────┴─────────────┘

---

8. 理论意义与实践建议

8.1 理论意义

1. 统一视角：首次为并行和顺序Scaling提供统一分析框架
2. 可预测性：饱和点可被理论预测，无需实验探索
3. 资源优化：为资源受限场景提供理论指导

8.2 实践建议

场景	建议
高效率要求	设置$N$接近饱和点，避免过度计算
质量优先	可超过饱和点，但需评估成本收益比
自适应系统	监控边际收益，动态调整计算预算
混合场景	先并行筛选候选，再顺序优化优质解

8.3 未来方向

1. 动态饱和点：考虑问题难度动态调整饱和阈值
2. 跨问题泛化：建立问题特征与最优预算的映射
3. 验证器集成：将验证器质量纳入TTSPM建模

---

9. 代码实现

9.1 TTSPM模型实现

import numpy as np
from scipy.optimize import curve_fit
 
class TTSPM:
    """
    Test-Time Scaling Performance Model
    
    建模: f(N) = F_max * (1 - C * exp(-kappa * N))
    """
    
    def __init__(self, F_max=1.0):
        self.F_max = F_max
        self.C = None
        self.kappa = None
        self.fitted = False
    
    def model(self, N, C, kappa):
        """TTSPM性能模型"""
        return self.F_max * (1 - C * np.exp(-kappa * N))
    
    def fit(self, N_data, f_data):
        """
        拟合模型参数
        
        Args:
            N_data: 计算预算数组
            f_data: 对应性能数组
        """
        def model_func(N, C, kappa):
            return self.F_max * (1 - C * np.exp(-kappa * N))
        
        popt, _ = curve_fit(
            model_func, N_data, f_data,
            p0=[0.5, 0.1],
            bounds=([0, 0], [1, 10])
        )
        
        self.C, self.kappa = popt
        self.fitted = True
        return self.C, self.kappa
    
    def predict(self, N):
        """预测给定计算预算下的性能"""
        if not self.fitted:
            raise ValueError("Model must be fitted first")
        return self.model(N, self.C, self.kappa)
    
    def compute_saturation_point(self, epsilon=0.001):
        """
        计算饱和点
        
        饱和点定义: df/dN < epsilon
        """
        if not self.fitted:
            raise ValueError("Model must be fitted first")
        
        # 解析解: N_sat = ln(C * F_max / epsilon) / kappa
        N_sat = np.log(self.C * self.F_max / epsilon) / self.kappa
        return int(np.ceil(N_sat))
    
    def compute_marginal_gain(self, N):
        """
        计算边际收益
        """
        if not self.fitted:
            raise ValueError("Model must be fitted first")
        
        return self.F_max * self.C * self.kappa * np.exp(-self.kappa * N)
 
 
class ParallelScaling(TTSPM):
    """并行Scaling的TTSPM实现"""
    
    def __init__(self, p=None, F_max=1.0):
        """
        Args:
            p: 单次推理成功概率
        """
        super().__init__(F_max)
        self.p = p
    
    def set_p(self, p):
        """设置成功概率并推导模型参数"""
        self.p = p
        self.C = 1 - p
        self.kappa = -np.log(p)
        self.fitted = True
    
    def theoretical_f(self, N):
        """理论性能函数"""
        return self.F_max * (1 - (1 - self.p) ** N)
 
 
class SequentialScaling(TTSPM):
    """顺序Scaling的TTSPM实现"""
    
    def __init__(self, q=None, r=None, F_max=1.0):
        """
        Args:
            q: 好状态保持概率
            r: 坏状态改进概率
        """
        super().__init__(F_max)
        self.q = q
        self.r = r
    
    def set_transition(self, q, r):
        """设置转移概率并推导模型参数"""
        self.q = q
        self.r = r
        self.lambda_ = q + r - 1
        self.pi_good = r / (1 - q + r)
        self.C = self.lambda_ * self.pi_good
        self.kappa = -np.log(abs(self.lambda_))
        self.fitted = True
    
    def theoretical_f(self, N):
        """理论性能函数"""
        return (self.F_max * self.pi_good * 
                (1 - self.lambda_ ** N))

9.2 使用示例

import matplotlib.pyplot as plt
 
# 示例数据
N_data = np.array([1, 4, 16, 64, 256, 1024])
f_data = np.array([0.724, 0.812, 0.867, 0.891, 0.902, 0.905])
 
# 创建并拟合模型
model = TTSPM(F_max=0.91)  # 估计最大性能
C, kappa = model.fit(N_data, f_data)
 
# 预测
N_range = np.linspace(1, 1024, 100)
f_pred = model.predict(N_range)
 
# 计算饱和点
saturation_point = model.compute_saturation_point(epsilon=0.001)
print(f"饱和点: N = {saturation_point}")
 
# 可视化
plt.figure(figsize=(10, 6))
plt.scatter(N_data, f_data, s=100, label='实际数据', zorder=5)
plt.plot(N_range, f_pred, 'r-', label='TTSPM拟合')
plt.axvline(x=saturation_point, color='g', linestyle='--', 
            label=f'饱和点 (N={saturation_point})')
plt.xscale('log')
plt.xlabel('计算预算 N')
plt.ylabel('准确率')
plt.title('测试时计算Scaling Plateau分析')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

---

10. 总结

本文系统介绍了测试时计算Scaling plateau的理论框架TTSPM，主要贡献包括：

1. 概率建模：将LRM的测试时计算Scaling建模为概率过程
2. 统一分析：为并行和顺序Scaling提供统一的理论边界
3. 饱和点预测：推导出可计算的饱和点公式
4. 实践指导：为资源高效使用提供理论依据

核心洞察：测试时计算Scaling的收益不是无限的，存在可预测的饱和点。理解和利用这一现象对于构建高效、经济的推理系统至关重要。

---

参考文献

---

相关阅读

• 测试时缩放高原现象分析
• 自适应测试时计算分配
• 测试时计算缩放前沿进展2026
• Forest-of-Thought推理缩放
• 验证器引导的自适应推理

Footnotes

1. Wang et al. “Scaling over Scaling: Exploring Test-Time Scaling Plateau in Large Reasoning Models” arXiv:2505.20522 (2025) ↩