12/30第 12 章，共 30 章

Chain of Thought、RLVR 与 Test-Time Compute：一次实测

同样 24 道题：1.9 个 token 时 0% 正确，145 个 token 时 100%。再看 self-consistency 如何买回 greedy decoding 已有的准确率。

2026年7月13日更新于 2026年9月11日11 分钟阅读

本页内容

二十四道两步文字题。一个小模型——5 亿参数，和第 11 章里的同一个——每道题都被问两次。

第一次，直接要求给出答案：

TEXT

"...How many bolts are left?  Reply with only the final number, nothing else."

  0 / 24 correct        1.9 tokens per answer

然后，再要求给出答案，但允许它先演算：

TEXT

"...How many bolts are left?  Think step by step, then give the final
 number on its own line."

  24 / 24 correct       145.2 tokens per answer

从 0 到 100%。同一个模型，同一组 weights，同样的问题，同样的 greedy decoding。唯一的区别是，第二个版本在提交一个数字之前，被允许多输出 143 个 token。

本章讨论的就是这个差距：它究竟是什么、能走多远、成本是多少，以及当这个领域不再在 prompt 里要求它、而是开始把它训练进去时发生了什么。

模型并不会思考。它只是计算得更久。

链接到此部分：模型并不会思考。它只是计算得更久。

很容易说第二个版本「想了一下」。不要这样说，因为真实机制既更简单，也更有用。

一个 transformer 对每个生成的 token 执行固定量的计算。一次 forward pass：同样的层、同样的矩阵、同样数量的运算，不管问题是 what is 2+2 还是 prove this theorem。模型内部没有一个「这题更努力一点」的旋钮。

所以，当模型被要求立刻回答时，它可用的全部计算就是一次 forward pass。所有中间量都必须装进这一次 pass 的 activations 里；凡是在那里算不出来的，它就算不出来。

输出 token 会改变这一点，而且是以两种值得区分的方式改变：

更多计算。 每生成一个 token，就是另一次完整的 forward pass。145 个 token 的演算，相当于直接回答时 145 倍的算术量。
外部化 memory。 token 被写入 context，所以下一次 pass 可以读取它们。5 × 13 = 65 变成了输入中的事实，而不是模型必须保存在 activation 里并向前携带的值。模型在把自己的输出当作草稿纸。

第二点是人们容易漏掉的，也解释了为什么演算必须被写下来才有帮助。让模型「默默想一想再回答」，它没有地方放这个想法。

这里不需要任何神秘主义，而且它给出一个明确预测：chain of thought 最应该帮助具有串行结构的问题——第二步需要第一步的结果——而最不该帮助单次查表的问题。文献发现的正是如此，也就是为什么「think step by step」对 what is the capital of France 没有作用。

作为 prompting 技术的 chain of thought

链接到此部分：作为 prompting 技术的 chain of thought

这项技术在 2022 年分两部分出现。Wei 等人证明，在 prompt 中加入带演算的示例——答案前有推理过程的 demonstrations——可以在算术和常识 benchmark 上带来很大提升。¹ Kojima 等人随后展示了一个更奇怪的结果：你不需要示例。把 「Let's think step by step」 附加到 zero-shot prompt 后面，就能获得相当一部分同样的增益。²

第二个结果说明了真正发生了什么。如果一句魔法短语能解锁这种行为，那这种行为本来就在模型里——pretraining 充满了带步骤的解法，而这句话是指向分布中那片区域的指针。Chain of thought 没有教会模型任何东西。它只是选择了模型已经拥有的东西。

这个框架也预示了这项技术最终会过时；我们会在本章末尾回到这一点。

Self-consistency，以及一个让我意外的结果

链接到此部分：Self-consistency，以及一个让我意外的结果

显然的下一步是：如果一条推理链可能错，那就 sample 多条，然后取多数答案。这就是 self-consistency。³ 它显然花费更多——不是一次生成，而是 $n$ 次完整生成——直觉是错误答案会分散，而正确答案会一致。

在同样问题中的 16 道上测量，temperature 0.8，对 $n$ 条链做多数投票：

$n$	accuracy	cumulative tokens	tokens per problem
1	81 %	2,952	185
2	81 %	5,618	351
3	100 %	8,417	526
4	100 %	11,103	694
5	100 %	13,933	871

16 道题是很小的分母，第 4 章的规则对这张表和对其他任何表一样适用。16 题中对 13 题是 81%，95% Wilson 区间为 [57, 93]；16 题全对是 100%，区间为 [81, 100]。它们重叠。 要读曲线的形状，那才是发现；不要读它在哪一级精确变平，因为 16 道题无法定位这一点。

这张表里有两件事，第二件不是我预期的。

曲线在 $n = 3$ 处变平。 到第三个 sample 时，accuracy 已经到达上限，剩下两个 sample 什么也买不到，却各花 172 个 token，合计 345 个。这就是文献中每条 self-consistency 曲线的形状，而且比「sample 越多越好」的说法暗示的要早得多。

