当一条路不够走时：Self-Consistent CoT 深度拆解

文献支撑：Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E., Narang, S., Chowdhery, A., & Zhou, D. (2023). Self-Consistency Improves Chain of Thought Reasoning in Language Models. ICLR 2023. arXiv:2203.11171.

0. 先从一个让你抓狂的场景开始

想象你正在用 LLM 解一道小学数学题：

“Janet 的鸭子每天下 16 个蛋。她每天早上吃 3 个当早餐，每天烤松饼用掉 4 个。剩下的她以每个 2 美元的价格在农贸市场卖掉。她每天能赚多少钱？”

你第一次问模型，它一本正经地算：“16 减 3 是 13，13 减 4 是 9，9 乘 2 等于 18。” 答案 18，看起来靠谱。

但第二天你换了个措辞再问一遍，模型却说：“16 减 3 再减 4 等于 9，所以她有 9 个蛋，每个 2 美元，一共 18 美元。” 还是 18，推理过程略有不同，但答案一致。

第三天你又试了一次，这次模型突然短路：“16 减 3 是 13，13 减 4 是 9，但她卖的是 16 个蛋，所以 16 乘 2 等于 32。” 答案变成了 32——明显错了。

你发现了一个让人不安的事实：同一条 CoT 思维链，换个随机种子，答案可能天差地别。

别急。Wang et al. (2023) 在提出 Self-Consistent CoT（简称 CoT-SC）时，正是被这个问题刺痛了。他们问了一个非常朴素的 question：如果一次推理可能出错，那让模型多推理几次，然后让答案们"投票表决"，是不是就能大幅提高准确率？

听起来像小学班级选班长对吧？但就是这个朴素的想法，让 GSM8K 的准确率从 56.5% 飙升到 74.4%，SVAMP 从 79.0% 涨到 86.6%——而且不需要任何额外训练，不需要标注数据，不需要改模型参数。

现在我们已经了解了 CoT-SC 的动机，接下来让我们一层一层剥开它的内部结构，看看这"多数表决"的背后到底发生了什么。

1. 宏观层：CoT-SC 不是"更复杂的模型"，而是"更聪明的解码策略"

1.1 先看清整张流水线

在深入之前，我们先退后三步，把 CoT-SC 的完整流水线画成一张工厂车间图。

如果画成图，CoT-SC 就像一家小型陪审团法庭：同一个案件（问题），让 5 位陪审员（采样路径）各自独立审阅、各自写判决书（推理链），最后看法官（投票聚合器）统计——哪种判决出现次数最多，就采纳哪种。

注意一个关键细节：陪审员之间互不交流。 路径 1 不知道路径 2 写了什么。这种独立性是投票有效的前提，就像统计抽样里要求样本独立同分布一样。

1.2 它和传统 CoT 的区别到底在哪？

传统 CoT 用的是贪心解码（Greedy Decoding）。在每个时间步，模型只选概率最高的那个 token，一路走到黑。这就像你走在一条单行道上，每个路口都选看起来最宽的那条路，没有回头路，也没有旁路。

贪心解码的问题在哪？局部最优不等于全局最优。 在推理任务中，某个中间步骤的"最优"token 可能会把整条链引向错误答案。就像你在迷宫里，第一步往右看起来最宽敞，但右边其实是死胡同。

CoT-SC 的解决方案简单粗暴：不选一条路，而是同时探索 k 条路。

听起来抽象对吧？其实它的核心假设只有一句话：正确的推理路径可能形态各异，但它们倾向于汇聚到同一个正确答案；错误的推理路径则像无头苍蝇，各自撞向不同的错误答案。

Wang et al. (2023) 在论文里把这个现象称为**“一致性信号”（Consistency Signal）**——正确答案就像一块磁铁，把各种正确的思考方式都吸向它；而错误答案没有这种凝聚力。

2. 中观层：为什么投票能打败单条思维链？

2.1 一个 Toy Example，让我们用显微镜看看

现在我们已经了解了宏观流水线，接下来看看中观层面的机制。为了让你"啊哈"一声，我们先玩一个极简玩具问题。

假设我们的词表小得可怜，只有这些词：

词表 V = {2, 3, 4, +, −, ×, =, ?, 先, 再, 然后, 所以, 答案, 是}

问题是：“3 + 2 × 4 = ?”

