深入理解自我一致性

可视化演示

交互展示LLM推理链的自洽性验证流程：多路径推理生成、一致性投票聚合与矛盾检测回溯，可视化从发散到收敛的推理质量控制。

概念与原理：多写几遍，少数服从多数

还记得刚才那场数学测验吗？老师的批改原则其实很朴素：一个人的草稿可能出错，但很多种不同解法都指向同一个数字时，这个数字大概率是真相。这就是“一致性”——不是看某一条路走得多专业，而是看最终停在同一个终点的人有多少。

自我一致性（Self-Consistency）是 2022 年提出的一种推理期增强方法。它不做任何训练，只改变“怎么用模型”：对同一个问题，用随机采样方式生成 N 条不同的思维链，每条链末尾给出一个答案，然后统计这些答案的频率，票数最高的胜出。模型权重一个字都不动，训练成本为零。

它建立在两个假设上：第一，正确的推理路径虽然形式多样，但最终答案高度趋同；第二，错误的路径往往各自错在不同的地方，难以形成多数。于是多数投票天然成为一台去噪器。设 N 次采样得到的答案为 \(a_1, a_2, \dots, a_N\)，最终答案取：

$$\displaystyle \hat{a} = \arg\max_{a \in A} \sum_{i=1}^{N} \mathbb{1}[a_i = a]$$

1. 答案集合：\(A\) 是所有可能答案构成的集合，比如 {41, 42, 43}，先把候选范围圈定。

$$\displaystyle A = \{41, 42, 43\}$$

2. 指示函数：\(\mathbb{1}[a_i = a]\) 是一个开关，当第 i 条路径的答案恰好等于 a 时取 1，否则取 0，用来给特定答案计数。

$$\displaystyle \mathbb{1}[a_i = a] = \begin{cases} 1, & a_i = a \\ 0, & a_i \neq a \end{cases}$$

3. 累加求和：\(\sum_{i=1}^{N}\) 把 N 条路径中所有投给答案 a 的票数加在一起，得到 a 的总得票。

$$\displaystyle \sum_{i=1}^{N} \mathbb{1}[a_i = a]$$

4. 取最大值：\(\arg\max\) 遍历所有候选答案，挑出得票最多的那一个作为最终输出 \(\hat{a}\)。

$$\displaystyle \hat{a} = \arg\max_{a \in A} \, \text{得票数}(a)$$

回到考试场景：老师并没有发明新题型，也没有换一批更聪明的学生，只是多看了几份草稿，就让误判率大幅下降。自我一致性同理——模型不变，数据不变，变的只是“批改”的方式。

思维链基础：先写过程，再报答案

让全班同学写出解题过程，是投票能成立的前提。如果只让每个人报一个最终数字，你根本不知道他有没有认真算。思维链（Chain-of-Thought, CoT）就是这个“要求写过程”的指令——它让模型在给出答案之前，先把推理步骤一步步写出来。

CoT 提示的核心做法，是在提问时告诉模型“让我们一步一步思考”，或者给它几个带推理过程的示例，让它在输出最终答案之前，先输出若干中间推理步骤。研究发现，当模型参数量足够大时，这种“先想后答”能显著提升数学、常识等任务的准确率，因为它把一次大跳跃拆成了许多可以检查的小步子。

有了中间步骤，模型不再一步跳到答案，而是把推理负担分摊到多个 token 上——每个步骤都基于前面的推理继续，正如学生写完一行算式才写下一行。形式化地写，给定问题 \(p\)，CoT 让模型产出推理步骤 \(r_1, \dots, r_m\) 后再得到答案：

$$\displaystyle a = f_{\theta}(p, r_1, r_2, \dots, r_m)$$

1. 问题输入：\(p\) 是用户提出的原始问题，例如“鸡兔同笼共 35 头 94 脚，兔子有几只？”。

$$\displaystyle p = \text{问题文本}$$

2. 推理步骤序列：\(r_1, r_2, \dots, r_m\) 是模型写出的中间推理文本，相当于草稿纸上的每一步计算。

$$\displaystyle r_1 \to r_2 \to \dots \to r_m$$

3. 模型参数：\(f_{\theta}\) 代表大语言模型本身，\(\theta\) 是它成千上亿的权重，这些权重在整个采样过程中保持不变。

$$\displaystyle \theta = \text{模型权重（冻结）}$$

4. 最终答案：\(a\) 是模型推理完后输出的答案，它是后续投票环节的“一张选票”。

$$\displaystyle a = \text{最终答案}$$

