推理时扩展深度解析：Test-Time Scaling 的理论与实践

1
预训练 Scaling Laws：
2

3
  能力 ∝ 模型参数量 × 训练tokens × 计算量
4

5
  历史数据：
6
  ┌─────────────────────────────────────────────────────────┐
7
  │  GPT-2 (1.5B)      训练 tokens ~ 10^9                 │
8
  │  GPT-3 (175B)      训练 tokens ~ 10^11                │
9
  │  PaLM (540B)       训练 tokens ~ 10^12                │
10
  │  GPT-4 (估计)      训练 tokens ~ 10^13+               │
11
  └─────────────────────────────────────────────────────────┘
12

13
  问题：
14
  → 高质量数据日益稀缺
15
  → 训练成本指数增长
16
  → 边际收益递减
17
  → 模型能力在某些任务上仍有上限

1
┌─────────────────────────────────────────────────────────────┐
2
│              推理时扩展的核心思想                             │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                              │
5
│  传统观点：                                                  │
6
│  "模型能力由训练决定，推理只是执行"                           │
7
│                                                              │
8
│  新观点：                                                    │
9
│  "推理时也可以投入计算来提升答案质量"                         │
10
│                                                              │
11
│  类比：                                                      │
12
│  → 训练 = 写代码时编译一次                                   │
13
│  → 推理 = 运行时可以多次迭代优化                             │
14
│                                                              │
15
│  核心公式：                                                  │
16
│                                                              │
17
│    能力 = f(训练计算量, 推理计算量)                         │
18
│                                                              │
19
│  关键洞察：                                                  │
20
│  → 增加推理时的计算量可以弥补训练时的不足                     │
21
│  → 复杂问题需要更多推理时计算                                │
22
│  → 简单问题可以跳过复杂推理                                  │
23
│                                                              │
24
└─────────────────────────────────────────────────────────────┘

1
class ChainOfThought:
2
    """
3
    Chain-of-Thought 提示
4

5
    核心：将答案的推导过程显式表达出来
6
    """
7

8
    def standard_prompt(self):
9
        """
10
        标准提示
11
        """
12
        return """
13
        Q: 小明有3个苹果，小红给了他2个，他又吃了1个，还剩几个？
14
        A: 4个
15
        """
16

17
    def cot_prompt(self):
18
        """
19
        CoT 提示
20
        """
21
        return """
22
        Q: 小明有3个苹果，小红给了他2个，他又吃了1个，还剩几个？
23
        A: 让我们逐步思考。
24

25
        1. 小明开始有3个苹果
26
        2. 小红给了他2个，所以是 3 + 2 = 5 个
27
        3. 他又吃了1个，所以是 5 - 1 = 4 个
28

29
        所以还剩 4 个苹果。
30
        """
31

32
    def math_prompt(self):
33
        """
34
        数学问题 CoT
35
        """
36
        return """
37
        Q: 计算 15 × 17
38

39
        A: 让我们逐步计算。
40

41
        1. 15 × 17 = 15 × (20 - 3)
42
        2. = 15 × 20 - 15 × 3
43
        3. = 300 - 45
44
        4. = 255
45

46
        答案是 255。
47
        """

1
class CoTAnalysis:
2
    """
3
    CoT 有效性分析
4
    """
5

6
    def why_works(self):
7
        """
8
        CoT 有效的可能原因
9
        """
10
        return {
11
            "intermediate_tokens": "中间 token 作为工作记忆",
12
            "sequential_computation": "强制模型逐步计算而非直接记忆",
13
            "error_localization": "错误更容易定位",
14
            "attention_distribution": "注意力更均匀分布",
15
            "program_synthesis": "隐式合成计算程序",
16
        }
17

18
    def ablation(self):
19
        """
20
        消融实验结论
21
        """
22
        return {
23
            "math_tasks": "CoT 提升最显著 (~40% 提升)",
24
            "commonsense": "中度提升 (~15%)",
25
            "factual_recall": "提升有限",
26
            "key_factors": [
27
                "模型规模 >= 100B 参数",
28
                "使用数学/代码类任务",
29
                "显式提示 'let's think step by step'",
30
            ],
31
        }

