一、推理模型和普通模型差在哪

普通模型是「问一句答一句」，中间怎么想的你完全看不见，它也没有一个「想」的过程， 只是一次前向直接出答案。 推理模型先写一段很长的思考过程，再给结论。 R1 的做法是用强化学习去奖励「答对」这件事，让它自己摸索出一套写法：先列条件、再分情况讨论、 最后回代验算。 关键要理解的是：这段思考不是写给你看的说明书，是它自己的工作内存。把中间结果写出来， 下一个字就有东西可以参照，不用全靠一次前向硬猜。 所以「思维链」这个译名容易误导——它不是一个展示环节，是一个计算环节。 省掉它，准确率会掉，不是因为不礼貌了。

二、链一长，误差就乘起来

Demo 第一张表只有一个公式：整体准确率 ＝ 单步准确率 ^ 步数。 单步 95% 已经很不错了，但 10 步之后是 0.60，20 步之后是 0.36。 十道题错四道、二十道错十三道——这就是「每步都对，答案却错」的来源。 反过来算更扎心：一道 20 步的题要做到 90% 的整体正确率，单步得准到 0.9947， 允许的失误率只有 0.53%。这比「差不多就行」严格得多。 这也解释了一个现象：模型在短问题上表现很好，一到多步计算就开始飘。 不是它变笨了，是误差在链上被乘了 20 次。

三、思维链真正做的是「把一步拆成几步小的」

既然整体是单步的幂，那想提高整体，只有两条路：减少步数，或者提高单步。 而减少步数往往做不到——题本身就有那么多步。 所以思维链走的是第三条路：把一步难算拆成几步容易算的，让每一步的单步准确率上去。 Demo 第三张表就是这个对照：一步硬算单步 0.60，20 步全对 0.00；随便拆拆 0.90，全对 0.12； 按位拆细 0.98，全对 0.67。 同一道题，拆得细不细，结果从 0.00 变成 0.67。 拆步的价值不在于「展示过程」，在于让每一步的失误率降下来。 这也能解释为什么「让它再检查一遍」有时真管用：多一次独立复算，等于把 0.60 抬到 0.84。 但复算这一步本身也会错，所以只能抬，不能保证。

四、能力的天花板在哪

拆步依赖「知道该怎么拆」。 训练数据里完全没有的题型，它拆不出来——不是算错， 是压根不知道该分成哪几步。 步数多了成本高。 思考的 token 一样算钱、一样占上下文。 一道本来三步能出的题，让它想两百步，钱花了效果未必好。 还有一种失败叫「看起来在推理，其实在背」。 题目换个数字，链条照抄一遍，结论跟着错。 这种错误最难发现，因为过程写得非常像样。 所以判断一个推理模型好不好，别只看最终答案。 换数字、换问法、换单位各问一遍，看它还稳不稳——这一步比看榜单有用。

五、动手 Demo：单步 95%、10 步只剩 0.60；20 步要 90% 得单步 0.9947

把「一道题要对几步」这件事抽象成一个乘法：每步独立的准确率是 p，n 步全对就是 p 的 n 次方。 扫三档单步准确率、五个步数，看整体怎么塌；再反过来算「要做到 90% 整体，单步得多准」； 最后比较三种拆法。

for p in (0.90, 0.95, 0.99):
    for n in (1, 3, 5, 10, 20):
        print('%.2f' % (p ** n))       # 整体 ＝ 单步 ^ 步数

# 反算：整体要做到 90%，单步得多准
need = 0.9 ** (1.0 / 20)               # 20 步
print('%.4f  %.2f%%' % (need, 100 * (1 - need)))

# 让它再检查一遍 ＝ 独立复算一次
print(1 - (1 - 0.95 ** 10) ** 2)

实跑输出：

