测试时计算与推理模型深度解析：从o1到o3到DeepSeek-R1的技术演进（2026最新）
一句话先说在前面：以前的AI是"快问快答型选手"，靠考前疯狂刷题（训练时计算）拿分；2024年OpenAI o1横空出世后，AI学会了"考场深度思考"------多花几分钟验算检查（测试时计算），难题正确率直接起飞。本文带你从概念、演进史、技术原理、代码实战到2026年最新进展，彻底搞懂这套正在重塑AI行业的新范式。
目录
一、前言：为什么o1出来后整个AI圈都疯了？
二、什么是测试时计算（Test-Time Compute）？
三、推理模型演进史：从o1到o3到DeepSeek-R1再到2026
四、技术原理深度拆解：CoT、Self-Consistency、ToT、PRM、GRPO
五、推理模型 vs 普通模型：什么时候该用？
六、测试时计算的最优分配：花多少算力"思考"才划算？
七、代码实战：CoT、Self-Consistency、API调用
八、性能对比：推理模型在各benchmark的表现
九、成本分析：推理模型的token消耗与优化策略
十、面试高频Q&A（10题）
十一、总结与展望
一、前言：为什么o1出来后整个AI圈都疯了？
1.1 那个改变一切的9月
2024年9月12日，OpenAI悄无声息地放出了一个叫"o1"的模型。没有盛大的发布会，没有Sam Altman的长篇演讲，就是一篇技术博客+一个ChatGPT里的新选项。
但整个AI圈炸了。
为什么？因为o1做了一件以前所有大模型都没做到的事：它在回答之前，会先"想一想"。
你可能会说：扯淡吧，GPT-4不也会推理吗？我让它做数学题它也能做对啊。
区别在于------以前的GPT-4做数学题，就像一个学生拿到卷子，看完题目直接写答案，中间过程全靠"直觉"（也就是模型权重里压缩的模式匹配）。简单的题没问题，但遇到需要多步推导、需要回头检查、需要尝试不同思路的难题，它就会翻车。
而o1呢？它会在给出最终答案之前，先在内部生成一大段"思考过程"（Chain-of-Thought），自己跟自己对话，尝试不同解法，发现走不通就换一条路，最后才把答案交给你。
打个比方：
以前的GPT-4 = 一个考前刷了10000道题的学生，上了考场全凭肌肉记忆秒答
o1 = 一个考前刷了10000道题的学生，上了考场遇到难题会先在草稿纸上列步骤、验算、检查，确认无误才交卷
哪个更靠谱？显然是后者。
1.2 这件事为什么重要到"炸圈"？
因为这直接戳破了一个当时AI圈的普遍焦虑：scaling law是不是要撞墙了？
2023年到2024年中，业界的共识是"大力出奇迹"------只要模型参数更大、训练数据更多、训练算力更多，模型就会更强。但问题来了：高质量数据快用完了，参数从70B涨到405B（Llama 3.1 405B），收益却在递减。砸10倍的训练算力，可能只换来5%的提升。
o1给出了另一条路：与其在训练时砸10倍算力，不如在推理（测试）时多花点算力让模型"想想"。
这篇博客里的核心发现（后来被业界反复引用）：在复杂数学题上，推理阶段多花10倍算力带来的提升，≈训练阶段多花100倍算力带来的提升。
你品，你细品。
这就好比：考前多刷100道题（训练时计算），不如考试时多想5分钟（测试时计算）。
当然这个类比不完全准确------两者的关系不是"非此即彼"而是"相辅相成"。但它确实打开了一扇新大门：原来推理阶段的算力投入，也是一个可以scale的维度。
1.3 一年半后的2026：推理已成标配
快进到2026年7月。OpenAI刚刚发布了GPT-5.6，旗舰模型代号"Sol"，带着两个新能力登场：
max reasoning effort（最大推理强度）：让Sol在深度推理时不会被主动截断，想多久想多久
ultra mode（超模式）：让模型调用多个子Agent并行处理，把复杂任务拆解成子任务分头攻克
而在这之前，o3、o4-mini、DeepSeek-R1、Gemini 2.5 Thinking、Claude Thinking Mode、Kimi K1.5、Qwen3......几乎所有主流大模型都内置了"思考"能力。
推理模型已经从"新奇事物"变成了"行业标配"。就像2023年所有手机厂商都在卷拍照，2026年所有AI厂商都在卷"思考"。
我的判断：到2026年底，"推理模型"这个词可能会逐渐消失------因为所有模型都会默认具备推理能力，就像现在没人会特意说"我的手机能拍照"一样。但"测试时计算"这个概念会越来越重要，因为它是控制成本和性能的关键旋钮。
二、什么是测试时计算（Test-Time Compute）？
2.1 一句话定义
Test-Time Compute（TTC，测试时计算）：在模型推理（inference）阶段，通过增加计算量来提升模型表现的技术总称。
注意三个关键词：
推理阶段：不是训练阶段，是模型已经训练好了、你在用它回答问题的时候
增加计算量：不是改模型权重，是让模型多生成一些中间内容、多跑几次、多搜索一下
提升表现：目标是在不改模型的前提下，让答案更准确、更靠谱
2.2 跟训练时计算的根本区别
这是理解整个推理模型浪潮的核心。我用一个表格说清楚：
表2-1：训练时计算 vs 测试时计算
维度 训练时计算（Training Compute） 测试时计算（Test-Time Compute）
发生在什么时候 模型出厂前，训练阶段 模型出厂后，推理/使用阶段
改变什么 改变模型权重（参数） 不改权重，只改推理过程
类比 学生考前刷题、上课学习 学生考试时多花时间检查验算
成本特点 一次性投入巨大，但分摊到每次使用很便宜 每次使用都要额外花算力
效果特点 提升模型"知识储备"和"基础能力" 提升模型在"具体题目"上的表现
可控性 训练完就固定了，不能动态调整 可以根据题目难度动态调整投入
scaling效果 边际收益递减（数据用完了） 在某些任务上收益仍很可观
谁在投入 模型厂商（OpenAI、DeepSeek等） 使用者（你调用API时付的钱）
最关键的洞察：训练时计算是"一锤子买卖"------你花了10亿美金训练一个模型，它就固定在那个水平了，没法升级（除非重新训练）。而测试时计算是"按需付费"------简单问题少想，复杂问题多想，灵活度极高。
2.3 再用一个生活类比彻底搞懂
想象你在准备一场数学考试。你有两条路提升成绩：
路线A（训练时计算）：考前疯狂刷题。你刷了10000道题，掌握了各种题型套路。这就像模型训练------投入大量算力学习，把知识"固化"到脑子里（权重里）。
路线B（测试时计算）：考试时认真审题。每道题你先列步骤，算完再验算一遍，发现不对就换个思路重来。这就像推理模型------在"使用"阶段多花时间和算力来确保答案正确。
路线A的局限：刷题是有天花板的。你刷了10000道题之后，再刷10000道，提升可能就很小了------因为该会的套路都见过了。这就像训练时scaling law边际递减。
路线B的优势：考试时多想5分钟，可能让你从"凭直觉写了个错误答案"变成"验算发现错了，改对了"。这种提升对难题特别明显。
但路线B也有代价：你每道题都想5分钟，一场考试只能做12道题。如果考的是简单题海战术，反而考不过"秒答型选手"。这就是为什么推理模型不是万能的------简单任务用它，纯粹浪费时间和钱。
2.4 测试时计算的几种主要形式
测试时计算不是单一技术，而是一大家子。我按"计算量从小到大"排一下：
Chain-of-Thought（CoT）：让模型"一步一步想"。最基础的形式，计算量增加适中。
Self-Consistency：让模型用CoT生成多个答案，投票取多数。计算量×N。
Best-of-N Sampling：生成N个答案，用奖励模型挑最好的。计算量×N + 打分。
Tree of Thoughts（ToT）：树状搜索，每一步生成多个分支，剪枝保留好的。计算量×分支数×深度。
Monte Carlo Tree Search（MCTS）：更高级的搜索，像AlphaGo下棋那样。计算量最大。
内化推理（如o1/o3/DeepSeek-R1）：把"思考"训练进模型里，推理时自动生成思考链。计算量取决于思考链长度。
前5种是"外挂式"的------你可以拿任何普通模型（GPT-4、Llama等）套上去用。第6种是"内化式"的------模型本身就被训练成会思考的，这是o1开创的新范式。
这里有个微妙但重要的区别：CoT prompting（你在prompt里加一句"let's think step by step"）是最原始的测试时计算，它只是改变了模型的输出行为，并没有真正"增加"太多计算。而推理模型（o1/o3/DeepSeek-R1）是把"思考"训练进了模型，推理时模型会自主生成大量内部思考token，这才是真正大规模的测试时计算投入。后面我会详细讲。
三、推理模型演进史：从o1到o3到DeepSeek-R1再到2026
3.1 演进全景图
先上一张总览表，让你对整个推理模型的发展脉络一目了然：
表3-1：推理模型演进史（2024.9 - 2026.7）
时间 模型 厂商 关键突破 意义
2024.09 o1 / o1-preview OpenAI 首个内化CoT的推理模型 开创推理模型范式
2024.12 o1正式版 / o1-mini OpenAI 完整版发布，成本优化 推理能力稳定可用
2025.01 DeepSeek-R1 / R1-Zero DeepSeek 纯RL训练推理能力，开源 打破OpenAI垄断，开源界狂欢
2025.01 o1-pro OpenAI 高可靠性推理 企业级应用
2025.02 o3-mini OpenAI 轻量推理模型，性价比高 推理模型走向大众
2025.03 Gemini 2.5 Thinking Google 原生多模态推理 谷歌加入推理战局
2025.03 Claude Thinking Mode Anthropic 可控的思考开关 给用户思考控制权
2025.04 o3 / o4-mini OpenAI 200K上下文，多模态推理 推理模型全面成熟
2025.05 Kimi K1.5 月之暗面 长上下文推理 国产推理模型崛起
2025.06 Qwen3（含思考模式） 阿里 思考/非思考模式切换 开源+双模式创新
2025下半年 Seed-Thinking-v1.5 字节 200B参数超越R1 国产推理模型持续进化
2026.07 GPT-5.6（Sol） OpenAI max reasoning + ultra多智能体 推理进入多Agent时代
3.2 第一阶段：o1破冰（2024年9月）
2024年9月12日，OpenAI发布o1。这是第一个真正意义上的"推理模型"------它不是靠prompt trick让模型"想一想"，而是通过强化学习把"思考"训练进了模型本身。
o1的核心创新：
内化Chain-of-Thought：模型学会了在回答前自动生成思考过程，不需要用户在prompt里写"let's think step by step"
强化学习训练：用RL让模型学会"什么样的思考路径能导向正确答案"
思考token：模型会生成大量内部思考内容（这些内容可以选择性地展示给用户）
o1的表现：
数学竞赛（AIME 2024）：83.3%（GPT-4o只有13.4%）
编程竞赛（Codeforces）：89百分位（GPT-4o只有11百分位）
博士级科学问答（GPQA）：78.0%（GPT-4o只有56.1%）
这几个数字当时看简直是"外星科技"。尤其是AIME从13.4%到83.3%，这不是提升，这是降维打击。
但o1也有明显短板：
慢。一个简单问题可能要想30秒到几分钟
贵。思考token也算钱，成本是GPT-4o的3-5倍
不擅长简单任务。你问它"今天天气怎么样"，它也可能在那"思考"半天（早期版本）
知识截止日期老。o1的知识截止在2023年10月
3.3 第二阶段：开源逆袭------DeepSeek-R1（2025年1月）
o1发布后，OpenAI对技术细节守口如瓶，只放了一篇博客，连论文都没发。业界都在猜：到底怎么训练的？
2025年1月20日，DeepSeek放了个大招：DeepSeek-R1，不仅开源了模型权重，还发了详细论文，把训练方法全盘托出。
DeepSeek-R1的两个版本：
DeepSeek-R1-Zero：直接在基础模型（DeepSeek-V3）上做纯RL，不经过任何SFT（监督微调）。结果发现，模型自己"涌现"出了推理能力------它会自发地产生反思、验证、换思路等行为。这证明了一个震撼性结论：推理能力可以纯靠RL激励出来，不需要人类标注的推理过程数据。
DeepSeek-R1：在R1-Zero基础上，加入了"冷启动"SFT数据（人工构造的高质量推理样本），再做RL。效果比R1-Zero更好更稳定，最终性能追平甚至部分超越o1。
R1的关键技术------GRPO算法：
传统的RL（如PPO）需要训练一个跟策略模型差不多大的"价值模型"（critic），显存翻倍。GRPO（Group Relative Policy Optimization）巧妙地用"组内相对奖励"替代了价值模型，省掉了一半显存，让大模型RL变得可行。
DeepSeek-R1的意义远超技术本身。它向全世界证明了：①推理模型不是OpenAI的魔法，是可以复现的；②开源社区一样能做出顶级推理模型；③纯RL训推理这条路是走得通的。R1发布后，HuggingFace上一周内就出现了几十个基于R1的微调模型，开源界彻底沸腾。
3.4 第三阶段：o3与轻量化（2025年2-4月）
OpenAI显然被DeepSeek刺激到了。2025年加速了迭代节奏：
o3-mini（2025年2月）：
主打性价比，成本远低于o1
支持"reasoning effort"三档调节（low/medium/high）
在数学和编程上超越o1-mini
关键：让推理模型变得"日常可用"
o3与o4-mini（2025年4月16日）：
o3：完整版推理模型，支持200K上下文窗口，多模态（能看图推理）
o4-mini：轻量版，速度快成本低，同样支持多模态
编程能力飞跃：o3在软件工程基准SWE-bench上表现强劲
关键突破：o4-mini能在思考过程中"使用工具"------它可以在推理链里调用搜索、代码执行等工具，然后再继续思考。这是推理模型从"纯脑力"走向"脑力+工具"的重要一步
3.5 第四阶段：百花齐放（2025年中-下半年）
2025年中开始，推理模型进入"人手一个"的阶段：
Gemini 2.5 Thinking（2025年3月）：Google的推理模型，原生多模态，思考过程可视化
Claude Thinking Mode：Anthropic给Claude加了"思考开关"，用户可以控制是否启用深度思考，还能看到思考摘要
Kimi K1.5：月之暗面的推理模型，长上下文推理能力强
Qwen3：阿里通义千问，创新性地支持"思考/非思考"双模式切换------简单问题用非思考模式秒答，难题切思考模式
Seed-Thinking-v1.5：字节豆包，200B参数，在多个benchmark上超越满血DeepSeek-R1
这个阶段的特征：
推理不再是OpenAI独有，成了行业标配
各家开始卷"可控性"------让用户能控制思考的强度
开源模型持续进化，缩小与闭源的差距
多模态推理开始成熟
3.6 第五阶段：2026最新------GPT-5.6与多智能体推理
2026年7月9日，OpenAI正式全面发布GPT-5.6系列，旗舰模型代号"Sol"。这是截至本文写作时（2026年7月）推理模型的最新进展。
GPT-5.6的两个核心新能力：
-
max reasoning effort（最大推理强度）：
以前的推理模型有一个问题------为了控制成本和延迟，思考过程往往会被"截断"。你让它想一个特别复杂的问题，它想到一半就被掐了，被迫给出一个不够充分的答案。max reasoning effort模式允许Sol在深度推理时不被主动截断，给它足够的时间"想到底"。简单说就是：以前是"限时考试"，现在是"开卷考试不限时"。
-
ultra mode（超模式）：
这是更有想象力的创新。ultra mode让Sol能够调用多个子Agent并行处理------把一个复杂任务拆解成多个子任务，分发给不同的子Agent同时干，最后汇总结果。这相当于从"一个人深度思考"进化到了"一个团队协作解题"。
举个例子：你让Sol"帮我分析这三家公司的财报，对比它们的AI战略，写一份投资建议报告"。在ultra mode下，Sol可能会：①派子Agent A去分析公司1的财报；②派子Agent B去分析公司2的财报；③派子Agent C去分析公司3的财报；④三个子Agent并行干完后，主Agent汇总对比、写报告。这就是"测试时计算"的升级版------不只是单个模型多想想，而是多个模型协同干。
GPT-5.6的benchmark表现（据公开信息）：
在编码、生物学、网络安全等核心基准测试中均刷新最佳纪录
评估时会看不同reasoning effort下的表现------区分"简单问题快速答"和"复杂任务多想会"
2026年推理模型的整体趋势：
推理能力全面内置化：GPT-5.6已经不再分"推理模型"和"普通模型"了，推理是默认能力，用户通过reasoning effort调节强度
多智能体协同推理：ultra mode代表了从"单兵思考"到"团队协作"的范式转变
思考token的压缩与优化：业界在研究如何让模型"想得更精炼"，减少无用的思考token，降低成本
自适应思考分配：模型自己判断"这道题需要想多久"，简单题快答，难题深想
国产开源持续追进：DeepSeek、Qwen、Kimi等持续迭代，在部分维度已与闭源旗舰持平
四、技术原理深度拆解：CoT、Self-Consistency、ToT、PRM、GRPO
这一章是全文最硬核的部分。我会把推理模型背后的几大核心技术拆开揉碎了讲，配上类比和伪代码，确保你能真正理解而不是背概念。
4.1 Chain-of-Thought（CoT）：让模型"一步一步想"
4.1.1 什么是CoT
CoT是最基础也最经典的测试时计算技术。核心思想极其简单：让模型在给出最终答案前，先输出中间推理步骤。
最原始的CoT------Zero-shot CoT：
你只要在prompt末尾加一句魔法咒语：
让我们一步一步地思考。
Let's think step by step.
模型就会开始输出推理过程，而不是直接蹦答案。
举个例子：
不用CoT：
Q: 一个班有32个学生，男生比女生多4人，男生有多少人？
A: 18人。
（模型可能直接猜，容易错）
用CoT：
Q: 一个班有32个学生，男生比女生多4人，男生有多少人？
A: 让我们一步一步地思考。
设女生有x人，则男生有x+4人。
总人数：x + (x+4) = 32
2x + 4 = 32
2x = 28
x = 14
所以女生14人，男生14+4=18人。
答案是18人。
4.1.2 为什么CoT有效
这是个好问题。为什么仅仅加一句"一步一步想"，模型就能做对更多题？
原因1：展开计算图。大模型本质上是next-token预测器，每次只生成一个token。直接让它输出最终答案，相当于让它在一个前向传播里完成所有计算。而CoT让模型把推理过程"展开"成多步，每步只需要做简单计算，降低了单步难度。
类比：让你心算 23×17，你可能算不准。但给你纸笔，让你列竖式一步一步算，肯定没问题。CoT就是给模型"纸笔"。
原因2：注意力机制的局限。Transformer的注意力是"看前面所有token"来预测下一个。如果直接从问题跳到答案，中间的推理步骤全靠模型在"脑子里"一次性完成。CoT把推理步骤显式写出来，变成了后续token可以attend到的上下文，相当于"外部记忆"。
原因3：训练数据分布。训练数据里，推理过程往往是"一步一步"的（数学课本、解题过程等）。CoT激活了模型在训练中学到的这种"分步推理"模式。
4.1.3 Few-shot CoT
更有效的做法是在prompt里给几个带推理过程的示例：
Q: 小明有5个苹果，吃了2个，又买了3个，现在有几个？
A: 小明原来有5个，吃了2个剩5-2=3个，又买了3个，3+3=6个。答案是6个。
Q: 一本书有120页，小红每天看15页，看了4天，还剩多少页？
A: 小红4天看了15×4=60页，总共120页，还剩120-60=60页。答案是60页。
Q: 你的实际问题
A:
模型会模仿示例的推理风格来解答新问题。
4.1.4 CoT的局限
CoT虽然有效，但有明显局限：
线性思维：CoT是"一条路走到黑"，走错了不会回头。如果第一步推理就错了，后面全错。
无法探索：不会尝试不同解法、不会比较哪种思路更好。
依赖prompt：需要用户记得加"step by step"，模型本身不会主动推理（除非是推理模型）。
这些局限正是后续技术（Self-Consistency、ToT等）要解决的。
4.2 Self-Consistency：多次采样取多数
4.2.1 核心思想
Self-Consistency（自洽性）是CoT的进阶版。核心思路：同一个问题，让模型用CoT生成N个不同的推理路径和答案，然后投票，选出现次数最多的答案。
为什么有效？因为正确的推理路径可能有多条，但它们都会导向同一个正确答案。而错误的推理路径往往各错各的，答案五花八门。所以"多数票"大概率是正确答案。
类比：你拿一道数学题问10个同学。如果8个人算出来是18，2个人算出来是16，你信哪个？当然信18------因为8个人独立算出同一个答案，说明这个答案大概率是对的（即使你不知道他们的解题过程对不对）。
4.2.2 算法步骤
- 对同一个问题，用温度采样（temperature > 0）生成N条不同的CoT推理路径
- 从每条路径中提取最终答案
- 对所有答案进行投票
- 返回出现次数最多的答案
4.2.3 代码逻辑伪代码
def self_consistency(question, model, n=5):
answers = \[\]
for i in range(n):
每次用不同的随机种子生成不同的推理路径
response = model.generate(
prompt=question + "\n让我们一步一步地思考。",
temperature=0.7, # 高温度增加多样性
seed=i
)
answer = extract_answer(response) # 从回答中提取最终答案
answers.append(answer)
# 投票
from collections import Counter
vote = Counter(answers)
return vote.most_common(1)[0][0] # 返回票数最多的答案4.2.4 代价与权衡
Self-Consistency的代价很明显：计算量是单次CoT的N倍。N越大，准确率越高，但成本也越高。
研究表明，N从1到5，准确率提升明显；N从5到10，提升放缓；N>20之后，边际收益很小。实际应用中N通常取5-10。
Self-Consistency是"以量取胜"的典型------不追求单次推理多聪明，而是靠多次推理的"群体智慧"。这跟人类做难题的策略很像：不确定的时候，多算几遍，看看是不是每次都得到同一个答案。
4.3 Tree of Thoughts（ToT）：树状搜索
4.3.1 核心思想
CoT是"一条线"（线性推理），Self-Consistency是"多条平行的线"（多次独立推理），而Tree of Thoughts是"一棵树"------在推理的每一步，都生成多个可能的下一步，评估哪个好，继续往下走，走不通就回溯。
类比：
CoT = 走迷宫只走一条路，走错了也不回头
Self-Consistency = 派5个人各走各的迷宫，看谁先到终点
ToT = 走迷宫时，每个路口都试探几个方向，发现死胡同就退回来换路走
ToT显然最接近人类解决复杂问题的方式。
4.3.2 算法步骤
- 将问题分解为若干"思考步"（thought steps）
- 在每一步，生成k个可能的候选思考（分支）
- 用模型自身评估每个候选思考的"前景"（打分）
- 保留得分最高的b个分支（剪枝beam search）
- 对保留的分支继续生成下一步
- 重复直到达到目标或最大深度
- 回溯：如果某条路走不通（评分太低），退回上一步尝试其他分支
4.3.3 ToT vs CoT vs Self-Consistency
表4-1：三种推理策略对比
维度 CoT Self-Consistency Tree of Thoughts
结构 线性（一条链） 多条平行链 树状（有分支和回溯）
能否回溯 不能 不能（但靠多次采样弥补） 能
计算量 1× N× 最大（分支数×深度）
适用场景 中等难度推理 有明确答案的推理 需要探索/规划的复杂任务
实现复杂度 极简 简单 复杂（需要评估函数）
典型任务 数学计算 数学竞赛题 创意写作、24点游戏、规划
4.3.4 ToT的代价
ToT是最"烧算力"的测试时计算方式之一。一棵深度为d、每步k个分支、保留b个beam的搜索树，总计算量约为 O(b × k × d) 次模型调用。对于复杂问题，可能需要几十到上百次模型调用。
所以ToT目前主要用于研究场景，在实际产品中很少直接用------太贵了。但它的思想（搜索+评估+回溯）被推理模型以更高效的方式"内化"了。
4.4 Best-of-N Sampling与Process Reward Model（PRM）
4.4.1 Best-of-N Sampling
Best-of-N是Self-Consistency的"豪华版"。区别在于：Self-Consistency靠投票选答案（只看最终答案是否一致），而Best-of-N靠一个奖励模型来评估每条推理路径的质量，选最优的。
- 生成N条推理路径
- 用奖励模型对每条路径打分
- 选分数最高的那条路径的答案
奖励模型打的是"整体分"------评估整条推理路径好不好。
4.4.2 Process Reward Model（PRM）：过程奖励模型
PRM是Best-of-N的进一步精细化。区别在于：普通奖励模型（Outcome Reward Model, ORM）只看"最终答案对不对"，而PRM看的是"推理过程的每一步对不对"。
类比：
ORM = 老师只看你的最终答案对不对，对了100分，错了0分
PRM = 老师逐步批改你的解题过程，第一步对了给分，第二步错了扣分，即使最终答案碰巧对了，过程有问题也扣分
PRM的优势：
更精细的反馈：能定位推理过程中具体哪一步出了问题
更适合搜索：在ToT式的搜索中，PRM可以在每一步评估分支质量，指导搜索方向
更适合RL训练：可以作为强化学习的奖励信号，训练模型生成更好的推理过程
PRM的训练：需要大量标注数据------人类专家对推理过程的每一步标注"对/错/不确定"。OpenAI在2023年发了一篇论文（"Let's Verify Step by Step"），标注了80万步人类数学推理过程，训练了PRM，在MATH数据集上大幅超越了ORM。
PRM的挑战：
标注成本极高（逐步标注比只标最终答案贵10倍以上）
什么算"正确的推理步骤"本身就很主观
对于开放性任务（写作、规划），很难定义"过程对错"
PRM是o1/o3这类推理模型背后的关键技术之一。推理模型在训练时，PRM（或类似的process-level奖励信号）帮助模型学会"什么样的思考步骤是好的"。不过o1的具体训练细节OpenAI没有公开，DeepSeek-R1用的是另一种思路（下面讲）。
4.5 GRPO算法：DeepSeek-R1的RL训练秘诀
4.5.1 为什么需要GRPO
强化学习训练大模型，传统方法是PPO（Proximal Policy Optimization）。但PPO有个大问题：需要训练一个跟策略模型差不多大的"价值模型"（value function / critic）。
什么意思？PPO里有两个模型：
Actor（策略模型）：就是你要训练的大模型，负责生成action（生成token）
Critic（价值模型）：评估"当前状态有多好"，给Actor提供baseline
问题在于：如果你的Actor是一个671B参数的大模型，Critic也得差不多大才能准确评估。这就意味着显存需求翻倍，训练成本直接×2。
对于DeepSeek这种要训671B模型的公司来说，这个开销太大了。于是他们提出了GRPO。
4.5.2 GRPO的核心创新
GRPO（Group Relative Policy Optimization）的核心思想：用"组内相对奖励"替代价值模型。
具体做法：
对同一个问题，让模型生成一组（group）G个回答（比如G=64）
计算每个回答的奖励（比如数学题：答案对=1，错=0）
计算组内奖励的均值和标准差
每个回答的"优势"（advantage）= (该回答的奖励 - 组内均值) / 标准差
用这个advantage来更新模型
关键洞察：不需要一个独立的价值模型来估计baseline，直接用同一组回答的均值作为baseline。如果某个回答的奖励高于组内均值，说明它"比平均水平好"，advantage为正，模型会被推向多生成这类回答；反之亦然。
类比：假设你是一个篮球教练（Actor），你想知道某个球员（某个生成的回答）水平怎么样。PPO的做法是请一个专业球探（Critic）来评估。GRPO的做法是：让这个球员跟队里其他球员打一组比赛（group），看他的表现是否高于队伍平均水平。不用请球探，省了一大笔钱。
4.5.3 GRPO的数学直觉（简化版）
PPO的目标函数（简化）：
L_PPO = -Emin(ratio \* A, clip(ratio) \* A)
其中 A = R - V(s) （A是优势，R是奖励，V(s)是价值模型估计的baseline）
GRPO的目标函数（简化）：
L_GRPO = -Emin(ratio \* A, clip(ratio) \* A)
其中 A = (R - mean(R_group)) / std(R_group) （用组内统计量替代价值模型）
损失函数的形式几乎一样（都是PPO的clip机制），区别只在于advantage的计算方式。GRPO用组内归一化的奖励替代了价值模型，省掉了critic，显存减半。
4.5.4 GRPO在DeepSeek-R1中的应用
DeepSeek-R1的RL训练流程（简化）：
- 准备：基础模型 DeepSeek-V3（已预训练+基础SFT）
- 冷启动SFT：用少量高质量推理数据微调，给模型一个"思考格式"的起点
- 推理RL（GRPO）：
- 输入大量数学/编程/推理题目
- 模型生成推理过程+答案
- 用规则奖励（答案对不对）+ 格式奖励（有没有用标签）作为奖励信号
- GRPO更新模型
- 拒绝采样SFT：用RL后的模型生成大量推理数据，筛出高质量的，再做一轮SFT
- 全场景RL：在推理+通用任务上再做一轮RL，确保模型不只擅长推理
DeepSeek-R1-Zero的特殊之处：跳过了步骤2（冷启动SFT），直接在基础模型上做纯RL。结果模型自发涌现出了反思、验证、换思路等行为。这证明了RL本身就能激励出推理能力------不需要手把手教模型怎么思考。
R1-Zero的"涌现行为"是最让人兴奋的发现。模型在RL训练中自己学会了：①"Wait, let me reconsider..."（自我反思）；②算完之后自己验算一遍；③发现思路不对主动换一条路。这些行为没有被人显式教过，是RL奖励信号"自然选择"出来的------因为会这些行为的模型答对的概率更高，拿到的奖励更多，所以被强化了。这跟生物进化的逻辑一模一样。
4.6 技术原理总览表
表4-2：推理技术原理对比总表
技术 核心思想 计算量 适用阶段 代表应用
CoT 逐步推理 1× 推理（外挂） GPT-4 + "step by step"
Self-Consistency 多次采样投票 N× 推理（外挂） 数学竞赛解题
Best-of-N 多次生成+奖励模型选优 N× + 打分 推理（外挂） 高质量生成
Tree of Thoughts 树搜索+评估+回溯 O(b×k×d) 推理（外挂） 复杂规划任务
PRM 过程级奖励评估 用于训练 训练 o1训练（推测）
GRPO 组内相对优势RL 训练阶段 训练 DeepSeek-R1训练
内化CoT（RL训练） 把推理训练进权重 推理时按需 训练+推理 o1/o3/R1/GPT-5.6
五、推理模型 vs 普通模型：什么时候该用？
到2026年，市面上同时存在"普通模型"（GPT-4o、Claude Sonnet、Gemini Flash等）和"推理模型"（o3、DeepSeek-R1、GPT-5.6 max reasoning等）。虽然趋势是融合，但目前你做技术选型时还是需要知道：什么场景该用哪种。
5.1 核心区别
普通模型和推理模型的本质区别在于：推理模型在输出最终答案前，会先生成大量"思考token"。这些思考token是模型内部的推理过程，用户可以选择看或不看，但它们都会被生成、都会消耗算力。
表5-1：推理模型 vs 普通模型核心对比
维度 普通模型（GPT-4o等） 推理模型（o3/R1等）
回答方式 直接生成答案 先思考再回答
延迟 快（秒级） 慢（数秒到数分钟）
成本 低 高（思考token也计费）
擅长任务 日常对话、简单问答、翻译、摘要 数学推理、编程、复杂逻辑、科学问题
不擅长任务 多步推理、需要验证的复杂问题 简单问答、闲聊、需要快速响应的场景
知识更新 依赖训练数据截止日期 同样依赖训练数据，但能通过思考弥补部分
可控性 输出即时可控 思考过程不完全可控
上下文利用 直接处理 先在思考中消化上下文再回答
5.2 什么时候该用推理模型？
该用的场景（推理模型有明显优势）：
数学竞赛/高难度数学：AIME、IMO级别的问题，推理模型碾压普通模型
复杂编程任务：算法设计、debug复杂代码、系统架构设计
多步逻辑推理：需要"如果A则B，如果B则C，所以..."的长链条推理
科学问题：物理、化学、生物的推导题
需要验证的任务：答案需要交叉验证、需要检查的（比如SQL正确性）
复杂规划：多步骤任务规划，需要考虑各种约束条件
数据分析：复杂的数据洞察，需要多角度思考
不该用的场景（普通模型更好或足够）：
简单问答："Python怎么反转字符串？"------普通模型秒答，推理模型纯属浪费
闲聊对话：日常聊天不需要深度思考
翻译/摘要：这些是模式匹配任务，不需要推理
高并发/低延迟场景：客服机器人、实时翻译，推理模型太慢
成本敏感场景：预算有限时，推理模型的思考token成本可能吃掉预算
创意写作：推理模型有时反而"想太多"，写出来的东西过于刻板
5.3 使用场景决策表
表5-2：使用场景决策表
任务类型 推荐模型类型 理由 备选方案
简单FAQ问答 普通模型 不需要推理，追求速度和成本 GPT-4o-mini / Claude Haiku
数学竞赛题 推理模型 需要多步推导和验证 o3 / DeepSeek-R1
日常编程辅助 普通模型（够用） 大部分编码任务不需要深度推理 GPT-4o / Claude Sonnet
复杂算法设计 推理模型 需要搜索解空间 o3 / o4-mini(high)
文档摘要 普通模型 压缩任务，不需要推理 任意普通模型
数据分析报告 推理模型 需要多角度洞察 o3 / GPT-5.6
客服对话 普通模型 需要快速响应 专用客服模型
多Agent任务编排 推理模型(ultra) 需要规划+拆解 GPT-5.6 ultra mode
翻译 普通模型 模式匹配为主 任意普通模型
安全漏洞分析 推理模型 需要深度逻辑推理 o3 / R1
闲聊/创意写作 普通模型 推理模型可能过于刻板 GPT-4o
SQL查询优化 推理模型 需要理解执行计划 o4-mini(medium)
5.4 一个实用的判断框架
我在实际工作中总结了一个简单的判断框架------"3秒法则"：
如果你（一个人类专家）看到这个问题，3秒内就能凭直觉给出答案，用普通模型。如果你需要拿纸笔算一下、想一想才能回答，用推理模型。
举个例子：
"北京到上海多少公里？" → 3秒内能答 → 普通模型
"一个水池有两个进水管一个出水管，A管3小时注满，B管4小时注满，C管6小时放完，三管同开几小时注满？" → 需要算一下 → 推理模型
这个框架的本质是：推理模型的价值在于解决"人类也需要思考才能解决的问题"。如果问题简单到人类不需要思考，那模型也不需要思考。
一个常见的误区：很多人觉得"推理模型=更聪明的模型"，所以什么任务都用推理模型。这是不对的。推理模型不是"更聪明"，而是"更擅长需要多步推理的任务"。在简单任务上，它可能跟普通模型表现一样，但成本高3-5倍、慢10倍。就像你不会用显微镜来看报纸------工具要对口。
六、测试时计算的最优分配：花多少算力"思考"才划算？
这是2025-2026年学术界和工业界最热门的研究方向之一：给定一个固定的计算预算，应该怎么分配给测试时计算，才能让效果最大化？
6.1 核心问题
测试时计算不是"越多越好"。就像考试时不是"想得越久分越高"------简单的题想太久是浪费时间，而难题想不够又会做错。
关键问题有三个：
该不该想：这个问题需要推理吗？（简单题直接答）
想多久：需要多长的思考链？（简单推理短一点，复杂推理长一点）
怎么想：用哪种策略？（CoT / Self-Consistency / 搜索）
6.2 OpenAI的经典研究：Scaling Test-Time Compute
2024年，OpenAI发了一篇论文（"Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters"），系统研究了测试时计算的scaling规律。核心发现：
发现1：测试时计算的收益跟问题难度强相关
简单题：增加测试时计算几乎没有提升（甚至可能因"过度思考"而变差）
中等题：增加测试时计算有明显提升
难题：增加测试时计算有提升，但有上限（模型基础能力不够时，想再久也没用）
发现2：最优策略跟问题难度有关
简单题：Best-of-N（多次采样取最优）效果最好------因为简单题模型大概率能做对，多试几次取最优就行
难题：逐步修订（让模型先答，再基于答案自我修正）效果最好------因为难题一次很难做对，需要迭代改进
发现3：在某些情况下，测试时计算比训练时计算更划算
当一个模型通过增加测试时计算达到的效果，≈另一个参数量大14倍的模型的效果时------说明测试时计算在这个场景下更高效。
6.3 最优分配的直觉理解
用一个图景来理解：
问题难度: 简单 ──────────── 中等 ──────────── 困难
最佳策略: 直接答 CoT 搜索+验证
计算投入: 1× 5× 20×+
收益: 几乎无 显著 有上限
类比：考试时的时间分配策略：
选择题（简单）：凭直觉秒选，不要犹豫
中等题：列步骤算一下，验算一遍
压轴大题（难）：多种解法尝试，反复检查，能做多少做多少
6.4 自适应思考分配
2025-2026年的一个重要趋势是自适应思考分配------让模型自己判断"这个问题需要想多久"。
实现方式：
难度预测器：训练一个小模型预测问题难度，据此分配计算预算
早停机制：模型在思考过程中如果已经"想清楚了"（置信度高），就提前结束思考
reasoning effort分级：像o3-mini的low/medium/high三档，用户或系统根据任务选择
动态调整：GPT-5.6的评估方式就是看不同reasoning effort下的表现，本质上是在做自适应分配
表6-1：reasoning effort各档对比（以o3-mini为例）
Effort 思考token量 延迟 成本 适用场景
low ~1K 快 低 中等难度推理、快速验证
medium ~5K 中 中 大多数推理任务
high ~10K+ 慢 高 复杂推理、竞赛级难题
max（GPT-5.6新增） 不限 很慢 很高 极端复杂问题、不截断深度推理
6.5 过度思考问题
测试时计算不是越多越好。一个有趣的现象叫"过度思考"（overthinking）：
研究表明，对于简单问题，让推理模型思考太久，准确率反而可能下降。原因：
过度复杂化：模型把简单问题想复杂了，反而引入错误
自我怀疑：模型想多了开始怀疑自己的正确答案，改成错误的
计算误差累积：思考链太长，中间步骤累积误差
类比：你做1+1=2，直觉就对了。但如果非要列方程、验算三遍，可能在某个环节算错反而得出错误答案。
所以最优策略是：简单问题少想，复杂问题多想。这也是为什么自适应思考分配如此重要。
2026年的前沿研究方向之一就是"思考token压缩"------如何让模型用更少的思考token达到同样的推理质量。这涉及到：①训练模型生成更精炼的思考链；②在推理时动态压缩冗余的思考内容；③用蒸馏技术把长思考链压缩成短思考链。这块DeepSeek和OpenAI都在发力。
七、代码实战：CoT、Self-Consistency、API调用
纸上得来终觉浅。这一章上代码，让你能真正跑起来。三段完整的Python代码，覆盖CoT推理、Self-Consistency投票、以及调用o3/DeepSeek-R1 API。
7.1 实现简单的CoT推理
这段代码演示如何用普通模型（如GPT-4o）通过CoT prompt实现推理增强，并对比"直接回答"和"CoT回答"的效果差异。
"""
代码示例1：Chain-of-Thought (CoT) 推理实现
演示：同一个模型，直接回答 vs CoT回答的效果对比
依赖：pip install openai
"""
import os
from openai import OpenAI
from dataclasses import dataclass
初始化客户端（请设置环境变量 OPENAI_API_KEY）
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
========== 测试题目集 ==========
TEST_QUESTIONS = [
{
"question": "一个农场有鸡和兔子，共35个头，94只脚。鸡和兔子各有多少只？",
"answer": "鸡23只，兔子12只"
},
{
"question": "小明买了3本书和2支笔共花47元，小红买了2本同样的书和4支笔共花46元。每本书和每支笔各多少元？",
"answer": "书14元，笔2.5元"
},
{
"question": "一个水池有进水管和出水管。进水管单独3小时注满，出水管单独6小时放完。两管同开几小时注满？",
"answer": "6小时"
},
]
@dataclass
class Response:
text: str
tokens: int
def direct_answer(question: str, model: str = "gpt-4o") -> Response:
"""直接回答模式：不加CoT提示"""
response = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": "你是一个数学解题助手。请直接给出最终答案，格式为'答案是XX'。"},
{"role": "user", "content": question}
],
temperature=0.0, # 贪心解码，确保可复现
)
return Response(
text=response.choices0.message.content,
tokens=response.usage.completion_tokens
)
def cot_answer(question: str, model: str = "gpt-4o") -> Response:
"""CoT回答模式：加入逐步推理提示"""
cot_prompt = f"""{question}
请按以下格式回答：
-
先分析题目中的已知条件和要求
-
设未知数，列方程或分步计算
-
求解并验算
-
最后给出答案，格式为'答案是XX'
让我们一步一步地思考。"""
response = client.chat.completions.create(
model=model,
messages= {"role": "system", "content": "你是一个数学解题助手，擅长逐步推理。"}, {"role": "user", "content": cot_prompt} ,
temperature=0.0,
)
return Response(
text=response.choices0.message.content,
tokens=response.usage.completion_tokens
)def extract_answer(text: str) -> str:
"""从回答中提取最终答案"""
import re匹配"答案是XX"格式
match = re.search(r'答案是(.+?)(?:。|$)', text)
if match:
return match.group(1).strip()
return text.strip()def run_comparison():
"""对比直接回答 vs CoT回答"""
print("=" * 70)
print("CoT推理对比实验：直接回答 vs 逐步推理")
print("=" * 70)for i, item in enumerate(TEST_QUESTIONS, 1):
q, expected = item"question", item"answer"
print(f"\n【题目{i}】{q}")
print(f" 标准答案：{expected}")直接回答
direct = direct_answer(q)
direct_ans = extract_answer(direct.text)
print(f"\n 直接回答 {direct_ans}")
print(f" 消耗token: {direct.tokens}")CoT回答
cot = cot_answer(q)
cot_ans = extract_answer(cot.text)
print(f"\n CoT回答 {cot_ans}")
print(f" 消耗token: {cot.tokens} (思考过程更长，token更多)")
print(f" CoT推理片段: {cot.text:200}...")if name == "main ":
run_comparison()
运行效果说明：
直接回答模式下，模型可能直接猜答案，复杂题容易错
CoT模式下，模型先列方程再求解，正确率显著提升
CoT模式的token消耗更多（因为输出了推理过程），这就是"测试时计算"的成本
7.2 实现Self-Consistency投票
这段代码实现完整的Self-Consistency流程：多次采样+答案提取+投票决策。
"""
代码示例2：Self-Consistency 自洽性投票
演示：多次采样取多数票，提升数学推理准确率
依赖：pip install openai
"""
import os
import re
from collections import Counter
from openai import OpenAI
from concurrent.futures import ThreadPoolExecutor, as_completed
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
def generate_single_cot(question: str, model: str, temperature: float, seed: int) -> str:
"""生成单条CoT推理路径（高温度采样增加多样性）"""
response = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": "你是一个数学解题专家。请逐步推理并给出答案，最后用'答案是XX'格式总结。"
},
{
"role": "user",
"content": f"{question}\n\n让我们一步一步地思考。"
}
],
temperature=temperature, # 高温度 = 多样性
seed=seed, # 不同seed = 不同推理路径
max_tokens=1000,
)
return response.choices0.message.content
def extract_answer(text: str) -> str | None:
"""从推理文本中提取最终答案"""
尝试匹配多种答案格式
patterns = [
r'答案是：:\\s(.+?)(?:。|KaTeX parse error: Undefined control sequence: \s at position 20: ... r'答案：:\\̲s̲*(.+?)(?:。|)',
r'最终答案：:\\s (.+?)(?:。|KaTeX parse error: Undefined control sequence: \s at position 21: ... r'因此，,\̲s̲*(.+?)(?:。|)',
]
for pattern in patterns:
match = re.search(pattern, text)
if match:
ans = match.group(1).strip()
归一化：去掉多余空格
ans = re.sub(r'\s+', '', ans)
return ans
return None
def self_consistency(
question: str,
model: str = "gpt-4o",
n_samples: int = 5,
temperature: float = 0.7,
) -> dict:
"""
Self-Consistency 投票推理
参数:
question: 问题文本
model: 使用的模型
n_samples: 采样次数（计算量 = n_samples × 单次推理）
temperature: 采样温度（建议0.6-0.8，太高太低都不好）
返回:
dict: 包含最终答案、各次推理结果、投票分布
"""
print(f"\n开始Self-Consistency推理 (N={n_samples}, T={temperature})")
print(f"问题: {question}")
print("-" * 60)
并行生成N条推理路径（省时间）
all_responses = \[\]
with ThreadPoolExecutor(max_workers=n_samples) as executor:
futures = {
executor.submit(generate_single_cot, question, model, temperature, i): i
for i in range(n_samples)
}
for future in as_completed(futures):
idx = futuresfuture
text = future.result()
answer = extract_answer(text)
all_responses.append({
"sample_id": idx,
"reasoning": text,
"extracted_answer": answer
})
print(f" 采样{idx}: 答案 = {answer}")
提取所有有效答案
valid_answers = [
r"extracted_answer" for r in all_responses
if r"extracted_answer" is not None
]
if not valid_answers:
return {"final_answer": None, "error": "无法从任何推理中提取答案"}
投票统计
vote_counts = Counter(valid_answers)
final_answer, vote_count = vote_counts.most_common(1)0
confidence = vote_count / len(valid_answers) # 置信度 = 最高票占比
print("-" * 60)
print(f"投票结果: {dict(vote_counts)}")
print(f"最终答案: {final_answer} (票数 {vote_count}/{len(valid_answers)}, "
f"置信度 {confidence:.0%})")
return {
"final_answer": final_answer,
"confidence": confidence,
"vote_distribution": dict(vote_counts),
"all_responses": all_responses,
}
========== 测试 ==========
if name == "main ":
hard_question = (
"一个三位数，百位数字是十位数字的2倍，"
"十位数字比个位数字大1，三个数字之和为14。这个三位数是多少？"
)
标准答案：百位=8, 十位=4, 个位=3 → 843
验证：8=4×2✓, 4=3+1✓, 8+4+3=15...
重新算：设个位x, 十位x+1, 百位2(x+1), 和=2(x+1)+(x+1)+x=4x+3=14, x=2.75...
题目改一下保证有整数解
hard_question = (
"一个三位数，百位数字是十位数字的2倍，"
"十位数字比个位数字大2，三个数字之和为11。这个三位数是多少？"
)
设个位x, 十位x+2, 百位2(x+2), 和=2x+4+x+2+x=4x+6=11...
再改：和为14 → 4x+6=14, x=2 → 个位2,十位4,百位8 → 842
hard_question = (
"一个三位数，百位数字是十位数字的2倍，"
"十位数字比个位数字大2，三个数字之和为14。这个三位数是多少？"
)
result = self_consistency(
question=hard_question,
model="gpt-4o",
n_samples=5,
temperature=0.7,
)
print(f"\n最终结果: {result'final_answer'} (标准答案: 842)")
关键设计点解释：
并行采样：用ThreadPoolExecutor并行调用API，5次采样只需要1次的时间
高温度：temperature=0.7确保每次生成不同的推理路径
不同seed：每次用不同的随机种子，进一步保证多样性
答案归一化：提取答案时做归一化处理，避免格式差异导致投票分散
置信度：最高票占比作为置信度，低于50%说明模型不确定，可能需要更多采样
7.3 调用OpenAI o3与DeepSeek-R1 API
这段代码演示如何调用推理模型API，包括reasoning effort控制、思考token处理等。
"""
代码示例3：调用推理模型API（OpenAI o3 / DeepSeek-R1）
演示：reasoning effort控制、思考过程处理、成本统计
依赖：pip install openai
"""
import os
import time
from openai import OpenAI
========== OpenAI o3 调用 ==========
def call_o3(
question: str,
reasoning_effort: str = "medium",
model: str = "o3",
) -> dict:
"""
调用 OpenAI o3 推理模型
参数:
question: 问题
reasoning_effort: "low" | "medium" | "high"
控制模型思考的深度（计算量）
model: 模型名 "o3" 或 "o4-mini"
返回:
dict: 答案、耗时、token消耗、成本估算
"""
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
print(f"\n调用 {model} (effort={reasoning_effort})")
print(f"问题: {question:100}...")
start_time = time.time()
response = client.chat.completions.create(
model=model,
reasoning_effort=reasoning_effort, # 核心参数：控制思考深度
messages=[
{
"role": "user",
"content": question
}
],
)
elapsed = time.time() - start_time
answer = response.choices0.message.content
token统计
prompt_tokens = response.usage.prompt_tokens
completion_tokens = response.usage.completion_tokens
注意：推理模型的completion_tokens包含思考token
成本估算（o3价格示例，请以官方定价为准）
PRICING = {
"o3": {"input": 0.002, "output": 0.008}, # 每1K token（美元）
"o4-mini": {"input": 0.0005, "output": 0.0015},
}
price = PRICING.get(model, {"input": 0.002, "output": 0.008})
cost = (prompt_tokens * price"input" + completion_tokens * price"output") / 1000
result = {
"model": model,
"effort": reasoning_effort,
"answer": answer,
"elapsed_seconds": round(elapsed, 1),
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"total_tokens": prompt_tokens + completion_tokens,
"estimated_cost_usd": round(cost, 4),
}
print(f"耗时: {result'elapsed_seconds'}秒")
print(f"Token: 输入{prompt_tokens} + 输出{completion_tokens} "
f"(含思考token) = {result'total_tokens'}")
print(f"估算成本: ${result'estimated_cost_usd'}")
print(f"回答: {answer:300}...")
return result
========== DeepSeek-R1 调用 ==========
def call_deepseek_r1(question: str, model: str = "deepseek-reasoner") -> dict:
"""
调用 DeepSeek-R1 推理模型
DeepSeek API兼容OpenAI格式，但推理模型有特殊字段：
- reasoning_content: 思考过程（单独字段）
- content: 最终答案
参数:
question: 问题
model: "deepseek-reasoner" (R1) 或 "deepseek-chat" (V3)
"""
# DeepSeek API base_url不同，但接口兼容
client = OpenAI(
api_key=os.environ.get("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
print(f"\n调用 DeepSeek-R1")
print(f"问题: {question:100}...")
start_time = time.time()
response = client.chat.completions.create(
model=model,
messages=[
{
"role": "user",
"content": question
}
],
)
elapsed = time.time() - start_time
message = response.choices0.message
DeepSeek-R1的特殊之处：思考过程和最终答案分开
reasoning_content = getattr(message, 'reasoning_content', None) or ""
final_answer = message.content
prompt_tokens = response.usage.prompt_tokens
completion_tokens包含reasoning_tokens
completion_tokens = response.usage.completion_tokens
DeepSeek定价（示例，请以官方为准）
R1: 输入0.00055/1K, 输出0.00219/1K (缓存命中更便宜)
cost = (prompt_tokens * 0.00055 + completion_tokens * 0.00219) / 1000
result = {
"model": model,
"reasoning": reasoning_content,
"answer": final_answer,
"elapsed_seconds": round(elapsed, 1),
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"reasoning_length": len(reasoning_content),
"estimated_cost_usd": round(cost, 4),
}
print(f"耗时: {result'elapsed_seconds'}秒")
print(f"思考过程长度: {result'reasoning_length'} 字符")
print(f"思考过程片段: {reasoning_content:200}...")
print(f"Token: 输入{prompt_tokens} + 输出{completion_tokens}")
print(f"估算成本: ${result'estimated_cost_usd'}")
print(f"最终回答: {final_answer:300}...")
return result
========== 对比实验 ==========
def compare_models(question: str):
"""对比普通模型 vs 推理模型"""
print("=" * 70)
print("模型对比实验")
print("=" * 70)
results = {}
1. 普通模型（GPT-4o）直接回答
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
print("\n--- GPT-4o（普通模型）---")
start = time.time()
resp = client.chat.completions.create(
model="gpt-4o",
messages={"role": "user", "content": question},
)
results"gpt-4o" = {
"answer": resp.choices0.message.content,
"tokens": resp.usage.completion_tokens,
"time": round(time.time() - start, 1),
}
print(f"耗时: {results'gpt-4o''time'}秒, "
f"Token: {results'gpt-4o''tokens'}")
2. 推理模型 o4-mini (low effort)
results"o4-mini-low" = call_o3(question, "low", "o4-mini")
3. 推理模型 o4-mini (high effort)
results"o4-mini-high" = call_o3(question, "high", "o4-mini")
4. DeepSeek-R1
results"deepseek-r1" = call_deepseek_r1(question)
汇总对比
print("\n" + "=" * 70)
print("汇总对比")
print("=" * 70)
print(f"{'模型':<20} {'耗时(秒)':<10} {'输出Token':<12} {'成本($)':<10}")
print("-" * 55)
print(f"{'GPT-4o':<20} {results'gpt-4o''time':<10} "
f"{results'gpt-4o''tokens':<12} {'~0.005':<10}")
print(f"{'o4-mini(low)':<20} {results'o4-mini-low''elapsed_seconds':<10} "
f"{results'o4-mini-low''completion_tokens':<12} "
f"{results'o4-mini-low''estimated_cost_usd':<10}")
print(f"{'o4-mini(high)':<20} {results'o4-mini-high''elapsed_seconds':<10} "
f"{results'o4-mini-high''completion_tokens':<12} "
f"{results'o4-mini-high''estimated_cost_usd':<10}")
print(f"{'DeepSeek-R1':<20} {results'deepseek-r1''elapsed_seconds':<10} "
f"{results'deepseek-r1''completion_tokens':<12} "
f"{results'deepseek-r1''estimated_cost_usd':<10}")
if name == "main ":
一道需要推理的数学题
test_question = (
"证明：对于任意正整数n，1+2+3+...+n = n(n+1)/2。"
"请用数学归纳法给出严格证明。"
)
compare_models(test_question)
单独测试DeepSeek-R1
call_deepseek_r1("编写一个Python函数，判断一个数是否为质数，要求时间复杂度O(sqrt(n))")
代码要点说明：
reasoning_effort参数：这是控制推理模型"思考深度"的关键旋钮。low=快但浅，high=慢但深。这就是"测试时计算分配"的API层面体现。
DeepSeek-R1的reasoning_content字段：跟OpenAI不同，DeepSeek把"思考过程"和"最终答案"分成了两个字段。reasoning_content是思考过程，content是最终答案。这让你可以灵活选择是否展示思考过程给用户。
成本对比：注意看各模型的completion_tokens------推理模型的输出token远多于普通模型，因为包含了大量思考token。这就是推理模型更贵的原因。
耗时对比：推理模型的延迟远高于普通模型。GPT-4o可能2秒返回，o4-mini(high)可能要30秒以上。
八、性能对比：推理模型在各benchmark的表现
数据说话。这一章用benchmark数据展示推理模型到底比普通模型强多少，以及各家推理模型之间的横向对比。
8.1 核心benchmark介绍
先快速过一下几个最重要的推理benchmark，不熟悉的话先看这里：
Benchmark 全称 考什么 难度
AIME American Invitational Mathematics Examination 高中数学竞赛 高（需要深度推理）
MATH MATH Dataset 竞赛级数学题 高
GPQA Graduate-Level Google-Proof Q&A 博士级科学问答 极高（Google搜不到答案）
Codeforces Codeforces编程竞赛 竞赛级算法编程 高
SWE-bench Software Engineering Benchmark 真实GitHub issue修复 高（需要工程能力）
LiveCodeBench Live Coding Benchmark 实时编程题 中高
MMLU Massive Multitask Language Understanding 多领域知识问答 中
8.2 推理模型 vs 普通模型：核心benchmark对比
表8-1：推理模型 vs 普通模型核心benchmark对比
Benchmark GPT-4o（普通） o1（初代推理） o3（2025推理） DeepSeek-R1（开源推理） GPT-5.6 Sol（2026最新）
AIME 2024 13.4% 83.3% 96.7% 79.8% ~97%+
GPQA Diamond 56.1% 78.0% 87.7% 71.5% ~89%+
Codeforces (百分位) 11th 89th 98th ~90th ~98th+
SWE-bench Verified ~33% ~43% ~69% ~49% ~72%+
MATH ~76% ~90% ~96% ~97% ~97%+
MMLU 88.7% 92.3% 95%+ 90.8% ~95%+
注：以上数据综合自各厂商官方发布的技术报告和博客。不同评测条件下数字可能有波动，GPT-5.6的数字为基于公开信息的估计值（正式全面评测数据仍在更新中）。仅供参考，请以官方最新数据为准。
8.3 数据解读
解读1：推理模型在"需要深度推理"的任务上碾压普通模型
最震撼的对比是AIME 2024：GPT-4o只有13.4%，o1直接83.3%，o3到了96.7%。这意味着：
普通模型做高中数学竞赛题，基本靠猜（13.4%接近随机猜）
o1能做对大部分
o3几乎全对
这就是测试时计算的威力------同一个级别的模型参数，推理模型靠"多想"就能在难题上拉开巨大差距。
解读2：MMLU等知识类benchmark差距较小
MMLU是"知识问答"，不是"推理"。GPT-4o已经有88.7%，o3也就95%左右。差距不大------因为这考查的是"知识储备"而非"推理能力"，而推理模型的知识储备并不比同代普通模型多。
这再次印证了核心观点：推理模型的优势在"推理"不在"知识"。简单知识问答，用推理模型是浪费。
解读3：DeepSeek-R1作为开源模型，表现接近o1
R1在AIME上79.8%，跟o1的83.3%只差不到4个百分点。考虑到R1是开源的、训练成本远低于o1，这个成绩非常了不起。
解读4：从o1到o3，进步主要在编程和工程
o1→o3的进步：AIME从83.3%→96.7%（+13.4），SWE-bench从43%→69%（+26）。编程和软件工程能力的提升尤其大，说明2025年推理模型在"工程化推理"上下了大功夫。
8.4 国产推理模型横向对比
表8-2：国产推理模型性能对比（2025-2026）
模型 厂商 AIME MATH Codeforces 开源 特色
DeepSeek-R1 深度求索 79.8% 97.3% ~90th 是（MIT协议） 纯RL训练，性价比极高
DeepSeek-R1-Zero 深度求索 71.0% 95.9% ~85th 是 无SFT纯RL，验证涌现
Kimi K1.5 月之暗面 77.5% 96.2% ~85th 部分开源 长上下文推理
Qwen3（思考模式） 阿里 ~75% ~95% ~80th 是 思考/非思考双模式
Seed-Thinking-v1.5 字节 ~80%+ ~97% ~90th 否 200B参数，超越R1
8.5 思考深度与性能的关系
一个关键问题：推理模型的"思考token数量"和"性能"是什么关系？
根据OpenAI和DeepSeek的公开数据，大致规律是：
性能
↑
| ___________ ← 饱和区（想再多也没用）
| /
| /
| / ← 线性增长区（多想确实有用）
| /
| /
| / ← 启动区（至少要想够才能开始推理）
|___/
±-----------------------→ 思考token量
1K 5K 10K 20K 50K+
1K以下：思考不够，推理不充分，性能低
1K-10K：性能随思考量线性增长，这个区间"多想"收益最大
10K-50K：增长放缓，进入边际递减
50K+：基本饱和，想更多也没用（受限于模型基础能力）
这也解释了为什么reasoning effort分low/medium/high三档------正好对应"启动区""线性增长区""饱和区"的不同位置。
九、成本分析：推理模型的token消耗与优化策略
推理模型好用，但贵。这一章算算经济账，并给出实用的成本优化策略。
9.1 为什么推理模型更贵？
推理模型的成本 = 输入token成本 + 输出token成本（含思考token）
关键在于思考token也是输出token，也按输出价格计费。
一个典型的推理任务：
输入：500 token（问题）
普通模型输出：200 token（直接答案）
推理模型输出：5000 token（4500思考 + 500答案）
推理模型的输出token是普通模型的25倍！即使单价相同，总成本也是25倍。
9.2 各模型成本对比
表9-1：主流推理模型API定价对比（2026年7月，仅供参考）
模型 输入价格(/1Ktoken)输出价格(/1K token) 输出价格(/1Ktoken)输出价格(/1K token) 缓存输入价格 备注
GPT-4o 0.0025 0.01 0.00125 普通模型，无思考token
o3 0.002 0.008 0.0005 推理模型旗舰
o4-mini 0.0005 0.0015 0.0001 轻量推理，性价比高
GPT-5.6 Sol 待确认 待确认 - 新发布，价格更新中
DeepSeek-R1 0.00055 0.00219 0.00014 开源模型API最便宜之一
DeepSeek-V3 0.00027 0.0011 0.00007 普通模型，无思考
Claude Sonnet(Thinking) 0.003 0.015 - 含思考token
Gemini 2.5 Pro Thinking 0.00125 0.005 - 谷歌推理模型
注：价格为公开信息的整理，实际价格请以各厂商官方定价页面为准。价格可能随时间调整。
9.3 单次任务成本估算
表9-2：单次推理任务成本估算（典型场景）
假设任务：解一道AIME数学题
输入：~500 token
普通模型输出：~300 token
推理模型思考+输出：~5000 token（思考4500 + 答案500）
模型 输入成本 输出成本 总成本 相对GPT-4o
GPT-4o 0.00125 0.003 $0.00425 1.0×
o3 0.001 0.04 $0.041 9.6×
o4-mini 0.00025 0.0075 $0.00775 1.8×
DeepSeek-R1 0.000275 0.01095 $0.01123 2.6×
DeepSeek-V3 0.000135 0.00033 $0.000465 0.1×
关键发现：
o3解一道题的成本是GPT-4o的约10倍
o4-mini虽然也是推理模型，但成本低很多（1.8倍），是性价比之选
DeepSeek-R1的成本是o3的1/4左右，性价比极高
DeepSeek-V3（普通模型）最便宜，但做不对AIME题
9.4 成本优化策略
推理模型贵，但有办法省。我总结了7个实用策略：
策略1：自适应路由------简单题用普通模型，难题用推理模型
最有效的优化。先用一个轻量分类器（或直接用普通模型）判断问题难度，简单问题路由给普通模型，复杂问题才路由给推理模型。
def smart_router(question):
"""智能路由：根据问题难度选择模型"""
用便宜模型判断难度
difficulty = classify_difficulty(question) # simple / medium / hard
if difficulty == "simple":
return call_model(question, "gpt-4o-mini") # 便宜快
elif difficulty == "medium":
return call_model(question, "o4-mini", effort="low") # 中等
else:
return call_model(question, "o3", effort="high") # 贵但准实测可以节省60-80%的成本，同时保持难题的准确率。
策略2：合理设置reasoning effort
不要所有问题都用high effort。根据任务难度选择：
简单推理：low effort（思考token少，省3-5倍）
中等推理：medium effort（默认，平衡）
复杂推理：high effort（只在真正需要时用）
策略3：利用Prompt Caching
很多API（DeepSeek、OpenAI）支持prompt缓存------如果多个请求的system prompt或前缀相同，缓存命中后输入价格大幅降低（通常是正常价格的1/4到1/10）。
对于推理模型，输入token虽然不多，但如果你的system prompt很长（比如包含大量工具定义），缓存能省不少。
策略4：批量处理（Batch API）
OpenAI和DeepSeek都提供Batch API------非实时请求可以批量提交，价格通常打5折。如果你的任务不需要实时响应（比如离线数据处理），用Batch API能省一半。
策略5：思考token压缩
2026年的前沿方向。通过蒸馏技术，把长思考链压缩成短思考链。比如用R1蒸馏出一个小模型，思考token只有1/5，但性能保留80%。
策略6：Self-Consistency的动态N
Self-Consistency的采样次数N不是固定的。可以先用N=3采样，如果3个答案一致（高置信），直接返回；如果不一致，再增加采样到N=7、N=10。这样大部分简单题只花3次的成本。
def adaptive_self_consistency(question, max_n=10):
"""自适应Self-Consistency：根据一致性动态调整采样次数"""
answers = \[\]
for n in range(3, max_n + 1, 2): # 3, 5, 7, 9...
answers.append(generate_and_extract(question))
vote = Counter(answers)
top_answer, top_count = vote.most_common(1)0
如果超过70%的答案一致，提前返回
if top_count / len(answers) >= 0.7:
return top_answer
return top_answer # 达到max_n，返回多数票
策略7：用开源模型替代
如果你的任务不需要最顶级的表现，DeepSeek-R1（开源）的API价格是o3的1/4。如果自己部署，成本还能更低（只付GPU费用，没有API加价）。
9.5 成本优化的ROI思考
优化推理模型成本时，要算总账，不要只盯着API费用：
表9-3：成本优化的ROI考量
优化策略 成本节省 代价/风险 推荐度
自适应路由 60-80% 需要开发分类器，可能误判 高
调低effort 50-70% 难题可能准确率下降 高
Prompt Caching 30-50%（输入部分） 需要固定prompt前缀 高
Batch API 50% 延迟增加（数小时） 中（非实时场景）
思考token压缩 60-80% 需要蒸馏训练，性能下降 中（有技术能力时）
Self-Consistency动态N 40-60% 实现复杂度增加 中
开源模型替代 70-90% 需要部署运维，性能可能下降 高（有GPU资源时）
一个容易被忽视的点：工程师的时间也是成本。如果一个优化策略能省50%的API费用，但需要2周开发+持续维护，那么如果你的月API费用只有1000，这个优化可能不划算。但如果月费用100000，那绝对值得。先算清楚你的API账单规模，再决定优化力度。
十、面试高频Q&A（10题）
这一章整理了10个面试中最常被问到的关于测试时计算和推理模型的问题。每题都给出简洁有力的回答，帮你准备面试。
Q1：测试时计算和训练时计算有什么区别？为什么测试时计算重要？
答：训练时计算是在模型训练阶段投入算力，通过更新模型权重来提升能力；测试时计算是在推理阶段增加计算量（如生成思考链、多次采样），不改权重来提升单次回答质量。
测试时计算重要的原因：①训练时scaling law边际递减（数据用完了），而测试时计算在推理类任务上仍有可观收益；②测试时计算是"按需付费"的，简单问题少投入、复杂问题多投入，灵活度高；③OpenAI的研究表明，在某些任务上，推理阶段10倍算力≈训练阶段100倍算力的效果。
Q2：CoT为什么有效？请从模型机制角度解释。
答：三个原因：①展开计算图------Transformer是next-token预测器，直接输出答案需要在前向传播中一次性完成所有计算，而CoT把推理分解为多步，每步只需简单计算；②外部记忆------CoT把中间步骤写成token，后续生成可以attend到这些token，相当于给模型"草稿纸"；③激活训练模式------训练数据中推理过程多为分步的，CoT prompt激活了模型在训练中学到的分步推理模式。
Q3：Self-Consistency和Best-of-N有什么区别？
答：两者都是"多次生成取最优"，但选择策略不同：
Self-Consistency：对最终答案投票，取多数票。不需要额外的模型，只看答案是否一致。适用于有明确答案的任务（数学题）。
Best-of-N：用奖励模型对每条推理路径打分，取最高分。需要训练奖励模型，但能评估推理质量而非只看答案。适用于开放性任务。
Q4：DeepSeek-R1的GRPO算法跟PPO有什么区别？为什么更省资源？
答：PPO需要训练一个与策略模型大小相近的价值模型（critic）来估计baseline，显存翻倍。GRPO用"组内相对奖励"替代价值模型------对同一问题生成一组G个回答，用组内奖励的均值和标准差做归一化得到advantage。这样不需要critic，显存减半，让大模型RL训练变得可行。
Q5：DeepSeek-R1-Zero有什么特殊意义？
答：R1-Zero跳过了SFT（监督微调），直接在基础模型上做纯RL。结果是模型自发涌现出了推理行为------自我反思（"wait, let me reconsider"）、验算、换思路等。这证明了：①推理能力可以通过纯RL激励出来，不需要人类标注的推理过程数据；②这些推理行为是RL"自然选择"出来的，因为会这些行为的模型答对率更高。这对整个推理模型领域有方向性启发。
Q6：推理模型在什么场景下不如普通模型？
答：四种场景：①简单任务------推理模型"想太多"反而可能过度思考导致错误，且浪费成本；②高并发低延迟场景------推理模型慢10倍以上，不适合实时应用；③成本敏感场景------推理模型的思考token使成本高3-10倍；④创意写作等非推理任务------推理模型可能过于刻板，缺乏创意。判断标准是"3秒法则"：如果人类3秒内能凭直觉回答，用普通模型。
Q7：什么是过度思考（overthinking）问题？
答：过度思考指推理模型在简单问题上思考过久，导致准确率不升反降的现象。原因包括：①过度复杂化------把简单问题想复杂引入错误；②自我怀疑------想多了开始怀疑正确答案改成错误的；③误差累积------思考链太长中间步骤累积误差。这说明测试时计算不是越多越好，需要根据问题难度自适应分配。
Q8：Process Reward Model（PRM）和Outcome Reward Model（ORM）有什么区别？
答：ORM只评估最终答案对不对（0或1），像一个只看结果不看过程的老师。PRM评估推理过程的每一步对不对，像一个逐步批改的老师。PRM的优势：①能定位具体哪步出错；②在搜索中可以每步评估指导方向；③作为RL奖励信号更精细。PRM的挑战是标注成本高（逐步标注比只标答案贵10倍+），且对开放性任务难以定义"过程对错"。
Q9：如何优化推理模型的使用成本？
答：七个策略：①自适应路由------简单题用普通模型，难题才用推理模型（省60-80%）；②合理设置reasoning effort------不要全用high；③Prompt Caching------固定前缀的输入缓存命中后大幅降价；④Batch API------非实时任务批量提交打5折；⑤思考token压缩------蒸馏出短思考链模型；⑥Self-Consistency动态N------答案一致时提前停止采样；⑦开源模型替代------DeepSeek-R1成本是o3的1/4。
Q10：2026年推理模型的发展趋势是什么？
答：五大趋势：①推理能力内置化------GPT-5.6不再区分推理/普通模型，推理成为默认能力，通过reasoning effort调节强度；②多智能体协同推理------GPT-5.6的ultra mode让多个子Agent并行处理复杂任务；③思考token压缩------让模型用更少思考达到同样质量；④自适应思考分配------模型自动判断问题难度决定想多久；⑤推理模型成为标配------所有主流大模型都内置思考能力，"推理模型"这个词将逐渐消失。
十一、总结与展望
11.1 全文核心总结
让我们回顾一下这篇文章讲了什么：
-
测试时计算（TTC）的本质：在推理阶段增加计算量来提升表现，不改模型权重。跟训练时计算的根本区别是"考试时多想5分钟"vs"考前多刷100道题"。
-
推理模型的演进：从2024年9月o1开创范式，到2025年1月DeepSeek-R1开源逆袭，到2025年o3/o4-mini成熟，再到2026年7月GPT-5.6的max reasoning+ultra多智能体------推理模型用不到2年时间从"新奇事物"变成"行业标配"。
-
核心技术栈：
推理增强：CoT（逐步推理）→ Self-Consistency（多次投票）→ ToT（树搜索）→ Best-of-N+PRM（过程评估）
训练方法：GRPO（省critic的RL算法）+ 冷启动SFT + 拒绝采样 + 全场景RL
-
使用指南：推理模型擅长数学、编程、复杂逻辑，不擅长简单问答、闲聊、翻译。判断用"3秒法则"------人类3秒能答的用普通模型，需要想想的用推理模型。
-
成本优化：自适应路由（省60-80%）是最有效的策略，其次是调低reasoning effort、用Prompt Caching、Batch API、以及开源模型替代。
11.2 我的个人判断
写到最后，分享几个我对推理模型未来的判断：
判断1：推理模型这个词会消失
到2026年底，"推理模型"可能不再是产品分类。就像现在没人说"智能手机能上网"一样------因为所有手机都能上网。未来所有大模型都会默认具备推理能力，用户通过一个"思考强度"旋钮来控制。GPT-5.6已经走在这条路上了。
判断2：测试时计算会成为独立的优化维度
训练时计算、模型参数、测试时计算------这三个维度会并列成为"scaling"的三个旋钮。未来做AI系统优化时，你需要同时考虑：花多少钱训练、用多大模型、推理时投入多少计算。这三个维度的最优配比，是2026年AI工程的核心课题。
判断3：多智能体推理是下一个爆发点
GPT-5.6的ultra mode只是开始。从"单模型深度思考"到"多模型协同推理"，这个范式转变的意义可能不亚于o1从"快答"到"深思"的转变。想象一下：未来你问AI一个复杂问题，它不是一个人在想，而是一个"AI团队"在协作------有的负责查资料，有的负责推理，有的负责验证，有的负责写报告。这才是ultra mode的真正潜力。
判断4：开源推理模型会持续追进
DeepSeek-R1证明了开源能做顶级推理模型。2026年国产开源模型（DeepSeek、Qwen、Kimi等）在部分维度已经跟闭源旗舰持平。差距虽然在，但在快速缩小。对开发者来说，开源推理模型是最值得关注的------免费、可定制、可部署。
判断5：思考token压缩是下一个技术热点
推理模型最大的痛点是成本------思考token太多太贵。谁能用更少的思考达到同样的效果，谁就赢。2026年这个方向的研究正在加速：蒸馏、剪枝、量化、动态压缩......各种技术都在往这个方向使劲。预计1-2年内，推理模型的单位思考成本会降低5-10倍。
11.3 给不同角色的建议
给开发者：
立刻开始用o4-mini和DeepSeek-R1，它们性价比最高
实现自适应路由，简单题用普通模型，难题用推理模型
关注reasoning effort参数，学会根据任务调节
如果预算有限，优先用DeepSeek-R1，成本是o3的1/4
给产品经理：
推理模型适合"高价值低频次"场景（如复杂分析、代码生成），不适合高频实时场景
在产品设计中给用户"思考强度"的控制权（参考Claude的思考开关）
做好成本预估------推理模型的单次成本是普通模型的3-10倍
考虑用ultra mode做多Agent任务编排，这是2026年的新能力
给研究者：
关注测试时计算的最优分配策略（这是2026年最热的研究方向）
GRPO之后，新的高效RL算法值得探索
思考token压缩/蒸馏有大量可发论文的空间
多智能体协同推理的机制设计是蓝海方向
11.4 写在最后
从2024年9月o1那个安静的发布，到2026年7月GPT-5.6带着ultra mode高调登场，不到两年时间，推理模型彻底改变了AI的格局。
最让我感慨的不是技术本身有多炫酷，而是这个趋势背后的朴素道理：有时候，多想一想，比学得更多更管用。
这不仅是AI的道理，也是人的道理。
我们生活在一个信息爆炸的时代，所有人都在追求"学得更多"------读更多的书、上更多的课、刷更多的题。但也许，我们更需要的是"想得更深"------在关键时刻停下来，认真推理一下，验算一下，换个角度再看看。
测试时计算给AI的启示，也许同样适用于我们每个人。
本文到此结束。 如果你读到这里，说明你是一个愿意"深度思考"的人。希望这篇文章能帮你在推理模型这个领域建立系统性的认知。如果觉得有用，欢迎点赞收藏分享。有任何问题或想讨论的，评论区见。
本文最后更新：2026年7月 | 作者：CSDN技术博客 | 基于公开信息整理，数据可能随时间变化，请以官方最新发布为准。