如果模型用贪心解码，它可能生成：

“先算 3 + 2 = 5，再算 5 × 4 = 20，所以答案是 20。”

错了。它忘了运算优先级。

现在我们把 temperature 调到 0.7，采样 5 条路径：

投票结果：11 出现 3 次，20 出现 2 次。11 胜出。

你发现了吗？两条错误路径虽然都错了，但它们的"错误方式"其实不一样——路径 2 是忘了优先级，路径 5 是同样的错误但表述更简略。而三条正确路径的推理方式各不相同：有的先说乘法，有的先说"先算乘法再算加法"，有的用词不同，但它们像多条小溪，最终都汇入了"11"这个湖泊。

这就是 CoT-SC 的魔法：它不要求每一条路径都正确，它只要求正确路径比任何单一错误路径更"团结"。

2.2 从概率视角理解：边际化推理路径

在继续之前，让我们把直觉翻译成概率语言——这会帮你把 CoT-SC 和已知的机器学习概念锚定在一起。

假设正确答案 a* 来自一个离散答案集合 A。模型生成一条推理路径 r_i 并导出答案 a_i 的联合概率是 P(r_i, a_i)。

传统贪心解码做的是：

a_greedy = argmax_a P(r, a | greedy path)

而 CoT-SC 做的是**边际化（marginalize out）**推理路径：

a_sc = argmax_{a ∈ A} Σ_i 𝟙(a_i = a)

用大白话说：传统方法问的是"最可能的那条路径通向哪里"，CoT-SC 问的是"如果我把所有可能的路径都走一遍，哪个终点被踩到的次数最多"。

这和你在贝叶斯推断里见过的边缘化潜变量是同一个操作。推理路径 r 就是潜变量，答案 a 是观测变量。CoT-SC 通过采样近似积分，把潜变量消掉，得到答案的后验分布。

如果画成图，它就像一座冰山。水面上你只能看到贪心解码凿出的那一道冰缝（单一路径），但水面下藏着整座冰山的体积（所有可能路径的分布）。CoT-SC 通过多次采样，把水面下的体积"探测"出来，然后选最厚的那一块。

2.3 锚定已知：这和 Bagging 有什么关系？

如果你熟悉集成学习（Ensemble Learning），你现在应该已经拍大腿了：CoT-SC 本质上就是 Bagging——但用的是同一个模型。

传统 Bagging 需要训练多个不同的模型（比如随机森林里的多棵决策树），然后让它们投票。CoT-SC 更省事儿：它只有一个模型，但通过随机解码制造出"多个不同的模型效果"。

Wang et al. (2023) 在论文里明确把这个称为 “Self-Ensemble”（自集成）——模型自己集成自己。这避免了传统集成的两个痛点：不需要维护多个模型权重，不需要准备不同的训练数据。

3. 微观层：多样性从哪来？采样机制解剖

3.1 温度旋钮：为什么 temperature = 0 会杀死 CoT-SC？

现在我们已经了解了 CoT-SC 为什么有效，接下来看看它的"发动机"——采样多样性是怎么产生的。

如果你把 temperature 设为 0，模型在每个位置都只选概率最高的 token。这时你采样 100 次，得到的 100 条路径一模一样。投票？投了个寂寞，100 票全投给同一个答案，和传统贪心解码没有任何区别。

所以 CoT-SC 的第一条铁律是：temperature 必须大于 0。

temperature 到底在干什么？它像是一个**“创造力旋钮”**。在 Transformer 的 softmax 层，logits 被 temperature 缩放：

P(token_j) = exp(z_j / T) / Σ_k exp(z_k / T)

当 T → 0，分布趋于尖锐，所有概率质量都砸向最高分 token。当 T 增大，分布趋于平缓，原本概率较低的 token 也有机会被选中。

听起来抽象对吧？想象一个班级投票选班长。T=0 就像"只有第一名能当选，其他人一票没有"；T=0.7 就像"第一名优势还在，但第二名、第三名也有相当机会"。CoT-SC 需要的就是这种"温和的竞争"——不是彻底随机（那样推理链会胡言乱语），也不是彻底专制（那样没有多样性）。

3.2 Top-k 与 Top-p：给采样加个护栏

