一句话总结：2024-2025 年，推理模型（Reasoning Model）彻底改变了 AI 的能力边界——通过让模型在推理时"花更多时间思考"而非单纯堆参数，OpenAI o1/o3、DeepSeek-R1、Kimi K1.5 和 Gemini 2.5 Thinking 在数学竞赛和编程挑战上实现了从 12% 到 90%+ 的飞跃，开启了 Test-Time Compute Scaling 的新范式。

31.1 推理模型的突破：一场改变游戏规则的革命

31.1.1 一个让人震惊的对比

2024 年初，研究者们用 GPT-4o（当时最强的通用模型）去做 AIME 2024（美国数学邀请赛）的题目。

结果是：12-13% 的正确率。

这是什么概念？AIME 有 15 道题，12% 意味着模型平均只能做对不到 2 道题。要知道，AIME 是美国高中生数学竞赛的第二轮，参加者都是全美数学前 5% 的学生。GPT-4o 连这些高中生都比不过。

然后，2024 年 9 月，OpenAI 发布了 o1-preview。

同样的 AIME 2024 题目，o1 的正确率：74-83%。

┌──────────────────────────────────────────────────────────────┐
│                    AIME 2024 性能飞跃                         │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   GPT-4o        ████                          12-13%         │
│                                                              │
│   o1-preview    ██████████████████████████████████  74-83%   │
│                                                              │
│   o1 (正式版)   ████████████████████████████████████  83-93% │
│                                                              │
│   o3 (2024.12)  ██████████████████████████████████████ 96.7% │
│                                                              │
└──────────────────────────────────────────────────────────────┘

从 12% 到 83%，提升了近 7 倍。这不是渐进式的改进，而是质变。

31.1.2 为什么这是革命性的

让我们来理解一下这个数字意味着什么。

传统的提升路径是这样的：

• GPT-3 → GPT-3.5：性能提升约 30-50%
• GPT-3.5 → GPT-4：性能提升约 50-100%
• GPT-4 → GPT-4o：性能提升约 10-20%

这些都是渐进式的改进，主要靠：

1. 更多参数
2. 更多训练数据
3. 更好的训练技巧

但 GPT-4o 到 o1 的跃迁完全不同。o1 的参数量并没有比 GPT-4o 大多少（具体数字 OpenAI 没公开），但性能却暴涨了 600%+。

这说明什么？

核心洞察：我们找到了一种全新的能力提升方式——不是让模型"更大"，而是让模型"想得更久"。

31.1.3 三个关键性能指标

为了理解推理模型的突破性，我们需要关注三个核心 Benchmark：

AIME（American Invitational Mathematics Examination）是最有说服力的测试，因为：

1. 题目每年更新，不存在"训练集泄露"问题
2. 题目需要多步推理，不能靠背答案
3. 有明确的人类基准（高中数学竞赛生）

o3 在 AIME 2024 上的 96.7% 意味着它平均只错不到 1 道题，这已经超过了绝大多数参加 AIME 的人类学生。

31.2 Test-Time Compute Scaling：一个改变范式的发现

31.2.1 传统范式：更大 = 更好

在 2024 年之前，提升 AI 能力的主流方法是 Scaling Law（缩放定律）：

性能 ∝ log(参数量) × log(训练数据) × log(计算量)

这个公式告诉我们：

• 想要模型更强？把参数从 7B 扩到 70B
• 想要回答更准？用更多数据训练
• 想要推理更好？用更多 GPU 训练更久

这个范式催生了"军备竞赛"：

• GPT-3: 175B 参数
• PaLM: 540B 参数
• GPT-4: 据传 1.8T 参数（MoE）
• Llama 3.1: 405B 参数

但这条路走到了瓶颈。参数量从 100B 翻倍到 200B，性能提升可能只有 10-20%。边际收益递减越来越严重。

31.2.2 新范式：更多思考时间 = 更好

2024 年 8 月，Google DeepMind 和 UC Berkeley 发表了一篇重要论文：

"Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters"

翻译过来就是：给模型更多推理时间，比给模型更多参数更有效。

这个发现的核心实验是这样的：

实验设置：
- 小模型：PaLM 2-S（较小）
- 大模型：PaLM 2-L（较大，约 14 倍参数）