1
class CoTImplementation:
2
    """
3
    CoT 实现
4
    """
5

6
    def few_shot_cot(self):
7
        """
8
        Few-shot CoT
9

10
        提供多个 CoT 示例
11
        """
12
        return """
13
        Q: 小明有5个球，丢了2个，又买了3个，现在有几个？
14
        A: 让我们逐步思考。
15
        1. 开始有5个球
16
        2. 丢了2个: 5 - 2 = 3
17
        3. 又买了3个: 3 + 3 = 6
18
        答案: 6个
19

20
        ---
21
        Q: 书店有80本书，第一天卖了15本，第二天卖了20本，还剩多少？
22
        A: 让我们逐步思考。
23
        1. 开始有80本
24
        2. 第一天卖了15本: 80 - 15 = 65
25
        3. 第二天卖了20本: 65 - 20 = 45
26
        答案: 45本
27

28
        ---
29
        Q: [新问题]
30
        """
31

32
    def zero_shot_cot(self):
33
        """
34
        Zero-shot CoT
35

36
        简单指令触发
37
        """
38
        return """
39
        问题: [用户问题]
40

41
        让我们逐步思考：
42
        """
43

44
    def api_usage(self):
45
        """
46
        API 使用示例
47
        """
48
        return '''
49
        from openai import OpenAI
50

51
        response = client.chat.completions.create(
52
            model="gpt-4",
53
            messages=[
54
                {
55
                    "role": "user",
56
                    "content": "问题: 小明有3个苹果，小红给了他2个，他又吃了1个，还剩几个？\\n\\n让我们逐步思考："
57
                }
58
            ],
59
            max_tokens=500,
60
            temperature=0.7,
61
        )
62

63
        print(response.choices[0].message.content)
64
        '''

1
class SelfConsistency:
2
    """
3
    Self-Consistency
4

5
    核心思想：
6
    1. 多次采样不同的推理路径
7
    2. 统计每个答案出现的次数
8
    3. 选择出现最多的答案
9
    """
10

11
    def __init__(self, model, num_samples=40):
12
        self.model = model
13
        self.num_samples = num_samples
14

15
    def generate_paths(self, question):
16
        """
17
        生成多条推理路径
18
        """
19
        responses = []
20

21
        for _ in range(self.num_samples):
22
            response = self.model.generate(
23
                prompt=f"{question}\n\n让我们逐步思考：",
24
                temperature=0.8,  # 高温度增加多样性
25
                max_tokens=500,
26
            )
27
            responses.append(response)
28

29
        return responses
30

31
    def extract_answer(self, response):
32
        """
33
        从响应中提取答案
34
        """
35
        # 简单实现：提取最后一行数字
36
        lines = response.strip().split("\n")
37
        for line in reversed(lines):
38
            # 尝试提取数字
39
            import re
40
            numbers = re.findall(r'-?\d+', line)
41
            if numbers:
42
                return numbers[-1]  # 取最后一个数字
43

44
        return None
45

46
    def majority_vote(self, answers):
47
        """
48
        多数投票
49
        """
50
        from collections import Counter
51

52
        counter = Counter(answers)
53
        most_common = counter.most_common(1)[0]
54

55
        return {
56
            "answer": most_common[0],
57
            "count": most_common[1],
58
            "total": len(answers),
59
            "confidence": most_common[1] / len(answers),
60
            "all_votes": counter,
61
        }
62

63
    def solve(self, question):
64
        """
65
        完整流程
66
        """
67
        # Step 1: 生成多条路径
68
        responses = self.generate_paths(question)
69

70
        # Step 2: 提取答案
71
        answers = [self.extract_answer(r) for r in responses]
72
        answers = [a for a in answers if a is not None]
73

74
        # Step 3: 多数投票
75
        result = self.majority_vote(answers)
76

77
        return result

1
Self-Consistency 效果（GSM8K 数据集）：
2

3
  基线 (Greedy):
4
  → LLM 准确率: 46.9%
5

6
  Self-Consistency (40 samples):
7
  → 准确率提升到: 74.4%
8
  → 相对提升: +27.5%
9

10
  关键发现：