但 temperature 单独工作有个风险：它可能选中一些语义上完全离谱的 token。比如模型在算数学题时，temperature 太高可能突然采样到一个"苹果"或者"所以我认为月亮是奶酪做的"这种 token，把整条推理链带偏。

所以实际系统中通常配合 Top-k 或 Top-p（Nucleus Sampling） 使用。

如果画成图，Top-k 就像给候选池装了一个容量限制器——不管后面有多少长尾 token，只让前 k 个进入决赛圈。Top-p 则更灵活：它说"保留概率最高的那一小撮，直到它们的累积概率达到 90%"，然后只在这撮里面采样。

在 CoT-SC 的语境下，这些"护栏"至关重要。它们确保采样出来的路径在语法和语义上都是合理的推理链，只是在具体措辞、中间步骤的拆分方式、解题策略上有所不同。

3.3 路径级多样性 vs Token 级多样性

这里有一个容易混淆的点，我们得停下来澄清一下。

CoT-SC 需要的多样性是**路径级（path-level）的——两条路径在整体解题策略上不同。但采样机制是在token 级（token-level）**工作的——每个位置选一个不同的词。

token 级的微小差异如何累积成路径级的显著差异？答案是：蝴蝶效应。

如果画成图，它就像一条河流的分汊口。在第一个分汊口，两股水流的差异可能只是一点点流向偏差（token 级），但越往下，它们流经的地形完全不同（路径级），最终一个汇入太平洋，一个汇入印度洋。

Wang et al. (2023) 在论文中展示了真实的采样路径，你会发现：即使是同一个模型、同一个问题，采样出来的路径有的用代数法，有的用假设法，有的先验证再计算——这种策略级多样性正是 CoT-SC 效果的核心来源。

4. 从向量到矩阵：CoT-SC 的工程实现视角

4.1 单条路径的向量级计算

现在我们已经了解了采样的微观机制，接下来把镜头拉到工程实现层。先回忆一下单条 CoT 路径在向量层面是怎么工作的。

给定输入序列的嵌入矩阵 X ∈ R^n×d，Transformer 通过多层自注意力前向传播，最终在每个位置输出一个 logits 向量 z_t ∈ R^|V|。贪心解码就是：

x_t+1 = argmax_j z_t[j]

而采样解码是：

x_t+1 ~ Categorical(softmax(z_t / T))

也就是说，在向量层面，单条路径的生成过程是一个在 |V| 维概率单纯形上的随机游走。每一步，当前隐藏状态 h_t 决定了下一个 token 的分布，然后我们掷一次骰子，决定往哪个方向走。

4.2 多条路径的矩阵实现：Batch 推理

在真实系统中，我们不会真的串行跑 k 次推理——那太慢了。我们会用 Batch 推理 把这 k 条路径并行化。

如果画成图，这就像把原来的输入向量纵向复印了 k 份，叠成一个三维张量。在 GPU 上，这 k 份拷贝并行通过 Transformer 的各层，每份都有自己的随机种子，确保采样独立。最终你得到 k 个输出序列，长度可能不同（因为 EOS token 可能在不同位置被采样到）。

在矩阵实现的视角下，CoT-SC 把单次前向传播的计算图宽度扩展了 k 倍，但深度不变。这和你在神经网络并行计算里见过的 Data Parallelism 是同构的——只不过这里并行的不是数据批次，而是同一个输入的 k 个随机副本。

4.3 答案提取与投票聚合

拿到 k 条路径后，下一步是提取答案和投票。这里有两个工程细节值得注意。

第一，答案提取不是简单的字符串匹配。 模型可能在路径末尾说"答案是 18"，也可能说"所以 Janet 每天赚 18 美元"，还可能说"最终结果为 $18"。你需要一个答案解析器（Answer Parser）——可以是正则表达式，也可以是另一个轻量模型——把最终答案从自由文本中"抠"出来，归一化成标准形式（比如纯数字）。

第二，投票策略不止多数表决一种。 Wang et al. (2023) 在论文中讨论了几种聚合方式：

• 多数表决（Plurality Vote）：最简单，直接数哪个答案出现次数最多。
• 加权投票（Weighted Vote）：如果某条路径的生成概率（perplexity）特别低，可以给它的投票降权。
• 基于一致性的置信度估计：一致性比例（获胜答案的得票率 / 总票数）可以直接当作模型置信度。Wang et al. 发现这个置信度和真实准确率高度相关——也就是说，CoT-SC 不仅给了答案，还给了答案的"可信度评分"。