结果：
- 大模型直接回答：性能 = X
- 小模型 + 额外推理计算：性能 > X

一个 14 倍小的模型，只要给它足够的推理时间，就能超过大模型的直接回答！

这颠覆了我们对 AI 的认知。以前我们认为"聪明"意味着"大脑容量大"，现在发现"思考得久"同样能提升表现。

31.2.3 具体效率提升

DeepMind 的研究发现，在数学推理任务上：

这个研究给 OpenAI 的 o1 和后来的所有推理模型奠定了理论基础：

核心公式：总性能 = 模型能力 × f(推理计算量)

其中 f 是一个增函数。这意味着，即使模型能力固定，增加推理计算量也能持续提升性能。

31.2.4 两条 Scaling 曲线

现在我们有两条提升性能的路径：

┌─────────────────────────────────────────────────────────────┐
│                    两种 Scaling 路径                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  性能 ▲                                                     │
│       │                          ╭── Train-time Scaling     │
│       │                      ╭───╯   (更大模型)              │
│       │                  ╭───╯                               │
│       │              ╭───╯                                   │
│       │          ╭───╯                                       │
│       │      ╭───╯                      ╭── Test-time        │
│       │  ╭───╯                      ╭───╯   Scaling          │
│       │──╯                      ╭───╯       (更多思考)        │
│       │                     ╭───╯                            │
│       │                 ╭───╯                                │
│       └─────────────────────────────────────────────▶ 计算量  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Train-time Scaling：增加训练计算量（更大模型、更多数据）

• 优点：推理时效率高
• 缺点：边际收益递减严重

Test-time Scaling：增加推理计算量（更长的思考链）

• 优点：对难题效果特别好
• 缺点：推理慢、成本高

最优策略是结合两者——用一个足够强的基础模型，在需要时给它更多思考时间。

31.3 OpenAI o1/o3：让模型学会思考

31.3.1 从 GPT-4 到 o1：发生了什么

OpenAI 在 2024 年 9 月发布 o1-preview，12 月发布 o3。这两个模型的核心创新是什么？

答案：自动化的 Chain-of-Thought（思维链）

还记得 CoT Prompting 吗？你给模型提示"Let's think step by step"，它就会一步步推理。但这需要人类主动提示。

o1/o3 的创新是：模型自己学会了什么时候需要深度思考，以及如何思考。

传统模型的回答流程：
问题 → 直接输出答案

o1/o3 的回答流程：
问题 → 生成思考链（隐藏）→ 基于思考链输出答案

31.3.2 "思考"过程是什么

当你问 o1 一个复杂问题时，它会在内部生成一个很长的推理过程。OpenAI 把这个过程叫做"reasoning trace"或"chain of thought"。

一个数学问题可能会触发这样的内部过程：

[用户问题]: 证明 √2 是无理数

[o1 内部思考 - 用户看不到]:
让我想想这个问题...
首先，我需要用反证法
假设 √2 是有理数，则 √2 = p/q，其中 p, q 互质
那么 2 = p²/q²
所以 p² = 2q²
这意味着 p² 是偶数
如果 p² 是偶数，那么 p 也是偶数（因为奇数的平方是奇数）
设 p = 2k
那么 (2k)² = 2q²
4k² = 2q²
2k² = q²
所以 q² 也是偶数，因此 q 也是偶数
但这与 p, q 互质矛盾
因此假设不成立，√2 是无理数
让我检验一下这个推理...
逻辑链完整，没有漏洞
好的，我可以给出答案了

[o1 输出 - 用户看到]:
√2 是无理数。证明如下：
（简洁版本的证明过程）

重要的是：用户看不到完整的思考过程。OpenAI 只展示一个"摘要"，完整的推理链是隐藏的。

31.3.3 o1/o3 的训练方法

OpenAI 没有公开 o1/o3 的完整训练细节，但根据公开信息和研究社区的分析，核心方法包括：

1. 大规模强化学习：用 RL 训练模型生成更好的推理链
2. 过程奖励模型（Process Reward Model, PRM）：不只看最终答案对不对，还看推理过程每一步是否正确
3. 搜索与验证：模型可能会生成多条推理路径，然后用验证器选择最好的