11
  → 复杂问题提升更显著
12
  → 多数投票能过滤错误推理
13
  → 计算量换质量的有效方式
14

15
  成本分析：
16
  → 40x 推理成本
17
  → 但比训练大模型便宜得多

1
class SamplingStrategy:
2
    """
3
    采样策略优化
4
    """
5

6
    def temperature_analysis(self):
7
        """
8
        温度分析
9
        """
10
        return {
11
            "temperature_0.0": {
12
                "description": "Greedy 解码",
13
                "diversity": "最低",
14
                "适合": "简单问题",
15
            },
16
            "temperature_0.3": {
17
                "description": "低温度",
18
                "diversity": "低",
19
                "适合": "需要一定多样性的推理",
20
            },
21
            "temperature_0.6": {
22
                "description": "中等温度",
23
                "diversity": "中等",
24
                "适合": "大多数推理任务",
25
            },
26
            "temperature_0.8": {
27
                "description": "高温度",
28
                "diversity": "高",
29
                "适合": "Self-Consistency",
30
            },
31
        }
32

33
    def top_p_analysis(self):
34
        """
35
        Top-p 核采样分析
36
        """
37
        return {
38
            "top_p_0.9": "截断尾部 10%，保持较高质量",
39
            "top_p_0.95": "更宽松的截断，更多样性",
40
            "top_p_0.99": "几乎不做截断，最大多样性",
41
            "recommendation": "top_p=0.95, temperature=0.7 是好的起点",
42
        }

1
class BestOfN:
2
    """
3
    Best-of-N 采样
4

5
    核心思想：
6
    1. 生成 N 个候选答案
7
    2. 用奖励模型对每个答案打分
8
    3. 选择得分最高的答案
9
    """
10

11
    def __init__(self, reward_model, n=100):
12
        self.reward_model = reward_model
13
        self.n = n
14

15
    def generate_candidates(self, question):
16
        """
17
        生成 N 个候选
18
        """
19
        candidates = []
20

21
        for _ in range(self.n):
22
            response = self.llm.generate(
23
                prompt=f"{question}\n\n让我们逐步思考：",
24
                temperature=0.8,
25
            )
26
            candidates.append(response)
27

28
        return candidates
29

30
    def score_candidates(self, question, candidates):
31
        """
32
        对候选打分
33
        """
34
        scores = []
35

36
        for candidate in candidates:
37
            # 使用奖励模型打分
38
            score = self.reward_model.score(question, candidate)
39
            scores.append(score)
40

41
        return scores
42

43
    def select_best(self, candidates, scores):
44
        """
45
        选择最佳
46
        """
47
        best_idx = scores.index(max(scores))
48
        return {
49
            "answer": candidates[best_idx],
50
            "score": scores[best_idx],
51
        }

1
class WeightedBestOfN:
2
    """
3
    加权 Best-of-N
4

5
    不仅选择最佳，还考虑概率
6
    """
7

8
    def select_with_probability(self, candidates, log_probs, scores):
9
        """
10
        基于概率加权的选择
11
        """
12
        import numpy as np
13

14
        # 计算概率
15
        probs = np.exp(log_probs)
16

17
        # 归一化分数
18
        normalized_scores = (scores - np.mean(scores)) / (np.std(scores) + 1e-8)
19

20
        # 加权概率
21
        weights = probs * np.exp(normalized_scores)
22
        weights = weights / weights.sum()
23

24
        # 加权采样
25
        selected_idx = np.random.choice(len(candidates), p=weights)
26

27
        return candidates[selected_idx]

1
class Comparison:
2
    """
3
    Best-of-N vs Self-Consistency
4
    """
5

6
    def compare(self):
7
        """
8
        对比
9
        """
10
        return {
11
            "self_consistency": {
12
                "需要": "CoT 提示",
13
                "评判方式": "多数投票",
14
                "优点": "无需额外奖励模型",
15
                "缺点": "需要一致的答案格式",
16
                "适用": "数学、代码等有明确答案的任务",
17
            },
18
            "best_of_n": {
19
                "需要": "奖励模型",
20
                "评判方式": "奖励打分",
21
                "优点": "可应用于开放式任务",
22
                "缺点": "需要训练奖励模型",
23
                "适用": "对话、写作等开放式任务",
24
            },
25
        }