5. 结构化伪代码：CoT-SC 的完整算法

现在我们已经了解了从宏观流水线到微观采样的全部机制，接下来让我们用结构化伪代码把整个过程凝固下来。

function SelfConsistentCoT(problem, cotExamples, k, T, parser):
    // 第一步: 构造完整提示
    prompt ← FormatCoTPrompt(problem, cotExamples)

    // 第二步: 并行采样 k 条推理路径
    paths ← ∅
    for i ← 1 to k do:
        // 每路径使用独立随机种子，确保多样性
        seed ← RandomSeed()
        path_i ← LLM_Sample(prompt, temperature=T, top_p=0.95, seed=seed)
        paths ← paths ∪ {path_i}
    end

    // 第三步: 从每条路径提取最终答案
    answers ← ∅
    for each path in paths do:
        a ← ExtractAnswer(path, parser)     // 解析器处理自由文本
        if a ≠ ∅ then:
            answers ← answers ∪ {a}
        end
    end

    // 第四步: 多数表决聚合
    voteCounts ← CountFrequency(answers)
    bestAnswer ← argmax_{a} voteCounts[a]
    confidence ← voteCounts[bestAnswer] / |answers|

    // 第五步: 收集胜出路径的推理过程（可选，用于可解释性）
    winningPaths ← { path ∈ paths | ExtractAnswer(path) = bestAnswer }
    representativeRationale ← SelectShortest(winningPaths)   // 或 SelectMostTypical

    return {
        answer: bestAnswer,
        confidence: confidence,
        rationale: representativeRationale,
        allPaths: paths,
        voteDistribution: voteCounts
    }
end

注意这个伪代码里的几个设计选择：

1. 独立随机种子：这是多样性的生命线。如果 k 条路径共享同一个种子，它们会高度雷同。
2. 解析器的鲁棒性：ExtractAnswer 是工程上最容易出问题的环节。一个好的解析器需要处理数字、货币、百分比、日期等多种格式。
3. 置信度输出：confidence 不是装饰，它是生产环境的质量闸门——如果置信度低于阈值，可以触发二次验证或人工审核。
4. 代表性推理链的选择：最终返回给用户的不应该只是干巴巴的数字"18"，而应该是某条通往 18 的推理链（通常是胜出路径中最短或最典型的一条），这样用户才能"看到模型的思考过程"。

6. 成本曲线：采样多少条才够？

6.1 收益递减的拐点

在继续之前，我们必须面对一个现实问题：CoT-SC 不是免费的。 采样 k 条路径，推理成本就是单条路径的 k 倍（忽略 batch 并行带来的微小效率增益）。k 选多少才划算？

Wang et al. (2023) 做了系统的消融实验。他们发现：

如果画成图，它就像一条对数增长曲线：从 k=1 到 k=5，准确率跳升最猛（GSM8K 上从 56.5% 到约 68%）；从 k=10 到 k=40，增益明显放缓（从约 71% 到 74.4%）。

这意味着边际收益递减。在实际工程中，k=5 到 k=10 通常是甜点区——你获得了大部分收益，而没有付出离谱的成本。Wang et al. 在论文里也建议：“在实践中，人们可以尝试少量路径（例如 5 或 10 条）作为起点，在大多数情况下性能会快速饱和。”

6.2 一致性作为"不知道"的信号

还有一个非常实用的发现：当模型对某个问题的一致性很低（比如 5 条路径给出了 4 个不同的答案，没有一个答案超过 2 票），这往往意味着模型真的不知道答案。

这和模型校准（Calibration）的研究直接相关。传统 LLM 的 softmax 概率往往过于自信，而 CoT-SC 的一致性比例是一个更可靠的不确定性估计器。Wang et al. 在论文 Figure 8 中展示了这种相关性：一致性越高，真实准确率越高，几乎呈线性关系。

7. 闭环：这在训练与实际使用中意味着什么？

7.1 训练阶段的启示

CoT-SC 是一个**纯推理阶段（test-time）**的技术，不需要训练。但它在训练阶段有两个重要用途：