而 greedy decoding 已经是 100%。 回看本章开头：一条链，不 sampling，145 个 token，24/24。temperature 0.8 下的 sampling 把 accuracy 降到 81%，而 self-consistency 需要三次生成，才能爬回单次 greedy pass 已经达到的位置——代价是 3.6 倍 token；如果你不知道曲线在哪里变平、一路扫到 5 次，那就是 6 倍。

这不是反对 self-consistency 的论点。它只是精确说明了它做的事：temperature 通过注入错误来购买多样性，而投票移除了它刚刚注入的错误。 在 greedy decoding 失败的问题上——单条最可能的链走向错误，而较不可能的一条是对的——这笔交易是值得的，这也是这项技术存在的原因。在 greedy 已经成功的问题上，它就是花 6 倍预算来打平。

没人发表第二种情况，所以在采用这项技术前，值得在你自己的任务上测一下。这些是给小模型做的简单两步题；答案以这种方式出现，正是在这个 regime 下。

Tree of thoughts，以及它的调用成本。

一般化做法是分支：不是 sample $n$ 条彼此独立的链，而是探索一棵由部分推理状态组成的树，评估它们，并扩展有前途的分支。⁴ 这确实有效，而且对于需要搜索的问题——谜题、规划、任何需要回溯的东西——这是正确结构。

阻止它成为默认方案的是成本。 $n = 5$ 的 self-consistency 是 5 次生成。一棵 breadth 为 $b$ 、depth 为 $d$ 的树，最多有 $b^d$ 个状态，而每个状态至少需要一次生成来扩展，通常还需要另一次生成来评估。已发表结果会为单个答案使用几十到几百次模型调用。

这和更长的链是不同类型的开销。900 个 token 的链是一次请求，latency 可预测。100 次调用的树是 100 次往返、100 次撞上 rate limit 的机会，以及由 100 个串行依赖相加而成的 latency——这是第 14 章的问题，而不是建模问题。

从要求到训练

链接到此部分：从要求到训练

到目前为止，所有事情都发生在 prompt time，发生在一个并未专门为此训练的模型上。当前一代 reasoning model 的转变，是把它移入训练——而使这一点成为可能的关键，比听起来要窄。

第 11 章的 post-training 需要人类偏好，因为「这个答案好吗？」没有程序化答案。但有些问题是有的。数学答案要么等于正确值，要么不等。代码要么通过测试，要么不通过。证明要么能被检查通过，要么不能。

对于这些领域，你可以用 verifier 替代 reward model，而下游所有事情会同时变好：没有标注员，没有 Bradley–Terry 拟合，也没有第 11 章测到的那类 reward hacking——因为你无法讨好一个 unit test。这就是 reinforcement learning from verifiable rewards，也是 GRPO 被设计出来的场景：对同一个问题 sample 一组解答尝试，检查每一个，并用组内平均分作为 baseline。没有 critic，没有标注员，没有 reward model。只有一个说对或错的程序。

Outcome reward。 只给最终答案打分。便宜——一次字符串比较——但有一个明显漏洞：一个通过错误推理得到正确数字的解法，会像真正正确的解法一样得到奖励，所以 policy 可以自由学会看起来合理、碰巧落到正确答案的胡话。

Process reward。 给每个步骤打分。Lightman 等人⁵构建了一个包含 800,000 个人类标注推理步骤的数据集，用来训练执行这件事的模型，并证明它在困难数学题上显著优于 outcome supervision。成本就在名字里：有人标注了 800,000 个步骤。

重新定义这个领域的结果来自 DeepSeek，时间是 2025 年初。⁶ 他们拿一个 base model，直接用 verifiable rewards 做 reinforcement learning，之前没有 supervised fine-tuning 阶段——而第 11 章把这个阶段呈现为一切的基础。尽管如此，长推理链还是涌现了。无人训练过的行为也出现了：模型开始重新检查自己的步骤，并且在论文中最常被引用的段落里，在解题中途自发地重新考虑一种方法。

诚实的解读不是「reasoning 是魔法」。而是：当唯一被奖励的是正确，而在难题上正确需要把题做完，那么 optimiser 找到的就是把题做完——包括人类做题时也会做的那些部分，因为它们是问题本身要求的，而不是任何人教出来的。

Reasoning token 是账单上的一行

链接到此部分：Reasoning token 是账单上的一行

这一切的实际后果是，reasoning model 会生成你要求的 token，也会生成你没有要求的 token，而两者你都要付费。

不同 providers 的处理方式不同，而且这个差异很重要：

大多数 API 把 reasoning token 计入输出 token 数之内。你的账单和你的 max_tokens 限制，都包含你看不见的思考。
Google 的 Gemini 把 thinking token 作为单独字段报告，放在标准输出计数之外。

