Chain of Thought 精通：从零到推理增强

# 标准 Prompt（直接输出）
Q: 小明有 23 个苹果，吃了 3 个，又买了 12 个。他有多少个苹果？
A: 32

# CoT Prompt（展示推理步骤）
Q: 小明有 23 个苹果，吃了 3 个，又买了 12 个。他有多少个苹果？
A: 小明开始有 23 个苹果。吃了 3 个之后，剩余 23 - 3 = 20 个。又买了 12 个后，总数为 20 + 12 = 32 个。所以答案是 32。

Prompt: 如果 5 个工人 5 小时能挖 5 个洞，那么 10 个工人 10 小时能挖多少个洞？让我们一步步思考。

模型输出: 5 个工人 5 小时挖 5 个洞 → 每个工人每小时挖 5/(5×5)=0.2 个洞。
10 个工人 10 小时能挖 10×10×0.2 = 20 个洞。答案是 20。

# Few-shot CoT Prompt 结构
prompt = """Q: 一个篮球 120 元，一个足球比篮球贵 30 元，一副羽毛球拍比足球便宜 50 元。羽毛球拍多少钱？
A: 篮球价格 = 120 元。足球价格 = 120 + 30 = 150 元。
羽毛球拍价格 = 150 - 50 = 100 元。答案是 100。

Q: 图书馆有 3 层书架，每层 120 本书。周一借出 45 本，周二还回 28 本，周三借出 67 本。还剩多少本？
A: 总书数 = 3 × 120 = 360 本。
剩余 = 360 - 45 + 28 - 67 = 276 本。答案是 276。

Q: 一条绳子对折 3 次后每段长 15 厘米，绳子原来多长？
A: 对折 1 次 = 2 段，对折 2 次 = 4 段，对折 3 次 = 8 段。
原长 = 15 × 8 = 120 厘米。答案是 120。"""

import json
from openai import OpenAI

client = OpenAI()

def auto_cot(question: str) -> str:
    # Step 1: 生成演示示例
    demo_questions = [
        "小明有 10 元，花了 3 元买笔，又得到 5 元零花钱，现在有多少元？",
        "一个正方形周长 36 厘米，面积是多少？",
    ]
    
    demonstrations = []
    for q in demo_questions:
        resp = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "user", "content": f"{q}\n让我们一步步思考。"}
            ]
        )
        demonstrations.append(f"Q: {q}\nA: {resp.choices[0].message.content}")
    
    # Step 2: 用生成的示例回答目标问题
    full_prompt = "\n\n".join(demonstrations) + f"\n\nQ: {question}\nA:"
    
    final_resp = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": full_prompt}]
    )
    return final_resp.choices[0].message.content

def self_consistency(question: str, n_samples: int = 5, temperature: float = 0.7):
    answers = []
    for _ in range(n_samples):
        resp = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": f"{question}\n让我们一步步思考。"}],
            temperature=temperature
        )
        # 提取最终答案（简化版）
        full_text = resp.choices[0].message.content
        # 假设最后一行包含答案
        final_ans = full_text.strip().split("\n")[-1]
        answers.append(final_ans)
    
    # 多数投票
    from collections import Counter
    most_common = Counter(answers).most_common(1)[0][0]
    return most_common

# 示例
result = self_consistency("从 1 到 100 中，所有能被 3 或 5 整除的数之和是多少？")
print(f"最终答案: {result}")

import math

def cot_with_calculator(question: str) -> str:
    """
    CoT + 计算器：模型生成推理步骤，实际计算由代码完成
    """
    system_prompt = """你是一个带计算器的推理助手。请遵循以下格式：
推理: <你的推理过程>
计算: <需要计算的表达式>
...
最终答案: <数值结果>"""
    
    resp = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": question}
        ],
        temperature=0
    )
    
    text = resp.choices[0].message.content
    
    # 提取所有计算步骤并验证
    import re
    calculations = re.findall(r"计算:\s*(.+)", text)
    for calc in calculations:
        try:
            result = eval(calc, {"__builtins__": {}}, {"math": math})
            print(f"验证: {calc} = {result}")
        except:
            print(f"计算失败: {calc}")
    
    return text

你是一个逐步推理的助手。对于每个问题：

1. **理解**：用自己的话重述问题，确认理解正确
2. **分解**：将问题拆解为独立的子问题
3. **推理**：逐一解决每个子问题，展示中间结果
4. **整合**：汇总所有子问题的结果
5. **验证**：反向验证答案是否合理
6. **答案**：给出最终结论

请遵循以下格式：

问题: <用户问题>
理解: ...
分解: ...
推理: ...
整合: ...
验证: ...
答案: <最终结果>

def adaptive_cot(question: str) -> str:
    """根据问题复杂度自动选择推理策略"""
    
    # 判断复杂度
    word_count = len(question)
    has_numbers = any(c.isdigit() for c in question)
    has_conditions = any(kw in question for kw in ["如果", "假设", "条件", "unless", "if"])
    
    # 简单问题 → 直接回答
    if word_count < 20 and not has_numbers and not has_conditions:
        return direct_answer(question)
    
    # 中等问题 → Zero-shot CoT
    if word_count < 60 and has_numbers:
        return zero_shot_cot(question)
    
    # 复杂问题 → Few-shot CoT + Self-Consistency
    return self_consistency(question, n_samples=3, temperature=0.5)