1
class RewardModels:
2
    """
3
    结果奖励 vs 过程奖励
4
    """
5

6
    def outcome_reward_model(self):
7
        """
8
        结果奖励模型 (ORM)
9

10
        只在最终答案处打分
11
        """
12
        return """
13
        问题: 2x + 5 = 15, 求 x
14

15
        解答:
16
        步骤1: 2x = 15 - 5 = 10
17
        步骤2: x = 10 / 2 = 5
18
        步骤3: x = 5
19

20
        最终答案: x = 5
21

22
        ORM 奖励: ✓ (最终答案正确)
23
        """
24

25
    def process_reward_model(self):
26
        """
27
        过程奖励模型 (PRM)
28

29
        对每个推理步骤打分
30
        """
31
        return """
32
        问题: 2x + 5 = 15, 求 x
33

34
        解答:
35
        步骤1: 2x = 15 - 5 = 10      → PRM: 0.9 ✓
36
        步骤2: x = 10 / 2 = 5        → PRM: 0.85 ✓
37
        步骤3: x = 5                 → PRM: 0.8 ✓
38

39
        最终答案: x = 5               → ORM: 1.0 ✓
40

41
        关键优势:
42
        → 能识别错误步骤
43
        → 提供更细粒度的反馈
44
        → 更好地指导搜索
45
        """

1
class ProcessRewardModel:
2
    """
3
    PRM 实现
4
    """
5

6
    def __init__(self, base_model):
7
        self.model = base_model
8

9
    def score_step(self, question, reasoning_steps):
10
        """
11
        对推理步骤打分
12

13
        输入: [步骤1, 步骤2, ..., 步骤N, 最终答案]
14
        输出: [奖励1, 奖励2, ..., 奖励N]
15
        """
16
        step_rewards = []
17

18
        accumulated_context = question
19

20
        for i, step in enumerate(reasoning_steps):
21
            # 构建上下文
22
            context = accumulated_context + "\n" + step
23

24
            # 使用模型预测该步骤是否正确
25
            # 方式1: 二分类 (正确/错误)
26
            correctness = self.model.predict_step_correctness(context)
27

28
            # 方式2: 打分 (0-1)
29
            score = self.model.score_step_quality(context)
30

31
            step_rewards.append(score)
32
            accumulated_context += "\n" + step
33

34
        return step_rewards
35

36
    def lookahead_reward(self, current_step, future_steps):
37
        """
38
        前看奖励
39

40
        评估从当前状态可能达到的奖励
41
        """
42
        total_reward = 0
43

44
        for future_step in future_steps:
45
            # 模拟未来的奖励
46
            future_reward = self.model.score_step_quality(future_step)
47
            total_reward += future_reward * self.discount_factor
48

49
        return total_reward

1
class PRMTraining:
2
    """
3
    PRM 训练
4
    """
5

6
    def training_data(self):
7
        """
8
        训练数据构建
9
        """
10
        return """
11
        数据来源：
12
        1. 人工标注
13
           - 收集多条推理路径
14
           - 标注每个步骤是否正确
15

16
        2. 合成数据
17
           - 使用 LLM 生成推理路径
18
           - 自动标记正确/错误的步骤
19

20
        3. 过程监督
21
           - 在 RLHF 中加入过程奖励
22
           - 使用 Process-Directed RL
23

24
        数据格式：
25
        {
26
            "question": "...",
27
            "steps": [
28
                {"text": "步骤1", "label": 1},
29
                {"text": "步骤2", "label": 1},
30
                {"text": "错误步骤", "label": 0},
31
                {"text": "步骤4", "label": 1},
32
            ],
33
        }
34
        """
35

36
    def training_objective(self):
37
        """
38
        训练目标
39
        """
40
        return """
41
        PRM 训练目标：
42

43
        L = -∑ log P(r_i | s_1, ..., s_i) × r_i
44

45
        其中：
46
        - r_i 是步骤 i 的奖励 (0 或 1)
47
        - P 是模型预测的步骤正确概率
48

49
        也可以使用回归目标：
50
        L = MSE(P(s_i is correct), r_i)
51
        """

