思维链基础概念 #

┌─────────────────────────────────────────────────────────────┐
│                    核心术语表                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  术语              英文                  说明               │
│  ─────────────────────────────────────────────────────     │
│  思维链            Chain of Thought      逐步推理的提示技术 │
│  推理步骤          Reasoning Step        单个思考步骤       │
│  中间结论          Intermediate Result   步骤间的过渡结果   │
│  触发语            Trigger Phrase        激发思维链的短语   │
│  示例              Demonstration         Few-shot 中的范例  │
│  推理路径          Reasoning Path        完整的推理过程     │
│  自我一致性        Self-Consistency      多路径投票机制     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

推理步骤 (Reasoning Step)
├── 定义：思维链中的单个思考单元
├── 特点：有明确的输入和输出
└── 示例："计算小明拿走的苹果数：15 × 1/3 = 5"

中间结论 (Intermediate Result)
├── 定义：推理过程中产生的过渡性结论
├── 作用：连接前后步骤，支撑最终答案
└── 示例："小明拿走后剩余 10 个苹果"

触发语 (Trigger Phrase)
├── 定义：激发模型生成思维链的短语
├── 常见形式："Let's think step by step"
└── 作用：引导模型进入推理模式

┌─────────────────────────────────────────────────────────────┐
│                    思维链标准结构                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  [问题理解]                                                 │
│     │                                                       │
│     ▼                                                       │
│  [步骤1：分析已知条件]                                       │
│     │                                                       │
│     ▼                                                       │
│  [步骤2：应用相关知识]                                       │
│     │                                                       │
│     ▼                                                       │
│  [步骤3：计算/推理]                                         │
│     │                                                       │
│     ▼                                                       │
│  [步骤4：验证结果]                                          │
│     │                                                       │
│     ▼                                                       │
│  [最终答案]                                                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

问题：一个长方形花园，长 12 米，宽 8 米，
      如果要在周围围上栅栏，需要多少米栅栏？

思维链：

[问题理解]
需要计算长方形的周长

[步骤1：分析已知条件]
- 长方形的长：12 米
- 长方形的宽：8 米
- 需要计算：周长

[步骤2：应用相关知识]
长方形周长公式：周长 = 2 × (长 + 宽)

[步骤3：计算]
周长 = 2 × (12 + 8)
     = 2 × 20
     = 40 米

[步骤4：验证]
长边：12 × 2 = 24 米
宽边：8 × 2 = 16 米
总计：24 + 16 = 40 米 ✓

[最终答案]
需要 40 米栅栏。

┌─────────────────────────────────────────────────────────────┐
│                    Zero-shot CoT 模板                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  [问题描述]                                                 │
│                                                             │
│  Let's think step by step.                                  │
│  （或：让我们一步步思考。）                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# Python 代码示例
question = """
一个商店有 120 个苹果，第一天卖出了 1/4，
第二天卖出了剩余的 1/3，还剩多少个苹果？
"""

prompt = f"""
{question}

Let's think step by step.
"""

# 模型输出：
# 让我们一步步思考：
# 
# 步骤1：计算第一天卖出的苹果数
# 第一天卖出：120 × 1/4 = 30 个
# 剩余：120 - 30 = 90 个
# 
# 步骤2：计算第二天卖出的苹果数
# 第二天卖出：90 × 1/3 = 30 个
# 剩余：90 - 30 = 60 个
# 
# 答案：还剩 60 个苹果。

英文触发语：
├── "Let's think step by step."
├── "Let's work this out step by step."
├── "Let's think through this carefully."
├── "Let's break this down."
└── "First, let's analyze the problem."

中文触发语：
├── "让我们一步步思考。"
├── "让我们逐步分析这个问题。"
├── "请详细说明你的推理过程。"
├── "让我们分解这个问题。"
└── "首先，让我们理解问题。"

