思维链（CoT）工程实践

思维链（Chain of Thought）通过引导模型逐步推理，显著提升复杂任务的准确性。

一、核心概念

1.1 什么是 CoT

CoT = Chain of Thought

原理：
引导模型展示推理过程，而非直接给出答案

效果：
- 数学推理提升 2-3 倍
- 逻辑推理提升 1.5-2 倍
- 复杂任务效果显著

1.2 Zero-Shot vs Few-Shot

# Zero-Shot CoT
prompt = """
问题：小明有 5 个苹果，给了小红 2 个，又买了 3 个，现在有几个？

请一步步思考：
"""

# Few-Shot CoT
prompt = """
示例 1：
问题：小明有 5 个苹果，给了小红 2 个，现在有几个？
思考：
1. 初始有 5 个苹果
2. 给了小红 2 个
3. 5 - 2 = 3
答案：3 个

示例 2：
问题：小红有 3 个橘子，又买了 5 个，现在有几个？
思考：
1. 初始有 3 个橘子
2. 又买了 5 个
3. 3 + 5 = 8
答案：8 个

问题：小明有 5 个苹果，给了小红 2 个，又买了 3 个，现在有几个？
思考：
"""

二、实现模式

2.1 标准 CoT

def standard_cot(question: str) -> str:
    prompt = f"""
请逐步推理以下问题：

问题：{question}

推理步骤：
1. 
"""
    response = llm.generate(prompt)
    return extract_answer(response)

2.2 验证链

def verification_chain(question: str) -> str:
    # 第一步：生成答案
    answer_prompt = f"""
问题：{question}

请一步步推理并给出答案。
"""
    answer = llm.generate(answer_prompt)
    
    # 第二步：验证答案
    verify_prompt = f"""
问题：{question}
答案：{answer}

请验证上述答案是否正确：
1. 检查推理过程
2. 检查计算
3. 检查逻辑
"""
    verification = llm.generate(verify_prompt)
    
    return answer, verification

2.3 自洽性检查

def self_consistency(question: str, n: int = 5) -> str:
    # 生成多个推理路径
    answers = []
    for i in range(n):
        prompt = f"""
问题：{question}

请一步步推理（路径{i+1}）：
"""
        response = llm.generate(prompt)
        answers.append(extract_answer(response))
    
    # 投票选择
    from collections import Counter
    most_common = Counter(answers).most_common(1)[0][0]
    
    return most_common

三、高级技巧

3.1 分解复杂问题

def decompose_question(question: str) -> list:
    # 让模型分解问题
    prompt = f"""
请将以下复杂问题分解为多个简单子问题：

问题：{question}

子问题：
1. 
2. 
3. 
"""
    response = llm.generate(prompt)
    return parse_subquestions(response)

def solve_decomposed(question: str) -> str:
    # 分解问题
    subquestions = decompose_question(question)
    
    # 逐个解决
    answers = []
    for subq in subquestions:
        answer = solve_simple(subq)
        answers.append(answer)
    
    # 综合答案
    final_prompt = f"""
原问题：{question}

子问题答案：
{format_answers(answers)}

请综合以上答案，给出最终答案。
"""
    return llm.generate(final_prompt)

3.2 反思机制

def reflection_chain(question: str) -> str:
    # 第一次尝试
    attempt1 = generate_answer(question)
    
    # 反思
    reflection_prompt = f"""
问题：{question}
答案：{attempt1}

请反思上述答案：
1. 是否有遗漏的信息？
2. 推理是否有漏洞？
3. 是否有更好的解法？
"""
    reflection = llm.generate(reflection_prompt)
    
    # 改进答案
    improved_prompt = f"""
问题：{question}
初始答案：{attempt1}
反思：{reflection}

请根据反思改进答案。
"""
    improved = llm.generate(improved_prompt)
    
    return improved

四、评估方法

4.1 准确性评估

def evaluate_cot(question: str, answer: str, expected: str) -> dict:
    return {
        "correct": answer == expected,
        "reasoning_quality": rate_reasoning(answer),
        "step_count": count_steps(answer),
        "consistency": check_consistency(answer)
    }

def rate_reasoning(answer: str) -> int:
    # 1-5 分评分
    criteria = [
        "步骤清晰",
        "逻辑连贯",
        "无跳跃",
        "可验证"
    ]
    score = sum(check_criterion(answer, c) for c in criteria)
    return score

4.2 A/B 测试

def ab_test_cot(test_set: list) -> dict:
    results = {
        "standard": [],
        "cot": [],
        "cot_with_verification": []
    }
    
    for item in test_set:
        # 标准方法
        ans_std = llm.generate(item["question"])
        results["standard"].append(ans_std == item["answer"])
        
        # CoT 方法
        ans_cot = generate_cot(item["question"])
        results["cot"].append(ans_cot == item["answer"])
        
        # CoT + 验证
        ans_cot_v = generate_cot_verified(item["question"])
        results["cot_with_verification"].append(ans_cot_v == item["answer"])
    
    return {
        k: sum(v) / len(v) 
        for k, v in results.items()
    }

五、最佳实践

5.1 Prompt 设计

# ✅ 推荐：明确的步骤指示
COT_TEMPLATE = """
请按照以下步骤解决问题：

步骤 1：理解问题
- 识别已知条件
- 识别求解目标

步骤 2：制定计划
- 选择合适的解题方法
- 列出解题步骤

步骤 3：执行计算
- 逐步计算
- 检查每步结果

步骤 4：验证答案
- 检查是否符合题意
- 检查计算是否正确

问题：{question}
"""

5.2 错误处理

def robust_cot(question: str, max_retries: int = 3) -> str:
    for i in range(max_retries):
        try:
            answer = generate_cot(question)
            
            # 验证答案格式
            if not validate_answer_format(answer):
                continue
            
            # 验证逻辑一致性
            if not check_logical_consistency(answer):
                continue
            
            return answer
            
        except Exception as e:
            log_error(e)
    
    # 所有尝试失败，返回标准答案
    return llm.generate(question)

5.3 性能优化

# 缓存推理结果
from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_cot(question_hash: str) -> str:
    return generate_cot(question_hash)

# 并行生成多个推理路径
async def parallel_cot(question: str, n: int = 5) -> list:
    tasks = [generate_cot_async(question) for _ in range(n)]
    return await asyncio.gather(*tasks)

六、总结

CoT 工程核心要点：

CoT 是提升大模型推理能力的有效方法，关键是设计合理的推理步骤和验证机制。