┌──────────────────────────────────────────────────────────────┐
│                    o1 训练框架猜测                            │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   问题 ─────▶ 基础模型 ─────▶ 推理链生成器                     │
│                                      │                       │
│                                      ▼                       │
│                              ┌───────────────┐               │
│                              │ 推理链 1      │               │
│                              │ 推理链 2      │               │
│                              │ 推理链 3      │               │
│                              │ ...          │               │
│                              └───────────────┘               │
│                                      │                       │
│                                      ▼                       │
│                              ┌───────────────┐               │
│                              │ 过程奖励模型   │               │
│                              │ (PRM)         │               │
│                              └───────────────┘               │
│                                      │                       │
│                                      ▼                       │
│                              选择最佳推理链                    │
│                                      │                       │
│                                      ▼                       │
│                              最终答案                         │
│                                                              │
└──────────────────────────────────────────────────────────────┘

31.3.4 o3 的惊人表现

2024 年 12 月，OpenAI 发布了 o3，性能再次飞跃：

特别值得注意的是 ARC-AGI 测试。这是一个专门设计来测试"真正智能"的 Benchmark，人类平均得分约 85%。o3 达到了 87.5%，首次在这个测试上超过人类平均水平。

31.3.5 o1/o3 的局限性

推理模型不是万能的，它有明显的短板：

1. 速度慢

• GPT-4o 回答一个问题：1-3 秒
• o1 回答同样的问题：10-60 秒

对于需要快速响应的应用（如聊天机器人），这可能无法接受。

直觉理解：想象你问一个人"1+1等于多少"，他却闭眼思考了 30 秒才回答。这种"过度思考"在简单场景下是浪费。

2. 成本高

• GPT-4o API：$2.5/1M input tokens,$10/1M output tokens
• o1-pro API：$150/1M input tokens,$600/1M output tokens

o1-pro 的成本是 GPT-4o 的 60 倍！

为什么这么贵？因为模型需要生成大量的"思考 tokens"，这些 tokens 用户看不到，但需要付费：

一次 o1 调用的实际 token 消耗：
├── 用户输入：200 tokens
├── 隐藏思考：3000-10000 tokens  ← 这部分用户看不到但要付费！
└── 最终输出：500 tokens

3. 对简单问题反而更差

Apple 的研究发现，当问题中加入无关信息时，o1 的表现会显著下降：

原问题：小明有 5 个苹果，小红给了他 3 个，小明现在有几个苹果？
o1 正确率：99%

修改后：小明有 5 个苹果。他的书包是蓝色的。小红给了他 3 个苹果。
        今天天气很好。小明现在有几个苹果？
o1 正确率：下降 17.5%

这表明 o1 可能过度依赖训练数据中的模式匹配，而非"真正理解"问题。

4. 不透明

OpenAI 隐藏了 o1 的推理过程，用户无法看到模型是如何得出答案的。这引发了关于可解释性和安全性的担忧。

更麻烦的是，OpenAI 明确禁止用户尝试揭示 o1 的思维链。如果你的 prompt 试图让模型暴露推理过程，可能会被警告甚至封号。

5. 安全风险

OpenAI 内部测试发现，o1-preview 在 CBRN（生化、放射、核）武器相关知识上达到了"中等风险"级别。它在生物武器问题上的表现"大多数时候超过了 PhD 科学家"。

这是一把双刃剑：更强的推理能力意味着更大的滥用风险。

31.4 DeepSeek-R1 深度解析：开源世界的逆袭

31.4.1 为什么 R1 如此重要

2025 年 1 月，DeepSeek 发布了 DeepSeek-R1，这可能是推理模型领域最重要的开源贡献。

R1 的性能与 OpenAI o1 相当，但有一个关键区别：完全开源，包括模型权重和训练方法。

31.4.2 核心突破：纯 RL 训练推理能力

DeepSeek 最震撼的发现是：不需要 SFT（监督微调），纯 RL 就能让模型学会推理——这一点在 R1-Zero 上得到了验证。

传统的训练流程是：

1. 预训练（学习语言）
2. SFT（学习对话格式和推理示范）
3. RLHF（对齐人类偏好）

但 DeepSeek 发现：