1
class TreeOfThoughts:
2
    """
3
    Tree of Thoughts
4

5
    核心思想：
6
    1. 将问题分解为多个思考节点
7
    2. 探索多条思考路径
8
    3. 使用启发式评估选择最佳路径
9
    """
10

11
    def __init__(self, model, max_depth=5, num_branches=3):
12
        self.model = model
13
        self.max_depth = max_depth
14
        self.num_branches = num_branches
15
        self.tree = None
16

17
    def generate_thoughts(self, state):
18
        """
19
        从当前状态生成多个思考
20
        """
21
        prompt = f"""
22
        当前状态: {state}
23

24
        请提出 {self.num_branches} 个不同的思考方向或行动：
25
        """
26

27
        response = self.model.generate(prompt, temperature=0.8)
28

29
        # 解析多个思考
30
        thoughts = response.split("\n")[:self.num_branches]
31

32
        return thoughts
33

34
    def evaluate_state(self, state, goal):
35
        """
36
        评估当前状态
37

38
        返回: (score, reason)
39
        """
40
        prompt = f"""
41
        目标: {goal}
42
        当前状态: {state}
43

44
        评估这个状态对目标的贡献程度 (0-10)，并说明理由：
45
        """
46

47
        response = self.model.generate(prompt)
48

49
        # 解析分数
50
        score = self.extract_score(response)
51

52
        return score, response
53

54
    def search(self, initial_state, goal):
55
        """
56
        树搜索
57
        """
58
        from collections import deque
59

60
        # BFS 或 DFS
61
        queue = deque([(initial_state, [], 0)])  # (state, path, depth)
62
        best_state = None
63
        best_score = -float('inf')
64

65
        while queue:
66
            state, path, depth = queue.popleft()
67

68
            # 评估当前状态
69
            score, _ = self.evaluate_state(state, goal)
70

71
            if score > best_score:
72
                best_score = score
73
                best_state = state
74

75
            # 如果还没到最大深度，继续扩展
76
            if depth < self.max_depth:
77
                thoughts = self.generate_thoughts(state)
78

79
                for thought in thoughts:
80
                    new_state = state + "\n" + thought
81
                    new_path = path + [thought]
82
                    queue.append((new_state, new_path, depth + 1))
83

84
        return best_state, best_score

1
class ToTvsCoT:
2
    """
3
    Tree of Thoughts vs Chain of Thoughts
4
    """
5

6
    def compare(self):
7
        """
8
        对比
9
        """
10
        return {
11
            "CoT": {
12
                "structure": "链式，一条路径",
13
                "branching": "无",
14
                "exploration": "无",
15
                "backtracking": "无",
16
                "适合任务": "简单推理、事实问答",
17
            },
18
            "ToT": {
19
                "structure": "树状，多条路径",
20
                "branching": "有",
21
                "exploration": "有（广度搜索）",
22
                "backtracking": "无（但可扩展为图）",
23
                "适合任务": "复杂规划、创意写作",
24
            },
25
        }
26

27
    def example_task(self, task_type):
28
        """
29
        任务适用性
30
        """
31
        return {
32
            "24_game": {
33
                "task": "使用 4 个数字和基本运算得到 24",
34
                "recommended": "ToT",
35
                "reason": "需要探索多种运算组合",
36
            },
37
            "writing": {
38
                "task": "写一篇结构清晰的文章",
39
                "recommended": "ToT",
40
                "reason": "需要规划文章结构和内容",
41
            },
42
            "math_proof": {
43
                "task": "证明数学定理",
44
                "recommended": "CoT + PRM",
45
                "reason": "步骤连续性很重要",
46
            },
47
            "qa": {
48
                "task": "回答事实性问题",
49
                "recommended": "CoT",
50
                "reason": "简单推理即可",
51
            },
52
        }

1
class BeamSearch:
2
    """
3
    Beam Search 用于推理
4
    """
5

6
    def __init__(self, model, beam_width=5):
7
        self.model = model
8
        self.beam_width = beam_width
9

10
    def decode(self, prompt, max_length=200):