第一，生成高质量的监督数据。 你可以用 CoT-SC 对大量未标注问题生成"高置信度答案 + 代表性推理链"，然后用这些自动标注的数据去**微调（fine-tune）**模型。Wang et al. (2023) 在论文结尾明确提到这是未来工作方向。经过这种蒸馏后，模型在单次推理时就能输出接近 CoT-SC 质量的答案——相当于把"多路径投票"的知识压缩进了单路径的模型参数里。

第二，作为强化学习的奖励信号。 在 RLHF 或类似框架中，CoT-SC 的投票结果可以作为伪标签（pseudo-label），用来训练过程奖励模型（PRM）。比如，你可以用 CoT-SC 确定正确答案，然后反推哪些中间步骤是"好步骤"，从而构造步骤级的监督信号。

7.2 推理阶段的工程实践

在实际部署中，CoT-SC 的落地需要考虑以下几点：

1. 成本-质量权衡。 不是所有查询都值得 k=10 的投票。简单的事实性问题（“法国首都是哪？”）用 k=1 就够了；复杂的数学证明可能值得 k=20。这正是后续技术（如 Adaptive Compute，第35号驿站）要解决的问题——动态决定采样预算。

2. 延迟优化。 串行采样 k 次会让延迟乘以 k。工程上通常用 vLLM / TensorRT-LLM 等推理引擎的 batching 能力，把 k 条路径塞进同一个 batch 并行生成。如果 GPU 显存够大，k=10 的延迟可能只比 k=1 高 20-30%，而不是 10 倍。

3. 答案解析的鲁棒性。 生产环境中，答案解析器必须能处理：

• 不同格式的数字（“18”、“$18”、“十八”、“18.0”）
• 多选题的选项映射（模型说"答案是 B"，需要映射到具体文本）
• 开放式问题的语义等价判断（"巴黎"和"法国首都"是否算同一个答案？）

对于最后一点，简单的字符串匹配不够，你可能需要语义相似度模型（如 Sentence-BERT）来判断两个答案是否等价。

4. 可解释性输出。 最终返回给用户时，不要只给一个数字。选一条胜出路径中的典型推理链一并返回，让用户看到"为什么模型相信这个答案"。这不仅是用户体验问题，也是信任建立的关键。

7.3 CoT-SC 的边界与局限

在结束之前，我们得诚实地说：CoT-SC 不是银弹。

第一，它解决不了系统性偏差。 如果模型对某个知识点有根本性的误解（比如它坚信"地球是平的"），那么采样 100 条路径，100 条都会指向同一个错误答案。投票只会让错误答案以 100% 的一致性胜出。

第二，它对开放式任务效果有限。 Wang et al. (2023) 指出，在答案空间巨大或没有明确答案的任务中（比如创意写作、开放式问答），“多数表决"变得模糊——你怎么判断两段自由文本是否"同一个答案”？

第三，计算成本是硬约束。 对于实时应用（如自动驾驶决策、高频交易），增加 k 倍的推理延迟可能是不可接受的。

8. 延伸阅读

如果你读到这里，我们已经一起走完了从"为什么要投票"到"怎么工程化落地"的完整旅程。以下是按兴趣推荐的下一步阅读：

• 想理解 CoT 的原始机制：Wei et al. (2022) Chain-of-Thought Prompting Elicits Reasoning in Large Language Models —— CoT-SC 的基石，先读这篇再读 CoT-SC 会更通透。
• 想探索比投票更复杂的聚合方式：Li et al. (2023) Making Large Language Models Better Reasoners with Step-Aware Verifier —— 用步骤级验证器替代简单多数表决。
• 关心推理成本优化：Snell et al. (2024) Scaling LLM Test-Time Compute Optimally 和 Alomrani et al. (2025) Reasoning on a Budget —— 系统讲解如何在有限预算内分配采样资源。
• 对"模型知道自己不知道"感兴趣：Kadavath et al. (2022) Language Models (Mostly) Know What They Know —— 从校准角度讨论 LLM 的不确定性估计。

在继续你的项目之前，不妨问自己一个问题：我现在的任务，是需要模型"快速给出一个大概对的答案"，还是"花更多计算换更高准确率"？ 如果是后者，把 CoT-SC 打开，把 k 调到 5 或 10，你可能会惊讶于同一个模型突然变"聪明"了那么多。

全文完。如有疑问，欢迎回到任何一节重新出发。