1. 预训练（学习语言）
2. 直接 RL（让模型自己发现推理策略）

他们用 DeepSeek-V3-Base 作为起点，只用强化学习，没有任何人工标注的推理示范数据，就训练出了 DeepSeek-R1-Zero。

注意：R1-Zero 是纯 RL 实验；最终发布的 DeepSeek-R1 则使用了少量 cold-start 数据 + 多阶段训练，以提升可读性和稳定性。

31.4.3 GRPO 算法

为了高效训练，DeepSeek 使用了 GRPO（Group Relative Policy Optimization）算法。

传统的 PPO（Proximal Policy Optimization）需要一个 Critic 模型来估计状态价值，这个 Critic 模型通常和 Policy 模型一样大，相当于要训练两个大模型。

PPO 训练的显存需求：
├── Policy 模型：671B 参数
└── Critic 模型：671B 参数（通常同样大）
    ─────────────────────
    总计：需要 2× 的显存！

GRPO 的创新：去掉 Critic 模型，用组内相对排名来估计基线。

# PPO 的价值估计（需要 Critic 模型）
advantage = reward - critic(state)

# GRPO 的价值估计（不需要 Critic）
group_rewards = [reward_1, reward_2, ..., reward_N]  # 同一 prompt 的多个回答
baseline = mean(group_rewards)
advantage_i = reward_i - baseline  # 相对于组平均的优势

直觉解释：PPO 就像让一个学生做题，然后找另一个老师来评判他做得好不好。GRPO 则是让学生做 N 道类似的题，通过对比他在不同题上的表现来判断哪些策略更好。不需要额外的"老师"（Critic 模型）。

这个看似简单的改变带来了巨大的计算节省：训练成本降低了近 50%。

GRPO 的具体做法：

1. 对于每个 prompt，生成 G 个不同的回答（G 通常是 8-16）
2. 用规则或奖励模型给每个回答打分
3. 计算每个回答相对于组平均分的"优势"
4. 用优势来更新策略，鼓励高于平均的行为

┌─────────────────────────────────────────────────────────────┐
│                    GRPO 算法示意                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Prompt: "证明 1+2+...+n = n(n+1)/2"                        │
│                      │                                      │
│                      ▼                                      │
│   ┌─────────────────────────────────────┐                   │
│   │  生成 8 个不同的回答                  │                   │
│   └─────────────────────────────────────┘                   │
│                      │                                      │
│     回答1  回答2  回答3  ...  回答8                           │
│      ↓      ↓      ↓          ↓                            │
│     分数    分数    分数        分数                          │
│     0.8    0.3    0.9         0.5                          │
│                      │                                      │
│     组平均分 = 0.625                                         │
│                      │                                      │
│     优势 = 分数 - 平均分                                      │
│     +0.175 -0.325 +0.275      -0.125                        │
│                      │                                      │
│     正优势 → 增加概率                                         │
│     负优势 → 降低概率                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

31.4.4 R1-Zero 的"涌现"：自我进化的推理能力

最令人惊叹的是 R1-Zero 在训练过程中展现的涌现行为。

没有人教它怎么推理，但经过几千步 RL 训练后，它自己学会了：

1. 自我验证

模型输出：所以答案是 42。
等等，让我检查一下...
第三步的计算可能有问题。
重新计算：3 × 14 = 42 ✓
好的，答案确实是 42。

2. 反思与回溯

这个思路似乎走不通。
让我换一个方法...
如果从另一个角度考虑这个问题...

3. 策略调整

这个问题直接算太复杂了。
让我先简化问题，考虑 n=1 的特殊情况...
找到规律后再推广到一般情况。

这些行为完全是模型自己发现的，不是人类设计或示范的。

┌──────────────────────────────────────────────────────────────┐
│               R1-Zero 训练过程中的性能变化                     │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  AIME 准确率                                                  │
│       ▲                                                      │
│   80% │                                    ╭───────────       │
│       │                              ╭─────╯                  │
│   60% │                        ╭─────╯                        │
│       │                  ╭─────╯                              │
│   40% │            ╭─────╯                                    │
│       │      ╭─────╯                                          │
│   20% │  ────╯    ← 开始出现 self-verification                 │
│       │──────────────────────────────────────────────▶ 训练步数 │
│       0    2000   4000   6000   8000   10000                  │
│                                                              │
│  训练初期：15.6%                                               │
│  训练后期：71.0% (pass@1)                                      │
│  Majority Voting：86.7%                                       │
│                                                              │
└──────────────────────────────────────────────────────────────┘