11
        """
12
        Beam Search 解码
13
        """
14
        # 初始化
15
        beams = [
16
            {"tokens": [], "score": 0.0, "log_probs": []}
17
        ]
18
        completed = []
19

20
        for step in range(max_length):
21
            all_candidates = []
22

23
            for beam in beams:
24
                if beam.get("finished"):
25
                    # 已完成的 beam
26
                    completed.append(beam)
27
                    continue
28

29
                # 扩展当前 beam
30
                logits = self.model.get_logits(beam["tokens"])
31
                top_k = self.model.top_k(logits, k=self.beam_width * 2)
32

33
                for token, log_prob in top_k:
34
                    new_tokens = beam["tokens"] + [token]
35
                    new_score = beam["score"] + log_prob
36
                    new_log_probs = beam["log_probs"] + [log_prob]
37

38
                    all_candidates.append({
39
                        "tokens": new_tokens,
40
                        "score": new_score,
41
                        "log_probs": new_log_probs,
42
                        "finished": self.model.is_eos(token),
43
                    })
44

45
            # 选择 top-k beams
46
            all_candidates.sort(key=lambda x: x["score"], reverse=True)
47
            beams = all_candidates[:self.beam_width]
48

49
            # 检查是否全部完成
50
            if all(b["finished"] for b in beams):
51
                break
52

53
        # 合并完成的和未完成的
54
        all_seqs = completed + beams
55
        all_seqs.sort(key=lambda x: x["score"] / len(x["tokens"]), reverse=True)
56

57
        return all_seqs[0]["tokens"]
58

59
    def with_reasoning(self, prompt):
60
        """
61
        带推理的 Beam Search
62
        """
63
        # 第一阶段：生成推理路径
64
        reasoning_beams = self.generate_reasoning_beams(prompt)
65

66
        # 第二阶段：基于答案一致性选择
67
        answer_votes = self.vote_on_answers(reasoning_beams)
68

69
        # 返回最一致的答案
70
        return answer_votes[0]

1
class InferenceTimeBeamSearch:
2
    """
3
    推理时 Beam Search 优化
4
    """
5

6
    def diverse_beams(self):
7
        """
8
        多样性 Beam Search
9
        """
10
        return """
11
        标准 Beam Search 只保留概率最高的路径
12
        可能导致路径同质化
13

14
        多样性 Beam Search 惩罚相似的候选：
15

16
        score_i = log P(token_i) + λ × diversity_penalty
17

18
        diversity_penalty = max_j exp((similarity(token_i, token_j)) / τ)
19

20
        其中 λ 控制多样性权重，τ 是温度参数
21
        """
22

23
    def lookahead_beams(self):
24
        """
25
        前看 Beam Search
26
        """
27
        return """
28
        评估当前 token 时考虑未来的潜力：
29

30
        score(token_t) = log P(token_t) + γ × V(state_{t+1})
31

32
        其中 V 是价值函数，评估从当前状态能达到好结果的可能性
33

34
        这需要训练一个价值网络来预测未来奖励
35
        """

1
class STaR:
2
    """
3
    STaR: Self-Taught Reasoner
4

5
    核心思想：
6
    1. 让模型尝试解决难题
7
    2. 成功解决时，记录成功的推理过程
8
    3. 失败时，使用"rationale generation"生成推理
9
    4. 用这些数据微调模型
10
    5. 重复迭代
11
    """
12

13
    def __init__(self, model, iterations=5):
14
        self.model = model
15
        self.iterations = iterations
16

17
    def attempt_solve(self, question, correct_answer):
18
        """
19
        尝试解决问题
20
        """
21
        # 生成解答（带 CoT）
22
        response = self.model.generate(
23
            f"问题: {question}\n让我们逐步思考：",
24
            temperature=0.5,
25
        )
26

27
        extracted_answer = self.extract_answer(response)
28

29
        if extracted_answer == correct_answer:
30
            # 成功：记录推理过程
31
            return {
32
                "success": True,
33
                "rationale": response,
34
                "answer": extracted_answer,
35
            }
36
        else:
37
            # 失败：尝试生成正确推理
38
            return {"success": False, "rationale": None, "answer": extracted_answer}
