CoT思维链

发表于 分类于 ，

CoT思维链

一、CoT是什么

CoT（Chain of Thought，思维链） 是一种提示工程技术，通过引导大语言模型（LLM）逐步推理，显式地展示思考过程，从而提升模型在复杂任务上的表现。

1.1 核心思想

传统Prompt CoT Prompt
直接问答案 要求展示推理过程
模型”黑盒”思考 思考过程可见、可验证
简单问题效果好 复杂推理任务效果显著

1.2 为什么CoT有效

1
2
3
4
5
人类解决问题的方式：
问题 → 分析 → 推理步骤1 → 推理步骤2 → ... → 得出答案

CoT让LLM模拟这个过程：
输入 → 分解问题 → 逐步推理 → 中间结论 → 最终答案

关键优势：

  • 可解释性：能看到模型的思考路径
  • 准确性：复杂推理任务准确率提升显著
  • 可调试性：出错时可以定位到具体步骤

二、CoT的基本形式

2.1 零样本CoT（Zero-shot CoT）

最简单的方式：在问题后添加触发词

1
2
3
问题：一个农场有鸡和兔，头共35个，脚共94只。鸡兔各多少只？

请逐步思考并解答：

常用触发词：

  • “让我们逐步思考”
  • “请展示你的推理过程”
  • “一步一步来解决这个问题”
  • “Let’s think step by step”

2.2 少样本CoT（Few-shot CoT）

提供示例：在Prompt中加入带推理过程的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
示例1：
问题：小明有5个苹果，给了小红2个，又买了3个，现在有几个？
推理：
1. 初始有5个苹果
2. 给小红2个后：5 - 2 = 3个
3. 又买3个后：3 + 3 = 6个
答案：6个

示例2：
问题：一本书100页，第一天看了1/4，第二天看了剩下的1/3，还剩多少页？
推理：
1. 第一天看了：100 × 1/4 = 25页
2. 剩余：100 - 25 = 75页
3. 第二天看了：75 × 1/3 = 25页
4. 剩余：75 - 25 = 50页
答案：50页

现在请解决：
问题：一个水池有进水管和出水管，进水管单独注满需6小时，出水管单独排空需8小时，同时打开两管，几小时注满？
推理：

2.3 自动CoT（Auto-CoT）

自动构建示例：通过算法自动选择或生成示例

适用场景：

  • 示例难以人工编写
  • 需要大量多样化示例
  • 领域专业性较强

三、CoT的高级技巧

3.1 自我一致性（Self-Consistency）

核心思想：让模型多次推理，选择最一致的答案

1
2
3
4
5
6
7
8
9
10
11
12
13
步骤：
1. 使用CoT生成多个推理路径（temperature > 0）
2. 收集所有答案
3. 投票选择出现次数最多的答案

示例：
推理路径1 → 答案A
推理路径2 → 答案A
推理路径3 → 答案B
推理路径4 → 答案A
推理路径5 → 答案C

最终答案：A（出现3次，最多）

适用场景：数学问题、逻辑推理题

3.2 从简到繁（Least-to-Most）

核心思想：先解决子问题，再组合解决主问题

1
2
3
4
5
6
7
8
9
复杂问题：计算 (123 + 456) × (789 - 321) ÷ 3

分解：
步骤1：计算 123 + 456 = 579
步骤2：计算 789 - 321 = 468
步骤3：计算 579 × 468 = 270,972
步骤4：计算 270,972 ÷ 3 = 90,324

答案：90,324

3.3 思维树（Tree of Thoughts, ToT）

核心思想：探索多个推理分支，评估后选择最优路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
问题：24点游戏，数字 [4, 9, 10, 13]

思维树探索：
├── 分支1: 13 + 10 = 23
│   ├── 23 + 9 = 32 (×)
│   └── 23 - 4 = 19 (×)
├── 分支2: 13 - 9 = 4
│   ├── 4 × 4 = 16 (×)
│   └── 4 + 10 = 14 (×)
├── 分支3: 10 - 4 = 6
│   └── 6 × (13 - 9) = 24 (√)
└── ...

最优路径：(13 - 9) × (10 - 4) = 24

3.4 验证链（Chain of Verification）

核心思想：生成答案后，主动验证每一步

1
2
3
4
5
6
7
8
9
10
11
问题：法国的首都是哪里？它的人口是多少？

初始回答：
法国的首都是巴黎，人口约2200万。

验证步骤：
1. 验证首都：巴黎确实是法国首都 ✓
2. 验证人口：巴黎市区人口约220万，大都会区约1200万 ✗

修正后：
法国的首都是巴黎，市区人口约220万。

四、CoT实践指南

4.1 何时使用CoT

场景 建议 原因
数学计算 ✅ 强烈推荐 需要多步计算
逻辑推理 ✅ 强烈推荐 需要演绎推理
代码生成 ✅ 推荐 需要分解步骤
文本分类 ⚠️ 可选 简单任务可能不需要
翻译任务 ❌ 不推荐 通常不需要推理
创意写作 ❌ 不推荐 可能限制创造性