31.4.5 Cold-Start Data 的作用

虽然 R1-Zero 证明了纯 RL 可以产生推理能力，但它有两个问题：

1. 可读性差：推理过程混乱，包含很多无意义的重复
2. 语言混杂：在中英文之间随意切换

为了解决这些问题，DeepSeek 在正式的 R1 模型中加入了少量 Cold-Start Data：

Cold-Start Data 的作用：
├── 格式规范（清晰的推理步骤）
├── 语言一致性（避免混杂）
└── 更好的可读性

数量：几千条，相比预训练数据微不足道

这表明：RL 能让模型学会推理的"能力"，但需要少量示范来规范推理的"格式"。

31.4.6 开源的意义

DeepSeek-R1 的开源带来了几个重要影响：

1. 推理模型不再是黑盒 研究者可以研究推理模型内部的工作机制，理解它们如何"思考"。

2. 成本大幅降低 部署 R1 的成本远低于调用 o1 API。对于高频使用场景，节省可达 90%+。

3. 可定制化 可以针对特定领域（如医学推理、法律推理）进行微调。

4. 推动领域发展 开源让更多研究者能够在此基础上创新，加速整个领域的进步。

31.5 Kimi K1.5：长上下文的力量

31.5.1 Moonshot AI 的独特路径

2025 年 1 月，Moonshot AI（中国公司）发布了 Kimi K1.5，采用了与 DeepSeek 不同的技术路线。

K1.5 的核心特点：128K 上下文 + 强化学习。

┌──────────────────────────────────────────────────────────────┐
│                     不同推理模型的技术路线                     │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  OpenAI o1:      隐藏的 CoT + RL + 搜索验证                   │
│                                                              │
│  DeepSeek R1:    纯 RL + GRPO + 开源                         │
│                                                              │
│  Kimi K1.5:      128K 长上下文 + RL + 多模态                  │
│                                                              │
└──────────────────────────────────────────────────────────────┘

31.5.2 Long-Context Scaling 的创新

传统推理模型的上下文窗口有限：

• o1-preview: 128K tokens
• 实际有效使用: 远小于 128K

K1.5 的创新是将 RL 训练扩展到完整的 128K 上下文：

训练创新：
├── Partial Rollouts：复用之前轨迹的大部分，只重新生成新的部分
├── 在线镜像下降优化
├── 有效的采样策略
└── 长度惩罚机制

这使得模型能够：

1. 处理更长的推理链
2. 在推理过程中参考更多上下文信息
3. 进行更深入的多步推理

31.5.3 K1.5 的性能

K1.5 还支持多模态推理，能够同时处理文本和图像输入，这是 o1-preview 初版不具备的能力。

31.5.4 关键技术：Long-CoT 的 RL

K1.5 的核心贡献是提出了 Long-CoT RL 的数学框架：

传统 RL：
└── 短轨迹优化（几百 tokens）

K1.5 的 Long-CoT RL：
└── 超长轨迹优化（几万到十几万 tokens）
└── 部分轨迹复用（Partial Rollouts）
└── 渐进式奖励信号

实验发现：推理性能随上下文长度持续提升，这意味着更长的思考链带来更好的结果。

31.6 Gemini 2.5 Thinking：MoE 与推理的结合

31.6.1 Google 的思考模型

2025 年 3 月，Google 发布了 Gemini 2.5 Pro，其中包含"Thinking"模式。这是 Google 对推理模型的回应。

Gemini 2.5 的独特之处：

1. MoE 架构：使用 Mixture-of-Experts，推理时只激活部分参数
2. 可控的 Thinking Budget：开发者可以控制模型"思考"多久
3. 超长上下文：支持 1M tokens 的上下文窗口

31.6.2 Thinking Budget 控制

这是 Gemini 2.5 的一个实用创新：

# 开发者可以设置 thinking budget
response = gemini.generate(
    prompt="证明费马大定理",
    thinking_budget=24576  # 最大 24576 tokens 的思考
)

