返回专栏
· 16 分钟阅读

Chain of Thought 与推理提示:从思维链机制到复杂任务推理优化


一、什么是 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:

P(x_1,x_2,\ldots,x_T) = \prod_{t=1}^{T}P(x_t|x_{<t})

其中:

  • 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)结合起来。

模型不仅生成中间分析,还可以根据任务需要提出工具调用请求,通过外部工具获取信息或执行操作。

例如,用户询问某项实时数据:

  1. 模型识别问题需要实时信息。
  2. 模型生成查询工具调用请求。
  3. 应用执行查询。
  4. 工具返回结果。
  5. 模型根据结果继续组织回答。

典型结构:

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. 最终结果是否满足题目约束。

但需要明确:让模型自我检查不等于独立验证。