4.2 CoT Prompt设计原则

原则1：明确性

1
2
3
4
5
6
7
8
9
10
❌ 差：
解决这个问题。

✅ 好：
请按以下步骤解决这个问题：
1. 理解问题要求
2. 识别已知条件
3. 制定解题计划
4. 执行计算
5. 验证结果

原则2：结构化

1
2
3
4
5
6
7
8
9
10
11
12
❌ 差：
帮我算一下这个。

✅ 好：
问题：[具体问题]

请按以下格式回答：
分析：[对问题的分析]
步骤1：[第一步推理]
步骤2：[第二步推理]
...
结论：[最终答案]

原则3：示例质量

1
2
3
4
5
6
7
8
9
10
11
12
13
❌ 差示例：
问题：2+2=?
推理：等于4
答案：4

✅ 好示例：
问题：25 × 4 = ?
推理：
1. 将25分解为20 + 5
2. 计算20 × 4 = 80
3. 计算5 × 4 = 20
4. 相加：80 + 20 = 100
答案：100

4.3 CoT模板库

模板1：数学问题解决

1
2
3
4
5
6
7
8
9
10
11
12
你是一个数学助手。请按以下步骤解决问题：

问题：{question}

解题步骤：
1. 理解题意：{分析题目要求}
2. 识别已知：{列出已知条件}
3. 确定方法：{选择解题方法}
4. 详细计算：{展示计算过程}
5. 结果验证：{检查结果合理性}

答案：{最终答案}

模板2：逻辑推理

1
2
3
4
5
6
7
8
9
10
11
12
13
请作为逻辑分析师，按以下框架分析：

前提条件：
{列出所有前提}

推理过程：
步骤1：{从前提A推导}
步骤2：{结合前提B推导}
步骤3：{得出中间结论}

最终结论：{答案}

置信度：{高/中/低}，理由：{说明}

模板3：代码调试

1
2
3
4
5
请作为资深程序员，按以下步骤调试代码：