# 或者关闭思考（快速响应）
response = gemini.generate(
    prompt="今天天气怎么样",
    thinking_budget=0  # 不思考，直接回答
)

这带来了灵活的成本-性能权衡：

31.6.3 性能对比

Gemini 2.5 Pro 在多个 Benchmark 上领先 o1，特别是在需要广泛知识的测试（如 Humanity's Last Exam）上。

31.6.4 Deep Think 模式

2025 年晚些时候，Google 推出了 Gemini 2.5 Deep Think，这是一个增强版的推理模式，专为极其复杂的数学和编程问题设计。

Deep Think 在 2025 年国际数学奥林匹克（IMO）上达到了铜牌水平，这是 AI 在顶级数学竞赛中的又一个里程碑。

31.7 蒸馏：让小模型也能推理

31.7.1 蒸馏的动机

推理模型有一个问题：太大了。

DeepSeek-R1 基于 DeepSeek-V3（约 671B 参数的 MoE），即使只激活部分参数，也需要大量显存。对于很多应用场景，这不现实。

部署 DeepSeek-R1 的硬件需求：
├── 显存：200GB+（需要 8×A100 80GB 或类似配置）
├── 成本：单卡 A100 约 <InlineMath math="10,000，8 卡=" />80,000+
└── 功耗：每卡 400W，8 卡 = 3.2kW

对于大多数公司和个人开发者，这个门槛太高了。

解决方案：知识蒸馏（Knowledge Distillation）。

蒸馏的思路：
大模型（教师）    →    小模型（学生）
   671B                  7B

教师模型的推理链      →    学生模型学习模仿

类比：这就像让一个数学博士把解题思路写成详细的解题步骤，然后让高中生照着学。高中生可能理解不了博士的全部思考过程，但能学会很多解题技巧。

31.7.2 DeepSeek 的蒸馏模型矩阵

DeepSeek 开源了一系列蒸馏模型：

几个惊人的数据：

• 7B 模型 55.5% 的 AIME 成绩，超过了 QwQ-32B-Preview（一个专门的开源推理模型）
• 32B 模型超过了 OpenAI o1-mini 的多数表现

31.7.3 蒸馏 vs 直接 RL：哪个更好？

DeepSeek 做了一个有趣的对比实验：

结论：蒸馏比直接 RL 更便宜，效果还更好。

这是因为：

1. 大模型通过 RL 发现的推理策略更优
2. 小模型可以直接学习这些策略，不需要自己探索
3. 蒸馏只是 SFT，计算成本远低于 RL

31.7.4 蒸馏的实际应用

蒸馏模型让推理能力变得"平民化"：

部署需求对比：

DeepSeek-R1 (完整版)
├── 显存需求：~200GB（需要多卡）
├── 推理速度：相对较慢
└── 部署成本：高

R1-Distill-Qwen-7B
├── 显存需求：~14GB（单卡 RTX 4090）
├── 推理速度：快
└── 部署成本：低

R1-Distill-Qwen-1.5B
├── 显存需求：~3GB（笔记本 GPU 或 CPU）
├── 推理速度：很快
└── 部署成本：几乎为零

对于边缘设备、个人电脑、小型服务器，蒸馏模型是唯一可行的选择。

31.7.5 蒸馏的局限性

蒸馏不是万能的，它有一些固有的限制：

1. 能力上限

学生模型的能力不可能超过教师模型。如果教师在某类问题上不行，学生也不会更好。

2. 信息损失

671B 到 7B，参数量减少了 99%。必然有大量信息丢失。蒸馏模型在最难的问题上表现会明显下降。

3. 推理链质量

蒸馏模型学的是"模仿"推理链，而非"理解"推理。在遇到训练分布外的问题时，可能会生成看起来合理但实际错误的推理过程。

蒸馏模型的典型错误模式：
├── 推理步骤看起来流畅
├── 每一步看起来都有道理
└── 但最终答案是错的
    （因为模型在模仿格式，而非真正理解）

31.8 推理模型的未来

31.8.1 推理成本问题

推理模型面临的最大挑战是成本：

每次请求的成本对比（估算）：