但只写一次过程还不够。同一份试卷，同一个学生，状态好时写得对，走神时可能算错。只有让他多写几遍不同思路的过程，才有投票的素材——这就引出了采样多样性。

采样多样性：别抄同桌，换条路走

考试时老师总鼓励：“别急着抄同桌的，自己换一种方法试试。”多条不同的解题路径，正是自我一致性采样的目标。而控制“换方法程度”的旋钮，就是温度参数。

大模型在生成每个词时，会给词表里所有候选词打一个分（logit），再经过 softmax 变成概率。温度 \(T\) 会对这些分数做缩放：\(T\) 越小，概率越集中，模型越倾向于选最高分那个词；\(T\) 越大，概率分布越平坦，低分词也有机会被选中，输出更加随机。

默认的贪心解码每次都选概率最高的词，只会产出一条“最保守”的推理链，谈不上多样性。自我一致性通常把温度设在 0.4~1.0 之间做随机采样，让每次生成的推理路径在措辞、步数甚至解题方法上产生差异。采样公式如下：

$$\displaystyle p(x_t \mid x_{<t}) = \frac{\exp(z_t / T)}{\sum_{v=1}^{V} \exp(z_v / T)}$$

1. 词汇得分：\(z_t\) 是模型给词表第 t 个候选词打出的原始分数（logit），代表它有多“想”选这个词。

$$\displaystyle z_t = \text{第 } t \text{ 个词的 logit}$$

2. 温度缩放：把每个分数除以温度 \(T\)，\(T > 1\) 时差异被压缩，\(T < 1\) 时差异被放大。

$$\displaystyle \frac{z_t}{T}$$

3. 指数变换：\(\exp(z_t / T)\) 把所有缩放后的分数转成正数，并拉大彼此差距。

$$\displaystyle \exp(z_t / T)$$

4. 归一化分母：\(\sum_{v=1}^{V} \exp(z_v / T)\) 对所有候选词的指数项求和，保证输出的概率加起来等于 1。

$$\displaystyle \sum_{v=1}^{V} \exp(z_v / T)$$

5. 最终概率：两者相除得到第 t 个词被采样到的概率，温度越高，这个概率分布越平坦，采样越随机。

$$\displaystyle p(x_t \mid x_{<t}) = \frac{\exp(z_t / T)}{\sum_{v=1}^{V} \exp(z_v / T)}$$

于是我们得到了一批“各显神通”的推理链。它们有的绕了远路，有的抄了近道，但老师不关心过程差异，只统计最终数字——接下来就是投票环节。

多数投票：最厚的一摞卷子说了算

批改到最后，老师把答案分成几摞：写 42 的三十七本，写 43 的两本，写 41 的一本。哪一摞最厚，就相信哪个——这就是多数投票最直白的模样。

在自我一致性中，每条推理链的末尾会给出一个答案。我们先把这些答案做规范化：去掉多余解释、统一数字格式、把“A“和”选项A”归入同一类。然后清点每一类的出现次数，次数最多的那个就是最终答案。这一步在代码里往往只是一次字符串抽取加一个计数器。

多数投票有效，是因为错误路径具有随机性：大概率出错的模型，每条路径错在哪个环节都不相同，最终答案自然分散；而正确路径虽然绕路，答案却稳定。只要正确路径的占比过半，多数票就大概率押中正确答案。形式化地说，设正确答案为 \(a^*\)：

$$\displaystyle \text{correct} \quad \Longleftrightarrow \quad \sum_{i=1}^{N} \mathbb{1}[a_i = a^*] > \frac{N}{2}$$

1. 指向正确的单票：\(\mathbb{1}[a_i = a^*]\) 表示第 i 条路径的答案是否为正确答案，是则计 1 票。

$$\displaystyle \mathbb{1}[a_i = a^*]$$

2. 累计票数：\(\sum_{i=1}^{N}\) 把 N 条路径中答对的票全部加起来，得到“正确票数”。

$$\displaystyle \sum_{i=1}^{N} \mathbb{1}[a_i = a^*]$$

3. 过半阈值：\(\frac{N}{2}\) 是半数分界线，比如 N=5 时至少要 3 票。

$$\displaystyle \frac{N}{2} > \frac{N}{2}$$

4. 等价判断：\(\Longleftrightarrow\) 表示左右两边同时成立，即“投票正确”与“正确票数过半”完全等价。

$$\displaystyle \text{correct} \Longleftrightarrow \text{正确票数} > \frac{N}{2}$$