这是两种计算同一件事的方式之间真正的不兼容；任何跨 providers 计算成本或执行预算的代码，都必须把它 normalize。第 16 章里，这会变成钱；第 23 章里，它会变成你能强制执行的预算。

另一个后果是 latency，很多人第一次遇到时都会惊讶。reasoning model 到第一个可见 token 的时间包含了它全部的思考，所以一个请求 8 秒什么也不流式输出、然后 1 秒给出答案，并不是连接挂了——是模型在工作。任何界面如果只显示一个 spinner、8 秒不给解释，问题在设计，不在网络。

第三个轴。

第 10 章的 scaling laws 有两个旋钮：参数和训练数据。两者都在模型发布之前花掉，并且在 inference time 固定不变。

Test-time compute 是第三个，而且它的行为不同于前两个：它按请求消耗，可以按请求变化，并且直接与 latency 和成本交易，而不是与训练预算交易。Snell 等人⁷表明，对于某些问题，在 inference 上花掉固定 compute budget，比花在更大的模型上能买到更高 accuracy——这颠倒了「想要更好答案就要更大模型」的假设。

实际解读，也是这成为工程决策而不是研究决策的原因：给一个小模型留出工作空间，它可以击败一个立即回答的大模型；而且成本由你按请求控制，不是按 deployment 控制。这笔交易是否划算，取决于你的 latency budget 值多少钱——这是关于你的产品的问题，不是关于模型的问题。

当「think step by step」不再有帮助

链接到此部分：当「think step by step」不再有帮助

最后提醒一句，因为这是本章内容最常被错误应用的方式。

前半部分的一切，都是让一个没有被训练成 reasoning 的模型仍然产出 reasoning 的技术。用 RLVR 训练过的模型已经会这样做：它们会在回答前，以自己的长度输出自己的演算。告诉这样的模型 think step by step，最好也只是多余，最坏可能有害——它可能生成一条短的、prompt 形状的链，取代模型本来会自己生成的更长链；一些 providers 明确记录了这一点。

同样适用于在应用代码里搭建的复杂 reasoning 脚手架。一个 prompt 如果带着模型走过一棵它内部已经会导航的决策树，就是在花你的 token 去约束一个已经训练进去的行为。这是贯穿课程后半部分的一个主题首次出现：2022 年必不可少的技术，到 2025 年会变成迷信；而想知道今天你的模型上哪一个是哪一个，唯一办法是两者都测。

第 15 章会把这种测量从观点变成纪律。

接下来走向哪里

链接到此部分：接下来走向哪里

Reasoning 有一个令人不舒服的性质：它是唯一一种成本会随问题难度扩展的能力。一个思考 900 个 token 的模型，会做 900 次 forward pass，为所有这些 pass 在 memory 中保留不断增长的 KV cache，并在整个期间占用一块 GPU。

这让服务 reasoning model 的经济性明显差于服务 chat model，也把一组实现细节变成了可行产品与不可行产品之间的差异：过去的 keys 和 values 的 cache 如何存储与复用，多少请求能共享一次 forward pass，以及 weights 实际需要多少 precision。

第 13 章是最后一章把模型当作你 memory 中的对象、而不是端口后面的服务来讨论；它讲的是如何让这个对象便宜到足以服务。它也兑现了本章的一个承诺：speculative decoding，也就是让小模型猜、大模型检查，从而以大约一个 token 的价格产出多个 token——只有在你看到 forward pass 中有多少时间花在等待 memory、而不是做算术之后，这个技巧才说得通。

来源与方法

链接到此部分：来源与方法

本章所有测量都来自 Qwen/Qwen2.5-0.5B-Instruct，使用 24 道生成的两步文字题，除明确说明 sampling 的地方外均采用 greedy decoding；在所用 token 上限下，没有任何生成被截断。结果可复现，而且是小模型在简单问题上的结果：请把 self-consistency 结果理解为对机制的演示，而不是 benchmark。CS229 讲义第 18 章和 Hugging Face LLM Course 第 12 章都用更大的模型和正规的 benchmark 讲解了这些材料。

参考资料

链接到此部分：参考资料

Wei, J. et al. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903 (2022). ↩
Kojima, T., Gu, S. S., Reid, M., Matsuo, Y. and Iwasawa, Y. Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916 (2022). 「let's think step by step」这个结果。 ↩
Wang, X. et al. Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171 (2022). ↩
Yao, S. et al. Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601 (2023). ↩
Lightman, H. et al. Let's Verify Step by Step. arXiv:2305.20050 (2023). 介绍 PRM800K，即包含 800,000 个步骤的 process supervision 数据集。 ↩
DeepSeek-AI. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948 (2025). R1-Zero 结果——直接对 base model 应用 reinforcement learning，且没有 supervised fine-tuning 阶段——见第 2.2 节。 ↩
Snell, C., Lee, J., Xu, K. and Kumar, A. Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters. arXiv:2408.03314 (2024). ↩