问题：解一道 AIME 难度的数学题

GPT-4o
├── 输入：~200 tokens
├── 输出：~500 tokens
├── 成本：~$0.01
└── 时间：2 秒

o1
├── 输入：~200 tokens
├── 内部思考：~5000 tokens（用户看不到，但要付费）
├── 输出：~500 tokens
├── 成本：~$0.50
└── 时间：30 秒

成本差异：50 倍！

对于需要大量推理的应用（如数学教育平台），使用 o1 的成本可能无法承受。

31.8.2 何时使用推理模型

推理模型不是"更好的 GPT-4"，而是一种不同的工具：

31.8.3 推理模型的应用场景

最适合的场景：

1. 数学竞赛和证明：需要多步推理，验证逻辑
2. 复杂编程挑战：算法设计，边界条件处理
3. 科学研究：假设验证，实验设计
4. 法律/医学分析：需要仔细推理和交叉验证

不适合的场景：

1. 实时对话：延迟太高
2. 简单任务：杀鸡用牛刀
3. 创意写作：推理模型可能过于"死板"
4. 大规模并发：成本太高

31.8.4 未来发展方向

推理模型的发展正在几个方向推进：

1. 效率优化

• 更短的推理链达到同样效果
• 更好的推理链剪枝
• 自适应的思考深度

2. 多模态推理

• 图像 + 文本联合推理
• 代码 + 数学联合推理
• 真实世界场景理解

3. 工具使用

• 推理过程中调用计算器
• 搜索引擎辅助
• 代码执行验证

4. 更小的推理模型

• 1B-3B 的推理模型
• 手机端部署
• 实时推理

31.9 本章要点

31.9.1 核心概念回顾

1. 推理模型的突破：

   • GPT-4o 在 AIME 2024 上只有 12%，o1 达到 83%，o3 达到 96.7%
   • 这不是渐进式改进，而是范式转变

2. Test-Time Compute Scaling：

   • 传统范式：更大模型 = 更好性能
   • 新范式：更多思考时间 = 更好性能
   • 小模型 + 更多推理时间 > 大模型直接回答

3. OpenAI o1/o3：

   • 自动化的 Chain-of-Thought
   • 隐藏的推理过程 + 过程奖励模型
   • 成本高但性能强

4. DeepSeek-R1：

   • R1-Zero 证明纯 RL 可涌现推理能力；R1 加入 cold-start 数据提升可读性
   • GRPO 算法降低训练成本
   • 完全开源，推动领域发展

5. Kimi K1.5：

   • 128K 长上下文 + RL
   • Long-CoT 的数学框架
   • 多模态支持

6. Gemini 2.5 Thinking：

   • MoE + Thinking 结合
   • 可控的 Thinking Budget
   • 1M 上下文窗口

7. 知识蒸馏：

   • 大模型推理能力可以蒸馏到小模型
   • 7B 蒸馏模型超过 32B 普通模型
   • 蒸馏比直接 RL 更高效

31.9.2 性能对比总览

31.9.3 关键洞察

洞察 1：推理能力可以通过 RL 从模型内部"涌现"，不需要人工示范。

洞察 2：给模型更多思考时间，比堆参数更有效率。

洞察 3：大模型的推理能力可以蒸馏到小模型，让推理变得"平民化"。

洞察 4：推理模型是工具，不是银弹。选择合适的模型比选择"最强"的模型更重要。

延伸阅读

1. DeepSeek-R1 技术报告：https://arxiv.org/abs/2501.12948
2. Scaling LLM Test-Time Compute 论文：https://arxiv.org/abs/2408.03314
3. OpenAI o1 官方介绍：https://openai.com/index/learning-to-reason-with-llms/
4. Kimi K1.5 GitHub：https://github.com/MoonshotAI/Kimi-k1.5
5. Gemini 2.5 技术报告：https://storage.googleapis.com/deepmind-media/gemini/gemini_v2_5_report.pdf

下一章预告

下一章我们将探讨后 Transformer 架构——随着序列长度增长，Attention 的 O(n^2) 复杂度成为瓶颈。Mamba 等状态空间模型（SSM）正在挑战 Transformer 的统治地位。我们将深入分析这些新架构的原理、优势和局限性。