就像老师不会在乎哪本卷子写得潦草，只要 42 这一摞最厚就盖棺定论。多数投票把“哪条推理链最可靠”的问题，巧妙地转化成了“哪个答案支持者最多”的问题——而后者，机器数起来容易得多。

效果与代价：5 份卷子还是 40 份卷子

既然投票有用，那是不是找 100 个同学算同一道题就万无一失？从概率上讲，确实有提升，但世界不会让你白拿——每多一条推理链，就多一份算力和延迟开销。

假设单条推理链答对的概率是 \(p\)（比如 0.7），采样 \(N\) 条后做多数投票，最终答对的概率可以精确写出。只要 \(p > 0.5\)，\(N\) 越大，最终正确的概率越高，并逐渐逼近 1。这个概率正是二项分布的尾部累加：

$$\displaystyle P_{\text{vote}} = \sum_{k=\left\lceil (N+1)/2 \right\rceil}^{N} \binom{N}{k} p^{k}(1-p)^{N-k}$$

1. 单路径正确率：\(p\) 是任意一条推理链单独答对的概率，它是整场投票的“原材料质量”。

$$\displaystyle p = \text{单路径答对概率}$$

2. 组合数：\(\binom{N}{k}\) 表示 N 条路径里恰好有 k 条答对共有多少种情况。

$$\displaystyle \binom{N}{k} = \frac{N!}{k!(N-k)!}$$

3. 联合概率项：\(p^{k}(1-p)^{N-k}\) 是“某 k 条答对、其余 N-k 条答错”这一种具体情况的概率。

$$\displaystyle p^{k}(1-p)^{N-k}$$

4. 过半下限：\(\left\lceil (N+1)/2 \right\rceil\) 表示多数所需的最少答对条数，N=5 时是 3，N=6 时是 4。

$$\displaystyle k_{\min} = \left\lceil \frac{N+1}{2} \right\rceil$$

5. 尾部累加：\(\sum_{k=k_{\min}}^{N}\) 把所有“能形成多数”的情形概率加起来，就是最终投票成功概率。

$$\displaystyle P_{\text{vote}} = \sum_{k=k_{\min}}^{N} \binom{N}{k} p^{k}(1-p)^{N-k}$$

代价同样清晰：时间开销和算力成本几乎随 \(N\) 线性增长。原本一次解码就能出答案，现在要跑 N 次；在延迟敏感的产品里，这个代价往往比收益更扎眼。实践经验表明，\(N\) 取 5~10 时通常已能拿到大部分增益，再往上投入产出比急剧下降。

这就像老师批改 5 份卷子比批改 1 份更稳，但要批 40 份就得加班到深夜。聪明的做法不是盲目加人，而是找一个“收益明显、成本可控”的人数——这正是调参的智慧所在。

局限挑战：没有标准答案的题目投不了票

但投票不是万能的。作文题就没法用这个方法——每个人写的文章都不同，“多数”根本无从谈起。这就是答案空间带来的第一道边界。

自我一致性要求答案能被提取、规范化并比较。数学题、选择题、代码这类“有唯一解”的任务最合适；而开放式生成、写诗、创意写作，不同答案只是风格差异，没有“对错”可言，多数投票反而可能埋没好答案。此外，它依赖采样质量：如果模型本身答对的概率低于 0.5，投票只会把错误答案“民主”地选出来。评估时也要小心：不同论文用不同数据集、不同温度、不同 N，结果很难横向对比；实时场景同样等不起 N 次长推理。

可以用不一致率 \(u\) 来度量 N 条路径的离散程度——路径越是各说各话，投票结果的置信度就越低：

$$\displaystyle u = \frac{1}{N} \sum_{i=1}^{N} \mathbb{1}[a_i \neq \hat{a}]$$

1. 反对票标记：\(\mathbb{1}[a_i \neq \hat{a}]\) 表示第 i 条路径的答案是否与最终多数答案不同，不同则记 1。

$$\displaystyle \mathbb{1}[a_i \neq \hat{a}]$$

2. 累计反对票：\(\sum_{i=1}^{N}\) 把 N 条路径中所有“唱反调”的路径数加起来。

$$\displaystyle \sum_{i=1}^{N} \mathbb{1}[a_i \neq \hat{a}]$$

3. 取平均：\(\frac{1}{N}\) 把反对票数除以总路径数，得到不一致的比例。

$$\displaystyle u = \frac{\text{反对票数}}{N}$$