┌─────────────────────────────────────────────────────────────┐
│                    Few-shot CoT 模板                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  示例1：                                                     │
│  问题：[示例问题1]                                          │
│  回答：[带推理步骤的回答1]                                   │
│                                                             │
│  示例2：                                                     │
│  问题：[示例问题2]                                          │
│  回答：[带推理步骤的回答2]                                   │
│                                                             │
│  示例3：                                                     │
│  问题：[示例问题3]                                          │
│  回答：[带推理步骤的回答3]                                   │
│                                                             │
│  问题：[实际问题]                                           │
│  回答：                                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

prompt = """
问题：停车场有 15 辆车，开走了 3 辆，又开来了 7 辆，现在有几辆？
回答：停车场原来有 15 辆车。开走了 3 辆，剩下 15 - 3 = 12 辆。
      又开来了 7 辆，现在有 12 + 7 = 19 辆。答案是 19。

问题：一本书有 240 页，小明第一天读了 1/4，第二天读了剩余的 1/3，
      两天共读了多少页？
回答：第一天读了 240 × 1/4 = 60 页。剩余 240 - 60 = 180 页。
      第二天读了 180 × 1/3 = 60 页。
      两天共读了 60 + 60 = 120 页。答案是 120。

问题：一个水箱容量是 500 升，先注入了 3/5 的水，
      然后用掉了 100 升，水箱里还剩多少升水？
回答：
"""

# 模型输出：
# 水箱容量是 500 升。
# 注入了 500 × 3/5 = 300 升水。
# 用掉了 100 升，剩余 300 - 100 = 200 升。
# 答案是 200 升。

❌ 不好的问题：
"算一下那个东西"

✅ 好的问题：
"一个长方形游泳池，长 25 米，宽 10 米，深 2 米。
  计算游泳池的容积是多少立方米？"

❌ 步骤过于粗糙：
步骤1：计算结果 = 25 × 10 × 2 = 500 立方米

✅ 步骤划分合理：
步骤1：确定计算公式
       容积 = 长 × 宽 × 深

步骤2：代入数值
       容积 = 25 × 10 × 2

步骤3：计算结果
       容积 = 500 立方米

❌ 推理逻辑不清晰：
"因为是这样，所以那样"

✅ 推理逻辑清晰：
"因为长方形的对边相等，
 所以周长 = 2 × (长 + 宽)"

❌ 缺少验证：
"答案是 500"

✅ 包含验证：
"答案是 500 立方米。

验证：
长 × 宽 × 深 = 25 × 10 × 2 = 500 ✓"

┌─────────────────────────────────────────────────────────────┐
│                    模型规模与 CoT 效果                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  模型参数量        CoT 效果          建议                   │
│  ─────────────────────────────────────────────────────     │
│  < 10B            效果有限          不推荐使用              │
│  10B - 70B        效果一般          可尝试使用              │
│  70B - 175B       效果较好          推荐使用                │
│  > 175B           效果显著          强烈推荐                │
│                                                             │
│  结论：模型越大，思维链效果越明显                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘

适合思维链的任务：
┌─────────────────────────────────────────────────────────┐
│                                                         │
│  ✅ 多步骤推理任务                                       │
│     数学应用题、逻辑推理题                               │
│                                                         │
│  ✅ 需要中间结论的任务                                   │
│     复杂计算、多条件判断                                 │
│                                                         │
│  ✅ 可分解的复杂任务                                     │
│     方案设计、问题分析                                   │
│                                                         │
│  ✅ 需要解释性的任务                                     │
│     决策分析、问题诊断                                   │
│                                                         │
└─────────────────────────────────────────────────────────┘

不适合思维链的任务：
┌─────────────────────────────────────────────────────────┐
│                                                         │
│  ❌ 单步骤简单任务                                       │
│     简单计算、直接检索                                   │
│                                                         │
│  ❌ 创意生成任务                                         │
│     写作、绘画、音乐创作                                 │
│                                                         │
│  ❌ 高度主观的任务                                       │
│     情感表达、审美判断                                   │
│                                                         │
│  ❌ 资源受限场景                                         │
│     低延迟、低成本要求                                   │
│                                                         │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                    思维链质量评估                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  维度1：正确性                                              │
│  ├── 最终答案是否正确                                      │
│  └── 推理步骤是否正确                                      │
│                                                             │
│  维度2：完整性                                              │
│  ├── 是否覆盖所有必要步骤                                  │
│  └── 是否遗漏关键信息                                      │
│                                                             │
│  维度3：连贯性                                              │
│  ├── 步骤之间逻辑是否连贯                                  │
│  └── 推理链条是否完整                                      │
│                                                             │
│  维度4：清晰性                                              │
│  ├── 表述是否清晰易懂                                      │
│  └── 是否有歧义                                            │
│                                                             │
│  维度5：效率                                                │
│  ├── 步骤是否冗余                                          │
│  └── 是否有不必要的计算                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