代码：
```{language}
{code}

错误信息：{error}

调试步骤：

  1. 错误定位：{哪一行/哪个函数}
  2. 原因分析：{为什么会出现这个错误}
  3. 解决方案：{如何修复}
  4. 修复后代码：{corrected code}
  5. 预防措施：{如何避免类似错误}
    1
    2
    3
    4
    5
    6
    7
    8
    9

    ---

    ## 五、CoT与其他技术的结合

    ### 5.1 CoT + RAG

    **场景**：需要结合外部知识的推理

    系统流程：
    用户问题 → 检索相关知识 → CoT推理 → 生成答案

示例：
问题：某公司2023年营收增长了多少？

步骤1（RAG）：
检索到：2022年营收100亿，2023年营收120亿

步骤2（CoT）：

  1. 获取2023年营收：120亿
  2. 获取2022年营收：100亿
  3. 计算增长额：120 - 100 = 20亿
  4. 计算增长率：20/100 × 100% = 20%

答案：营收增长了20%，即20亿元

1
2
3
4
5

### 5.2 CoT + Function Calling

**场景**：需要调用工具完成推理

问题：北京明天适合户外活动吗？

CoT推理：

  1. 需要获取北京明天的天气信息
  2. 需要判断天气是否适合户外活动

Function Call：

  • 调用天气API获取北京明天天气

继续推理：
3. 根据返回的天气数据（温度、降雨概率、风力）
4. 判断：温度适宜(15-25°C)、降雨概率低(<30%)、风力适中(<4级)
5. 结论：适合户外活动

答案：适合，明天北京天气晴好，温度适宜，适合户外活动。

1
2
3
4
5

### 5.3 CoT + 多智能体协作

**场景**：复杂问题需要多个专家协作

问题：设计一个高并发的电商系统

智能体协作流程：

[架构师智能体]
推理：需要考虑负载均衡、服务拆分、缓存策略…
输出：系统架构方案

↓

[数据库专家智能体]
推理：根据架构，需要设计分库分表、读写分离…
输出：数据库设计方案

↓

[安全专家智能体]
推理：检查架构中的安全漏洞，设计防护方案…
输出：安全加固建议

↓

[汇总智能体]
CoT整合：

  1. 整合架构方案
  2. 整合数据库设计
  3. 整合安全建议
  4. 生成最终方案文档
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35

    ---

    ## 六、CoT效果评估

    ### 6.1 评估指标

    | 指标 | 说明 | 计算方法 |
    |------|------|----------|
    | 准确率 | 答案正确比例 | 正确数/总数 |
    | 推理完整性 | 步骤是否完整 | 人工评估 |
    | 逻辑一致性 | 推理是否自洽 | 人工评估 |
    | 答案稳定性 | 多次运行一致性 | Self-Consistency |
    | 推理长度 | 步骤数量 | 自动统计 |

    ### 6.2 常见问题与优化

    | 问题 | 表现 | 解决方案 |
    |------|------|----------|
    | 推理跳跃 | 跳过关键步骤 | 要求"详细展示每一步" |
    | 幻觉推理 | 基于错误前提推理 | 添加验证步骤 |
    | 循环推理 | 重复相同步骤 | 限制最大步骤数 |
    | 过早结论 | 推理不充分就下结论 | 要求"确保推理完整" |
    | 格式混乱 | 输出结构不清晰 | 提供明确的格式模板 |

    ---

    ## 七、实战案例

    ### 案例1：数学应用题

    **问题**：
    甲乙两人同时从A、B两地相向而行，甲每小时走5公里，乙每小时走4公里，3小时后相遇。A、B两地相距多少公里？

    **CoT解答**：
    分析：这是相遇问题，需要计算两人3小时走的总路程。

步骤1：确定已知条件

  • 甲的速度：5 km/h
  • 乙的速度：4 km/h
  • 行走时间：3 小时

步骤2：计算甲走的路程
甲的路程 = 速度 × 时间 = 5 × 3 = 15 公里

步骤3：计算乙走的路程
乙的路程 = 速度 × 时间 = 4 × 3 = 12 公里

步骤4：计算总距离
A、B距离 = 甲的路程 + 乙的路程 = 15 + 12 = 27 公里

验证：
两人相向而行，相对速度 = 5 + 4 = 9 km/h
3小时相遇，距离 = 9 × 3 = 27 公里 ✓

答案：A、B两地相距27公里。

1
2
3
4
5
6
7

### 案例2：逻辑谜题

**问题**：
有三扇门，后面分别是一辆车和两只山羊。你选择一扇门后，主持人（知道门后是什么）打开另一扇有山羊的门，然后问你要不要换门。你应该换吗？

**CoT解答**：

分析：这是蒙提霍尔问题，需要概率分析。

初始状态：

  • 选中车的概率：1/3
  • 选中山羊的概率：2/3

情况1：初始选中车（概率1/3）

  • 主持人打开一扇有山羊的门
  • 换门会得到山羊
  • 不换得到车

情况2：初始选中山羊（概率2/3）

  • 主持人只能打开另一扇有山羊的门
  • 换门会得到车
  • 不换得到山羊

概率计算：

  • 不换门的胜率：1/3
  • 换门的胜率：2/3

结论：应该换门，胜率从1/3提升到2/3。

1
2
3
4
5
6
7

### 案例3：代码生成

**问题**：
写一个函数，找出数组中第K大的元素。

**CoT解答**：

分析：有多种方法可以实现，需要考虑时间复杂度和空间复杂度。

方案对比：

  1. 排序法：O(nlogn)，简单直接
  2. 最小堆法：O(nlogk)，适合k较小的情况
  3. 快速选择：O(n)平均，最优但实现复杂

选择：使用最小堆法，时间复杂度较好且实现相对简单。

实现步骤：

  1. 创建一个大小为k的最小堆
  2. 遍历数组，维护堆中的k个最大元素
  3. 堆顶就是第k大的元素

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import heapq

def find_kth_largest(nums, k):
    # 创建最小堆（Python heapq默认是最小堆）
    min_heap = []
    
    for num in nums:
        if len(min_heap) < k:
            heapq.heappush(min_heap, num)
        elif num > min_heap[0]:
            # 当前元素比堆顶大，替换堆顶
            heapq.heapreplace(min_heap, num)
    
    # 堆顶就是第k大的元素
    return min_heap[0]

# 验证
nums = [3, 2, 1, 5, 6, 4]
k = 2
result = find_kth_largest(nums, k)
print(f"第{k}大的元素是：{result}")  # 输出：5

复杂度分析：

  • 时间复杂度：O(nlogk)，每个元素最多入堆出堆一次
  • 空间复杂度：O(k)，堆的大小
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26

    ---

    ## 八、总结

    ### 8.1 CoT核心要点

    | 要点 | 说明 |
    |------|------|
    | 适用场景 | 复杂推理、数学计算、逻辑分析 |
    | 关键技巧 | 零样本触发、少样本示例、自我一致性 |
    | 设计原则 | 明确性、结构化、高质量示例 |
    | 高级扩展 | ToT、验证链、多智能体协作 |

    ### 8.2 最佳实践 checklist

    - [ ] 判断任务是否需要推理（简单任务可能不需要CoT）
    - [ ] 选择合适的CoT形式（零样本/少样本）
    - [ ] 设计清晰的推理步骤和格式
    - [ ] 提供高质量的示例（如果使用少样本）
    - [ ] 考虑使用自我一致性提升准确率
    - [ ] 对关键任务添加验证步骤
    - [ ] 评估CoT效果，持续优化Prompt

    ### 8.3 学习路径

    入门 → 掌握零样本CoT → 学习少样本CoT → 了解高级技巧 → 实践优化
    ```

关键记住：CoT的本质是让模型像人类一样”先思考，后回答”，通过显式展示推理过程来提升复杂任务的准确性和可解释性。