说到底，“多批几份卷子”要有前提：题目得有明确对错，批卷人要来得及，学生也不能集体跑偏。这三个前提，正好对应答案空间、实时性、采样质量三大约束。

应用生态：从一次考试到一套制度

一套方法要在真实世界扎根，光有“正确率提升”还不够。就像学校要把“多评阅”制度落地，需要教务处定标准、老师统一改卷口径、家长信任评分结果——对应到 AI 工程里，就是评估、防护、安全的整套生态。

工程实践上，自我一致性已成为数学推理评测（如 GSM8K、MATH）的标配技巧：同一道题采样多条推理链取多数，分数普遍能在无训练的情况下提升十几个百分点；代码生成场景里，也可以生成多份候选程序，用单元测试结果代替“多数票”来筛选正确实现。同时，一致性分数本身可以被当作置信度信号——它告诉系统“这次回答到底靠不靠谱”：

$$\displaystyle c = \frac{\max_{a \in A} \sum_{i=1}^{N} \mathbb{1}[a_i = a]}{N}$$

1. 最高票数：\(\max_{a \in A} \sum_{i=1}^{N} \mathbb{1}[a_i = a]\) 先统计每个答案的票数，再取出其中最大值。

$$\displaystyle \text{最高票数} = \max_{a \in A} \sum_{i=1}^{N} \mathbb{1}[a_i = a]$$

2. 归一化比例：把最高票数除以总路径数 \(N\)，得到一个 0 到 1 之间的分数。

$$\displaystyle c = \frac{\text{最高票数}}{N}$$

3. 置信度解读：\(c\) 越接近 1，说明各条路径越一致，答案可信度越高；\(c\) 越低，说明分歧越大。

$$\displaystyle c \in [0, 1]$$

在高风险领域（医疗建议、法律咨询、金融决策），一致性分数被用作防护机制：低一致性时自动转人工，而不是硬着头皮输出。伦理与安全考量也从前瞻讨论进入工程实践——评估数据要覆盖偏见与对抗样本，防护机制要做压力测试，这些都需要产学研三方协同：高校提出算法、企业打磨工程、评测机构建立标准。

就像一套好的考试制度，既要有科学的评分方法，也要有公平的考场规则和透明的成绩申诉渠道。自我一致性从一篇论文出发，正在长成推理模型生态里一块不可或缺的基石——而它的全部起点，不过是老师那句：“多找几位同学，用不同方法再算一遍。”

AI 应用场景

Python 演示

"""自我一致性演示：同一问题采样多条推理链，多数投票定答案"""import randomfrom collections import Counter  class MockLLM:    """模拟大模型：同一问题会产生带噪声的多种推理路径"""     def __init__(self, seed=0):        random.seed(seed)        self.pool = [            ("列方程求解，答案是 42", "42"),            ("先算单价再乘数量，答案是 42", "42"),            ("估算后取整，答案是 43", "43"),            ("画图逐个数格子，答案是 41", "41"),            ("交叉相乘验算，答案是 42", "42"),        ]     def generate(self, question, temperature=0.7):        if temperature < 0.3:            return self.pool[0]        return random.choice(self.pool)  def extract_answer(chain):    """从推理链末尾提取答案"""    return chain.split("答案是")[-1].strip()  def self_consistency(llm, question, n_samples=5, temperature=0.7):    chains, votes = [], Counter()    for _ in range(n_samples):        chain, _ = llm.generate(question, temperature)        answer = extract_answer(chain)        chains.append((chain, answer))        votes[answer] += 1    final = votes.most_common(1)[0][0]    return final, votes, chains  if __name__ == "__main__":    llm = MockLLM()    final, votes, chains = self_consistency(        llm, "鸡兔同笼共35头94脚，兔子有几只？", n_samples=7, temperature=0.7    )    for i, (chain, answer) in enumerate(chains, 1):        print(f"路径{i}: {chain} -> 答案{answer}")    print("投票统计:", dict(votes))    print("最终多数票答案:", final)

1. from collections import Counter建立计票器，统计各答案得票，对应“数卷子”环节。
2. def generate(self, question, temperature=0.7)模拟一次解码采样：温度低时只走固定路径，温度高时从候选池随机抽一条推理链。
3. answer = chain.split("答案是")[-1].strip()从推理链末句抽出最终数字，完成答案提取与规范化。
4. votes[answer] += 1每出现一个答案就加一票，对应多数投票的计数动作。
5. final = votes.most_common(1)[0][0]取票数最高的答案作为最终输出，机器“老师”拍板。

常见误区

面试题