思维链（Chain of Thought）：引导模型逐步推理 ​

1. 问题引入：为什么模型会"跳步" ​

观察以下数学问题的两种回答方式：

问题：一个杂货店有 5 箱苹果，每箱 12 个。店主卖掉了 28 个苹果。现在还剩多少个苹果？

直接回答（容易出错）：

答案：32 个

逐步推理（更可靠）：

1. 计算总数：5 箱 × 12 个/箱 = 60 个
2. 减去卖出：60 - 28 = 32 个
答案：32 个

两种方式都得到了正确答案，但第二种方式更可靠。原因在于：

• 直接回答：模型直接从问题跳到答案，中间的推理是"隐式"的，容易出错
• 逐步推理：将推理过程"显式化"，每一步都可验证，降低了错误累积的风险

这就是**思维链（Chain of Thought, CoT）**的核心思想：通过引导模型显式地输出中间推理步骤，提升复杂任务的准确性。

2. CoT 的基本形式 ​

2.1 零样本 CoT（Zero-shot CoT） ​

最简单的触发方式——在问题末尾添加一句引导语：

让我们一步一步地思考。
(Let's think step by step.)

完整示例：

问题：一个书架有三层。第一层有15本书，第二层比第一层多5本，
第三层的书是第二层的一半。书架上一共有多少本书？

让我们一步一步地思考。

模型输出：

1. 第一层：15 本
2. 第二层：15 + 5 = 20 本
3. 第三层：20 ÷ 2 = 10 本
4. 总计：15 + 20 + 10 = 45 本

答案：45 本

为什么有效：这句简单的引导语改变了模型的生成模式，使其倾向于输出中间步骤而非直接跳到结论。

2.2 少样本 CoT（Few-shot CoT） ​

提供一个或多个包含完整推理过程的示例，引导模型模仿这种推理风格：

## 示例
问题：篮球比赛中，A队得了3个三分球，5个两分球，罚球得了7分。
B队得了2个三分球，8个两分球，罚球得了5分。哪队得分更高？

思考过程：
1. A队得分 = 3×3 + 5×2 + 7 = 9 + 10 + 7 = 26分
2. B队得分 = 2×3 + 8×2 + 5 = 6 + 16 + 5 = 27分
3. 比较：27 > 26

答案：B队得分更高

---

## 新问题
问题：[你的实际问题]

思考过程：

Few-shot CoT 的优势：

• 可以控制推理的格式和风格
• 对于特定领域的推理任务，示例可以教会模型领域知识
• 适合需要特定解题模式的场景

3. CoT 的进阶变体 ​

3.1 Auto-CoT（自动思维链） ​

问题：手工编写 Few-shot 示例成本高，且示例质量影响效果。

解决方案：让模型自动生成示例的推理链。

# Auto-CoT 的基本流程
def auto_cot(questions, model):
    # 1. 对问题进行聚类
    clusters = cluster_questions(questions)
    
    # 2. 从每个聚类中选择代表性问题
    representative_questions = select_representatives(clusters)
    
    # 3. 用零样本 CoT 为每个代表性问题生成推理链
    demonstrations = []
    for q in representative_questions:
        reasoning = model.generate(q + "\n让我们一步一步地思考。")
        demonstrations.append((q, reasoning))
    
    # 4. 将生成的示例用于 Few-shot CoT
    return demonstrations

3.2 Tree of Thoughts（思维树） ​

问题：CoT 是单一的线性推理路径，遇到错误会一路错下去。

解决方案：将推理过程组织成树状结构，探索多个分支，选择最优路径。

                    [问题]
                       │
           ┌───────────┼───────────┐
           ▼           ▼           ▼
       [思路A]     [思路B]     [思路C]
           │           │           │
       评估:0.6    评估:0.8    评估:0.3
           │           │
           │      ┌────┴────┐
           │      ▼         ▼
           │  [步骤B1]   [步骤B2]
           │      │         │
           └──────┴────┬────┘
                       ▼
                   [最终答案]

ToT 的核心机制：

1. 思维生成：在每个节点生成多个可能的下一步
2. 思维评估：评估每个思维的质量/可行性
3. 搜索算法：使用 BFS/DFS 探索思维空间
4. 回溯机制：发现死胡同时可以回退

适用场景：

• 复杂的规划问题
• 多步决策问题
• 需要探索多种可能性的任务

3.3 Self-Consistency（自我一致性） ​

在下一章详细介绍。核心思想：多次生成推理路径，通过投票选择最一致的答案。

4. CoT 的技术细节 ​

4.1 温度设置 ​

4.2 提示词结构 ​

推荐的 CoT 提示词模板：

# 任务
[描述任务目标]

# 思考要求
在回答之前，请按以下步骤进行分析：
1. 首先，识别问题中的关键信息
2. 然后，列出解决问题需要的步骤
3. 接着，逐步执行每个步骤
4. 最后，验证答案的合理性

# 问题
[具体问题]

# 分析过程

4.3 结合结构化输出 ​

请以 JSON 格式输出你的推理过程和最终答案：

{
  "reasoning_steps": [
    {"step": 1, "action": "识别关键信息", "result": "..."},
    {"step": 2, "action": "...", "result": "..."}
  ],
  "final_answer": "...",
  "confidence": 0.95
}

5. CoT 的适用边界 ​

5.1 什么时候使用 CoT ​

5.2 CoT 的局限性 ​

1. 不能修复错误的前提

问题：如果 1+1=3，那么 2+2 等于多少？
CoT 输出：
1. 根据题目，1+1=3
2. 所以 2+2 = (1+1) + (1+1) = 3 + 3 = 6
答案：6

[即使推理过程"正确"，但基于错误前提]

2. 增加 Token 消耗和延迟

• CoT 输出的 Token 数通常是直接回答的 3-10 倍
• 对于高频、简单任务，成本增加不可忽视

3. 可能引入"虚假推理"

• 模型可能生成看起来合理但实际无效的推理步骤
• 推理链的存在不等于推理的正确性

4. 对某些任务无效

• 依赖隐性知识/直觉的任务
• 需要实时信息的任务
• 纯粹的信息检索任务

6. 实战案例 ​

6.1 代码审查中的 CoT ​

请逐步分析这段代码的潜在问题：

```python
def process_user_input(user_id, data):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    result = db.execute(query)
    return eval(data)

分析步骤：

1. 首先检查安全问题
2. 然后检查性能问题
3. 最后检查代码规范

### 6.2 数据分析中的 CoT

```markdown
以下是某电商网站的月度数据。请分析销售趋势。

| 月份 | 销售额 | 订单数 | 客单价 |
|------|--------|--------|--------|
| 1月  | 100万  | 2000   | 500    |
| 2月  | 80万   | 1800   | 444    |
| 3月  | 120万  | 2200   | 545    |

分析步骤：
1. 计算各指标的环比变化
2. 识别异常数据点
3. 分析可能的原因
4. 给出改进建议

7. 本章小结 ​

实践建议：

1. 从零样本 CoT 开始尝试
2. 对于特定领域，编写高质量的 Few-shot 示例
3. 重要任务结合自我一致性使用
4. 监控 Token 消耗，权衡成本和准确性

练习 ​

1. 对于以下问题，设计一个 Few-shot CoT 提示词： "一个水池有两个进水管和一个出水管。单独使用进水管A需要6小时注满，进水管B需要4小时注满，出水管需要12小时放空。如果三管同时开启，需要多长时间注满水池？"

2. 尝试 Tree of Thoughts 的思想：对于"如何在 3 个月内学会一门新的编程语言"这个问题，画出至少 3 个不同的思路分支，并评估每个分支的可行性。

3. 找一个你之前用 AI 解决但效果不好的推理问题，尝试用 CoT 方法重新提问，比较效果差异。