--------------------------------------------------------------------
推理能力：链长了，单步就得更准，否则整体一定崩
--------------------------------------------------------------------
  单步准确率   1 步   3 步   5 步   10 步   20 步
  ----------------------------------------------
         90%   0.90   0.73   0.59    0.35    0.12
         95%   0.95   0.86   0.77    0.60    0.36
         99%   0.99   0.97   0.95    0.90    0.82

  这张表只有一个公式：整体准确率 = 单步准确率 ^ 步数。**看着简单，它解释了大模型推理最要命的一件事。**
  单步 95% 已经很不错了，可一道题要 10 步，整体就掉到 0.60——十道题错四道。这就是「模型明明每步都对，答案却不对」的来源。

  反过来算：要想整体做到 90%，不同步数下单步得多准？
  步数   单步需要的准确率   允许的失误率
  -------------------------------------
     1             0.9000         10.00%
     3             0.9655          3.45%
     5             0.9791          2.09%
    10             0.9895          1.05%
    20             0.9947          0.53%
  20 步的题，单步失误率必须压到 0.5% 以内——**这比「每步差不多就行」严格得多。**

  所以「思维链」不是「多写几步更保险」，它的作用是**把每一步变简单**：
  拆法       单步准确率   20 步全对
  --------------------------------
  一步硬算         0.60        0.00
  随便拆拆         0.90        0.12
  按位拆细         0.98        0.67
  同一道 20 步的题，拆得细不细，结果从 0.00 变成 0.67。**拆步的价值不在于「展示过程」，在于让每一步的失误率降下来。**

  这也能解释为什么「让它再检查一遍」有时管用：检查这一步本身也会出错，但它相当于**给整条链加了一次低成本的复算**。单步 0.95、10 步 0.60 的时候，多一次独立复算能把命中率抬到 0.84。

第一张表的对角线最能说明问题：单步 0.90 走 20 步只剩 0.12，单步 0.99 走 20 步还有 0.82。 同样的步数，单步差 9 个百分点，整体差 70 个百分点。 中间那行 0.95 是最贴近现实的：很多模型在单步任务上确实能到 95% 左右。 但一到 10 步就是 0.60——十道题错四道，用户体感就是「这模型不太行」。 第二张表是工程上的用法：如果业务要求 90% 的整体正确率，你就知道单步得压到多少。 20 步对应 0.9947，这个数基本只有推理模型加验算才够得着。 第三张表是这一节的核心论点。 一步硬算单步 0.60（人直接心算二十位数就这样），拆细之后 0.98（一位一位算，几乎不会错）。 同一个脑子，换了个拆法，结果从 0 变成 0.67。 最后那个 0.84 值得单独说：单步 0.95、10 步 0.60，独立复算一次能到 0.84。 但注意前提是「独立」——如果第二次还是照着第一次的思路走，那就不是复算，是复读。

30 秒实验

1. 把单步从 0.95 提到 0.99，看 20 步整体从 0.36 涨到 0.82。 单步只涨 4 个百分点，整体涨了 46 个百分点——长链会把单步的小改进放大。
2. 把复算次数从 1 次加到 3 次（1 - (1-p)^4），看命中率还能涨多少。 你会看到明显的边际递减：第一次复算最值钱，后面的越来越不值。
3. 假设每步思考写 100 个 token，算一道 20 步的题光思考要多少 token、多少钱。 再对比「三步直接答」的成本——这就是推理模型的定价逻辑。

常见误区

1. 「思维链越长越准」。步数越多，单步要求越苛刻。 20 步之后，每多一步都在给自己增加失误机会，收益会被误差吃掉。
2. 「推理模型不会算错」。它只是把一步拆成几步，每一步还是可能错。 拆步降低的是单步失误率，不是消除失误。
3. 「答对了就是会推理」。换数字还能答对才算。 很多「推理」实际是把训练里见过的解题模板背下来了，题目一变模板就失效。

推理是「自己想」，联网搜索是「出去查」。下一节看它怎么把外面的东西搬进来，以及搬错了会怎样。

• ☐ （本节完，下一节 1.3.4 DeepSeek的联网搜索能力）

相关笔记

• 🧠 AI训练师手册2 · 索引