39

40
    def rationale_generation(self, question, correct_answer):
41
        """
42
        理由生成
43

44
        提示模型"假设你最终会得到正确答案"
45
        """
46
        prompt = f"""
47
        问题: {question}
48
        正确答案: {correct_answer}
49

50
        请推理出正确的答案，假设你是对的。
51
        让我们逐步思考，最后给出正确答案。
52
        """
53

54
        response = self.model.generate(prompt, temperature=0.5)
55

56
        # 验证生成的推理是否正确
57
        extracted = self.extract_answer(response)
58
        if extracted == correct_answer:
59
            return response
60
        else:
61
            return None
62

63
    def iterative_training(self, dataset):
64
        """
65
        迭代训练
66
        """
67
        for iteration in range(self.iterations):
68
            print(f"迭代 {iteration + 1}/{self.iterations}")
69

70
            training_examples = []
71

72
            for item in dataset:
73
                question = item["question"]
74
                answer = item["answer"]
75

76
                # 尝试解决
77
                result = self.attempt_solve(question, answer)
78

79
                if result["success"]:
80
                    # 成功案例
81
                    training_examples.append({
82
                        "prompt": question,
83
                        "response": result["rationale"],
84
                    })
85
                else:
86
                    # 失败案例：生成正确推理
87
                    rationale = self.rationale_generation(question, answer)
88
                    if rationale:
89
                        training_examples.append({
90
                            "prompt": question,
91
                            "response": rationale,
92
                        })
93

94
            # 用收集的数据微调模型
95
            if training_examples:
96
                self.model.fine_tune(training_examples)
97

98
            # 评估
99
            accuracy = self.evaluate(dataset)
100
            print(f"  准确率: {accuracy:.2%}")
101

102
            if accuracy > 0.9:
103
                break
104

105
        return self.model

1
STaR 效果（StrategyQA 数据集）：
2

3
  基线（无推理）：
4
  → 准确率: 53.0%
5

6
  CoT（few-shot）：
7
  → 准确率: 59.7%
8

9
  STaR（自迭代）：
10
  → 准确率: 73.2%
11
  → 提升: +13.5%
12

13
  关键洞察：
14
  → 模型可以"教会自己"推理
15
  → 成功的推理例子比失败更重要
16
  → 迭代可以不断提升能力

1
class TestTimeScaling:
2
    """
3
    测试时计算 Scaling Laws
4
    """
5

6
    def power_law(self, compute_budget, task_difficulty):
7
        """
8
        性能与计算量的幂律关系
9

10
        P(C) = a × C^b + c
11

12
        其中：
13
        - C 是推理计算量
14
        - a, b, c 是拟合参数
15
        - b 通常在 0.1-0.3 之间
16
        """
17
        import numpy as np
18

19
        a, b, c = 0.3, 0.2, 0.5
20
        performance = a * (compute_budget ** b) + c
21

22
        return min(performance, 1.0)  # 上限 1.0
23

24
    def compute_optimal(self, task_difficulty, model_cost, compute_cost):
25
        """
26
        计算最优策略
27

28
        给定任务难度和成本，选择：
29
        - 使用更大的模型
30
        - 还是在推理时投入更多计算
31
        """
32
        return {
33
            "easy_task": "使用小模型 + 少量推理计算",
34
            "medium_task": "使用中等模型 + 适量推理计算",
35
            "hard_task": "使用大模型 + 充足推理计算",
36
            "very_hard_task": "使用最大模型 + 最大推理计算",
37
        }
38

39
    def compute_allocation(self, total_compute):
40
        """
41
        计算量分配
42

43
        在模型规模和推理计算之间如何分配
44
        """
45
        return """
46
        论文 "Test-Time Compute" 的发现：
47

48
        对于简单问题：
49
        → 增加推理计算的效果有限
50
        → 应该用更大的模型
51

52
        对于复杂问题：
53
        → 增加推理计算效果显著
54
        → 可以弥补模型规模不足
55

56
        最佳策略：
57
        → 根据问题难度自适应分配计算
58
        → 简单问题用少量计算
59
        → 复杂问题用更多计算
60
        """