问题：小明有 50 元，买了 3 支铅笔，每支 2 元，
      还买了一本笔记本 15 元，还剩多少钱？

思维链A（高质量）：
步骤1：计算铅笔花费
       3 × 2 = 6 元

步骤2：计算总花费
       6 + 15 = 21 元

步骤3：计算剩余
       50 - 21 = 29 元

答案：还剩 29 元。

评估：
- 正确性：✅ 答案和步骤都正确
- 完整性：✅ 覆盖所有必要步骤
- 连贯性：✅ 逻辑清晰连贯
- 清晰性：✅ 表述清晰
- 效率：✅ 无冗余步骤

思维链B（低质量）：
小明买了东西，花了钱，还剩 29 元。

评估：
- 正确性：✅ 答案正确
- 完整性：❌ 缺少计算步骤
- 连贯性：❌ 逻辑跳跃
- 清晰性：⚠️ 表述模糊
- 效率：⚠️ 信息不足

问题表现：
步骤中的计算或逻辑出现错误

解决方案：
1. 使用 Self-Consistency 生成多条路径
2. 添加验证步骤
3. 使用更清晰的示例

示例：
问题：计算 23 × 15

错误思维链：
23 × 15 = 23 × 10 + 23 × 5 = 230 + 115 = 345 ❌

正确思维链：
步骤1：分解计算
       23 × 15 = 23 × (10 + 5)

步骤2：分别计算
       23 × 10 = 230
       23 × 5 = 115

步骤3：验证 23 × 5
       23 × 5 = 20 × 5 + 3 × 5 = 100 + 15 = 115 ✓

步骤4：求和
       230 + 115 = 345

答案：345

问题表现：
推理步骤过多，包含不必要的信息

解决方案：
1. 精简示例
2. 明确要求简洁
3. 优化提示词

示例：
冗长版本：
让我仔细思考这个问题。首先，我需要理解题目在问什么。
题目问的是 2 + 2 等于多少。这是一个加法运算。
加法是将两个数合并的过程。让我来计算一下。
2 加上 2，就是从 2 开始，往后数 2 个数。
2 后面是 3，再后面是 4。所以答案是 4。

简洁版本：
2 + 2 = 4

问题表现：
不同问题的思维链格式不一致

解决方案：
使用统一的模板

模板示例：
步骤1：[分析已知条件]
步骤2：[应用相关公式/知识]
步骤3：[计算/推理]
步骤4：[验证结果]
答案：[最终答案]

┌─────────────────────────────────────────────────────────────┐
│                    思维链最佳实践                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 选择合适的方法                                          │
│     ├── 简单问题：Zero-shot CoT                            │
│     └── 复杂问题：Few-shot CoT                             │
│                                                             │
│  2. 设计高质量示例                                          │
│     ├── 示例要有代表性                                     │
│     ├── 推理步骤要清晰                                     │
│     └── 格式要统一                                         │
│                                                             │
│  3. 合理划分步骤                                            │
│     ├── 每步一个明确的操作                                 │
│     ├── 步骤间有清晰的逻辑关系                             │
│     └── 避免过度细分或过度概括                             │
│                                                             │
│  4. 添加验证机制                                            │
│     ├── 关键步骤进行验证                                   │
│     ├── 最终结果进行检验                                   │
│     └── 使用 Self-Consistency                              │
│                                                             │
│  5. 持续优化                                                │
│     ├── 分析错误案例                                       │
│     ├── 改进示例和提示词                                   │
│     └── 积累高质量模板                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