一、什么是 Chain of Thought?
Chain of Thought,简称 CoT,中文通常称为思维链。
它是一种提示策略,通过引导大语言模型生成或利用中间推理步骤,将复杂问题分解为多个相互关联的子问题,最终得到答案。
传统提示通常要求模型直接给出结果:
问题:
一个商品原价 200 元,打八折后是多少?
请给出答案。
模型需要直接生成最终答案:
160 元。
使用 CoT 后,可以引导模型按照中间步骤组织求解过程:
问题:
一个商品原价 200 元,打八折后是多少?
请逐步分析计算过程,再给出答案。
模型可能生成:
第一步:理解八折的含义。
八折表示支付原价的 80%。
第二步:计算折后价格。
200 × 0.8 = 160。
最终答案:
160 元。
两种方式的区别在于,CoT 不只是要求模型给出答案,还引导模型显式组织中间推理步骤。
1.1 为什么需要推理提示?
大语言模型在很多任务上可以直接生成答案,但复杂任务往往需要多个连续的判断和计算步骤。
例如:
- 多步骤数学计算。
- 复杂逻辑判断。
- 多条件规则匹配。
- 代码问题分析。
- 多文档信息综合。
- 复杂问题拆解。
- 多阶段规划。
如果直接生成最终答案,模型可能在中间某一步出现错误,却没有充分展开过程供后续检查。
CoT 的价值在于将复杂任务拆解成更小的推理步骤,使模型能够利用前一步的中间结果继续处理后续问题。
1.2 普通提示与 CoT 的区别
| 对比维度 | 普通提示 | Chain of Thought |
|---|---|---|
| 输出目标 | 直接给出结果 | 组织中间推理后给出结果 |
| 中间步骤 | 通常不显式要求 | 通常显式生成 |
| 适用任务 | 简单问答、信息提取 | 多步骤推理、复杂计算 |
| Token 消耗 | 通常较少 | 通常较多 |
| 推理过程 | 不要求展示 | 可以要求展示 |
| 结果验证 | 主要检查最终结果 | 可以检查中间步骤和最终结果 |
需要注意,CoT 并不意味着所有问题都会得到更准确的答案。
简单任务使用 CoT 可能增加不必要的输出和延迟;复杂任务也可能因为错误的中间步骤而得到错误结论。
二、Chain of Thought 的底层工作原理
理解 CoT,需要从自回归语言模型的生成机制入手。
2.1 大语言模型如何生成内容?
大语言模型通常采用自回归方式生成 Token。
给定输入上下文,模型根据已经出现的 Token 预测下一个 Token:
其中:
- x_t:当前生成的 Token。
- x_{<t}:当前 Token 之前的上下文。
- P(x_t|x_{<t}):根据已有上下文预测下一个 Token 的条件概率。
普通提示下,模型直接从问题上下文生成答案。
CoT 提示下,模型可能先生成中间推理文本,再基于这些文本继续生成后续步骤和最终答案。
2.2 CoT 如何影响生成过程?
假设问题需要经过三个步骤才能解决:
- 识别已知条件。
- 执行中间计算。
- 得出最终结果。
普通提示:
问题上下文 → 最终答案
CoT 提示:
flowchart TD
A["问题与已知条件"]
B["生成第一个推理步骤"]
C["生成第二个推理步骤"]
D["生成第三个推理步骤"]
E["整合中间结果"]
F["生成最终答案"]
A --> B
B --> C
C --> D
D --> E
E --> F
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
这里的箭头表示生成过程中的上下文依赖关系,并不是说模型内部一定存在三个独立的推理模块。
实际 Transformer 在每个生成步骤中都会根据当前上下文进行计算。
2.3 中间推理文本为什么可能提高任务表现?
CoT 的一个重要机制是让中间结果成为后续生成的上下文。
例如:
问题:
一个仓库有 120 件商品,上午卖出 30 件,
下午卖出的数量是上午的两倍,还剩多少件?
如果模型直接生成答案,需要同时完成数量关系识别、乘法计算和减法计算。
使用 CoT 时,可以组织为:
上午卖出:30 件。
下午卖出:
30 × 2 = 60 件。
总共卖出:
30 + 60 = 90 件。
剩余数量:
120 - 90 = 30 件。
前面的计算结果会进入后续生成上下文,模型可以继续利用这些中间结果完成任务。
但是,这也带来一个重要风险:
中间步骤一旦出错,错误可能沿着后续生成过程持续传播。
CoT 并不会自动验证每一步的正确性。
2.4 CoT 与模型参数的关系
CoT 是推理阶段的提示策略,不等于模型训练。
常规 CoT 提示不会直接修改模型权重。
它主要改变:
- 输入上下文。
- 任务执行方式。
- 中间输出形式。
- 后续 Token 的条件概率分布。
不过,模型是否具备较强的多步骤推理能力,还与预训练、指令微调、偏好对齐和推理训练等因素有关。
仅仅在 Prompt 中加入“请逐步思考”,并不能凭空创造模型原本不具备的推理能力。
三、CoT 的基本提示方法
CoT 可以通过不同方式引导模型组织推理过程。
3.1 Zero-shot CoT
Zero-shot CoT 是不提供推理示例,只通过提示语引导模型生成中间推理步骤。
经典提示方式包括:
请逐步思考,然后给出答案。
英文中常见表达:
Let's think step by step.
例如:
问题:
一个团队有 8 名开发人员,
每人每天完成 5 个任务。
如果工作 6 天,一共完成多少个任务?
请逐步分析计算过程,再给出最终答案。
模型可能生成:
每天完成的任务数量:
8 × 5 = 40
6 天完成的任务数量:
40 × 6 = 240
最终答案:
240 个任务。
Zero-shot CoT 的特点:
- 不需要准备推理示例。
- 只需要添加推理指令。
- 适合具有一定推理能力的模型。
- Prompt 成本相对较低。
- 推理过程的质量依赖模型自身能力。
3.2 Few-shot CoT
Few-shot CoT 是通过提供带有中间推理过程的示例,引导模型学习类似的推理组织方式。
例如:
示例 1:
问题:
小明有 10 个苹果,送给朋友 3 个,还剩多少个?
推理:
初始数量为 10 个。
送出 3 个。
剩余数量为 10 - 3 = 7 个。
答案:
7 个。
示例 2:
问题:
一个商品原价 100 元,打八折后是多少?
推理:
八折表示支付原价的 80%。
100 × 0.8 = 80。
答案:
80 元。
现在回答:
问题:
一个商品原价 300 元,打七折后是多少?
模型可以参考示例中的:
- 问题分析方式。
- 中间步骤组织方式。
- 计算过程。
- 最终答案格式。
与 Zero-shot CoT 相比,Few-shot CoT 不仅提供推理指令,还提供了具体的推理模式示例。
3.3 Zero-shot CoT 与 Few-shot CoT 对比
| 维度 | Zero-shot CoT | Few-shot CoT |
|---|---|---|
| 推理示例 | 不提供 | 提供 |
| 主要引导方式 | 自然语言指令 | 指令和推理样例 |
| Prompt 复杂度 | 较低 | 较高 |
| 示例准备成本 | 无 | 需要 |
| Token 消耗 | 通常较少 | 通常较多 |
| 适用场景 | 通用推理任务 | 特殊推理模式或业务规则 |
四、CoT 的典型推理策略
CoT 是一类重要的推理提示方法,但并不是所有推理策略都等同于 CoT。
围绕复杂任务求解,已经形成多种相关策略。
4.1 Chain of Thought:线性思维链
最基本的 CoT 是按照顺序生成中间步骤。
例如:
问题:
某商品原价 500 元,先涨价 20%,再降价 20%,
最终价格是多少?
推理:
第一步:计算涨价后的价格。
500 × 1.2 = 600 元。
第二步:计算降价后的价格。
600 × 0.8 = 480 元。
最终答案:
480 元。
这里需要注意,先涨价 20% 再降价 20%,并不会恢复原价。
原因是第二次计算的基数已经发生变化。
CoT 的价值在于把计算过程拆开,避免直接套用错误的直觉。
4.2 Least-to-Most Prompting:由易到难提示
Least-to-Most Prompting 的核心思想是:
先将复杂问题拆分为一组较简单的子问题,再按照由易到难的顺序逐个解决。
它与普通线性 CoT 的区别在于,更强调子问题的拆解和依赖关系。
例如:
问题:
某公司有 3 个部门。
每个部门有 4 个小组,每个小组有 5 名员工。
每名员工每周完成 8 个任务。
整个公司一周完成多少个任务?
可以拆解为:
子问题 1:
公司一共有多少个小组?
3 × 4 = 12
子问题 2:
公司一共有多少名员工?
12 × 5 = 60
子问题 3:
公司一周完成多少个任务?
60 × 8 = 480
执行流程:
flowchart TD
A["接收复杂问题"]
B["识别问题组成"]
C["拆分子问题"]
D["确定子问题依赖关系"]
E["解决基础子问题"]
F["利用中间结果解决后续问题"]
G["整合所有结果"]
H["输出最终答案"]
A --> B
B --> C
C --> D
D --> E
E --> F
F --> G
G --> H
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
适合:
- 多步骤计算。
- 复杂规则分析。
- 多阶段任务规划。
- 具有明确依赖关系的问题。
4.3 Self-Consistency:自一致性推理
Self-Consistency 是一种通过生成多条推理路径,再对结果进行聚合或选择的策略。
它的核心思想是:
同一个问题可以通过不同的推理路径求解,如果多条路径得到相同答案,那么这个答案可能更可靠。
例如:
问题:
一个商品原价 200 元,先打八折,再减 20 元,
最终价格是多少?
可以让模型独立生成多条推理路径。
路径 1:
200 × 0.8 = 160
160 - 20 = 140
答案:140 元
路径 2:
先计算八折价格 160 元,
再减去 20 元。
答案:140 元
路径 3:
原价的 80% 为 160 元,
优惠后再减 20 元。
答案:140 元
对多条路径的结果进行统计:
140 元:3 次
最终选择出现次数较多的答案。
执行过程:
flowchart TD
A["输入同一个问题"]
B["生成多条独立推理路径"]
C["提取各路径最终答案"]
D["统计答案分布"]
E["选择聚合结果"]
F["输出最终答案"]
A --> B
B --> C
C --> D
D --> E
E --> F
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
Self-Consistency 的关键在于多条推理路径之间具有一定独立性。
如果所有路径都受到同一个错误前提影响,即使答案高度一致,也不代表答案正确。
此外,多次采样会增加 Token 消耗、计算成本和响应延迟。
4.4 Tree of Thoughts:思维树
Tree of Thoughts,简称 ToT,是将推理过程从单一路径扩展为多条候选路径的搜索策略。
普通 CoT 更接近线性推理:
步骤 A → 步骤 B → 步骤 C → 最终答案
ToT 则允许在某个阶段生成多个候选思路,对它们进行评估,再选择继续探索的方向。
例如,设计一个系统架构方案时,可以先生成多个候选方案:
- 单体架构。
- 微服务架构。
- 模块化单体架构。
再根据业务规模、团队能力、运维成本和扩展要求评估。
其抽象过程:
flowchart TD
A["复杂任务"]
B["生成候选思路"]
C["候选方案 A"]
D["候选方案 B"]
E["候选方案 C"]
F["评估候选方案"]
G{"选择继续探索的路径"}
H["展开下一层推理"]
I["输出最终方案"]
A --> B
B --> C
B --> D
B --> E
C --> F
D --> F
E --> F
F --> G
G -->|"继续搜索"| H
H --> F
G -->|"完成搜索"| I
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
ToT 通常需要额外的候选生成、状态评估和搜索控制机制。
它不是简单地要求模型多写几段思考过程。
适合:
- 开放式规划。
- 多方案比较。
- 复杂决策。
- 需要探索多个候选路径的问题。
4.5 ReAct:Reasoning + Acting
ReAct 将推理(Reasoning)与行动(Acting)结合起来。
模型不仅生成中间分析,还可以根据任务需要提出工具调用请求,通过外部工具获取信息或执行操作。
例如,用户询问某项实时数据:
- 模型识别问题需要实时信息。
- 模型生成查询工具调用请求。
- 应用执行查询。
- 工具返回结果。
- 模型根据结果继续组织回答。
典型结构:
Thought:
当前问题需要获取外部实时数据。
Action:
调用查询工具。
Observation:
工具返回查询结果。
Thought:
根据返回结果进行分析。
Final:
组织最终回答。
需要注意,ReAct 中的 Action 不是模型直接执行外部程序。
模型生成工具调用请求后,仍然需要由应用程序解析、校验和执行。
执行流程:
flowchart TD
A["用户提出问题"]
B["模型分析任务"]
C{"是否需要外部工具"}
D["生成工具调用请求"]
E["应用校验参数与权限"]
F["执行外部工具"]
G["返回 Observation"]
H["模型继续分析"]
I["生成最终答案"]
A --> B
B --> C
C -->|"需要"| D
D --> E
E --> F
F --> G
G --> H
H --> C
C -->|"不需要"| I
style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
ReAct 适合:
- 实时信息查询。
- 数据库检索。
- API 工具调用。
- 多步骤业务处理。
- 需要外部反馈的任务。
4.6 几种推理策略的区别
| 策略 | 核心思想 | 主要特点 | 适用场景 |
|---|---|---|---|
| CoT | 展开中间推理步骤 | 单条推理链 | 多步骤问题 |
| Zero-shot CoT | 通过指令引导推理 | 不需要示例 | 通用推理 |
| Few-shot CoT | 提供推理过程示例 | 学习任务模式 | 特定推理格式 |
| Least-to-Most | 先拆解再逐步解决 | 子问题递进 | 复杂组合问题 |
| Self-Consistency | 多路径采样与聚合 | 多次推理 | 数学、逻辑任务 |
| Tree of Thoughts | 搜索多条候选路径 | 分支探索与评估 | 规划和决策 |
| ReAct | 推理与工具行动结合 | 外部反馈循环 | 工具型任务 |
这些策略可以组合使用,并非相互排斥的技术体系。
五、推理提示的设计方法
推理提示并不是简单地在 Prompt 中添加一句“请认真思考”。
要让模型更好地处理复杂任务,需要明确任务结构、推理目标和约束条件。
5.1 明确推理目标
不推荐:
请深入思考这个问题。
这种指令过于宽泛,模型不清楚应该采用什么分析方法。
推荐:
请分析下面的技术问题。
1. 识别问题中的已知条件。
2. 找出关键约束。
3. 分析可能的原因。
4. 比较不同解决方案。
5. 给出最终建议。
如果缺少必要信息,请明确指出。
明确步骤能够让模型获得更具体的任务结构。
5.2 将复杂任务拆分为子问题
例如,用户提出:
为什么 Java 服务在高并发场景下响应时间突然增加?
这是一个复杂问题,可能涉及:
- CPU 使用率。
- 内存和 GC。
- 线程池。
- 数据库连接池。
- 网络延迟。
- 锁竞争。
- 下游服务。
可以要求模型分别分析这些维度,而不是直接给出单一原因。
5.3 提供必要的约束
推理过程需要遵循明确的业务和技术约束。
例如:
分析要求:
- 不要假设未提供的系统配置。
- 区分已知事实和推测。
- 不要把相关性直接解释为因果关系。
- 对每个候选原因给出验证方法。
- 如果信息不足,列出需要补充的数据。
约束可以减少模型在信息不足时进行无依据推断。
5.4 要求输出结构化结果
对于复杂分析,可以将结果分为不同部分:
请按照以下结构输出:
一、问题理解
二、已知条件
三、关键分析
四、候选原因
五、验证方法
六、最终建议
这比要求模型输出大量自由形式的推理文本更容易评估和使用。
5.5 使用验证步骤
对于计算和逻辑任务,可以要求模型在输出前检查关键结果。
例如:
完成计算后,请检查:
1. 是否正确理解所有已知条件。
2. 是否存在单位转换错误。
3. 中间计算是否一致。
4. 最终结果是否满足题目约束。
但需要明确:让模型自我检查不等于独立验证。