2024年SEO标题优化十大技巧

三大高级提示技巧全景速览：从示范到推理再到一致性

┌──────────────────────────────────────────────────────────────────┐│高级提示技巧全景图│├──────────────────────────────────────────────────────────────────┤│││Zero-shot（零样本） ││"无示例直接提问，测试模型基础能力"││→ 基础能力││││▼││││Few-shot（少样本）││"提供2–5个示例，引导模型模仿输出模式" ││→ 格式对齐、模式学习││││▼││││Chain-of-Thought（思维链）││"要求模型分步推理，展示中间过程后再给出答案" ││→ 推理能力大幅提升││││▼││││Self-Consistency（自一致性） ││"多次独立推理，投票选取出现频率最高的答案" ││→ 准确率进一步提升│││└──────────────────────────────────────────────────────────────────┘

上述四种技巧呈递进关系：Few‑shot 教会模型“执行格式”，CoT 迫使模型“理清逻辑”，Self‑Consistency 则让结果“更鲁棒”。

一、Few‑shot：用示范案例告诉模型“该怎么做”

1.1 核心思想

Few‑shot（少样本提示）是在 Prompt 中嵌入若干“输入→输出”对，使模型快速习得期望的输出模式。类比一下：培训新员工时，与其背诵操作手册，不如直接展示几个成功案例，上手效率更高。

1.2 Zero‑shot vs Few‑shot

❌ Zero‑shot（无示例）:"判断以下评论的情感倾向：- 这个产品真的太好用了- 第三次坏了，再也不会买"→ 模型可能输出格式不统一，或判断标准波动✅ Few‑shot（带示例）:"判断用户评论的情感倾向，输出：positive / negative / neutral示例：- "物流很快，包装也很好" → positive- "第三次坏了，再也不会买" → negative- "今天收到货了" → neutral现在判断：- "这个产品真的太好用了" →- "第三次坏了，再也不会买" →"

1.3 Few‑shot 的效果提升

1.4 Few‑shot 的最佳实践

# ============ Few‑shot 模板 ============# 技巧 1：示例数量控制在 2‑5 个# 太少学不会，太多浪费 token 且边际收益递减# 技巧 2：示例要覆盖多样性few_shot_examples = {"情感分类": [# 正面 - 长评论{"input": "用了三个月了，续航很给力，拍照也清晰，强烈推荐！", "output": "positive"},# 正面 - 短评论{"input": "不错，满意", "output": "positive"},# 负面 - 具体问题{"input": "屏幕有亮点，客服说正常现象，但我觉得不应该", "output": "negative"},# 中性 - 客观描述{"input": "今天到货了，还没拆封", "output": "neutral"},],}# 技巧 3：用分隔符区分示例和待处理内容prompt_template = """{instruction}{examples}{user_input}"""# 技巧 4：示例的格式要和期望输出完全一致# 如果你期望 JSON 输出，示例就必须是 JSON

1.5 Few‑shot 的局限性

Few-shot 并非万能❌ 无法有效处理的场景： • 需复杂推理的任务（数学、逻辑）• 模型训练语料中极少出现的领域 • 依赖大量外部知识的任务✅ 擅长的场景：• 格式对齐（输出 JSON、表格、特定模板）• 模式学习（分类、提取、转换）• 风格模仿（语气、用词习惯）

二、Chain‑of‑Thought：让模型“想明白再作答”

2.1 核心思想

Chain‑of‑Thought（思维链，简称 CoT）是 2022 年 Google 提出的提示技术（论文：Chain‑of‑Thought Prompting Elicits Reasoning in Large Language Models）。核心理念极其简单：引导模型先写出推理步骤，再给出最终答案。就像数学考试，直接写答案容易出错；先列算式再写结果，正确率明显提高。

2.2 Zero‑shot CoT：最简化的用法

你甚至不需要提供示例，只需在 Prompt 末尾添加一句话：

"请一步步思考。""Let's think step by step.""请先分析，再给出结论。""请详细说明你的推理过程。"

仅此一步，效果却非常显著：

❌ 不加 CoT:"一个水池有两个水管，A 管单独注水 6 小时注满，B 管单独排水 8 小时排完。如果同时打开两管，多久注满？"→ 模型可能直接猜："14小时"（错误）✅ 加 CoT:"一个水池有两个水管，A 管单独注水 6 小时注满，B 管单独排水 8 小时排完。如果同时打开两管，多久注满？请一步步计算。"→ 模型会：1. A 管每小时注水：1/62. B 管每小时排水：1/83. 同时打开，每小时净注水：1/6 - 1/8 = 1/244. 注满需要：1 ÷ 1/24 = 24 小时→ "24小时"（正确）

2.3 Few‑shot CoT：更强力的用法

给模型展示“推理过程 + 最终答案”的完整示例：

Q: 小明有 23 个苹果，给了小红 1/3，又买了 6 个，还剩多少个？A: [思考过程] 原有 23 个苹果。 给小红 1/3：23 × 1/3 ≈ 7.67 个。因为苹果不能分，给 7 个，剩下 16 个。 又买了 6 个：16 + 6 = 22 个。 [最终答案] 22 个。Q: 一列火车 3 小时行驶 360 公里，前 1.5 小时的速度是后 1.5 小时的 2 倍， 求前后两段的速度分别是多少？A: [思考过程] 设后 1.5 小时的速度为 x 公里/小时，则前 1.5 小时的速度为 2x。 总路程 = 前段 + 后段 360 = 2x × 1.5 + x × 1.5 360 = 3x + 1.5x 360 = 4.5x x = 80 所以后段 80 公里/小时，前段 160 公里/小时。 [最终答案] 前 1.5 小时 160 公里/小时，后 1.5 小时 80 公里/小时。Q: 一件商品先涨价 20%，再打 8 折，最终价格是原价的百分之几？A:

2.4 CoT 为什么有效？

CoT 有效的三个原因 ① 分解问题复杂问题被拆成多个小步骤，每步更简单→ 每步出错的概率更低 ② 中间状态可验证推理过程中产生的中间结果可以被"检查"→ 如果某一步错了，后面的步骤可能会自我纠正③ 更多"思考时间" 生成推理过程需要更多 token→ 等于给了模型更多"计算空间"来处理问题

2.5 CoT 的代码实现

import openaidef cot_prompt(question: str, few_shot_examples: list = None) -> str:"""CoT 提示函数支持零样本 CoT 和少样本 CoT"""if few_shot_examples:# Few-shot CoT：包含推理过程的示例examples_text = ""for ex in few_shot_examples:examples_text += f"Q: {ex['question']}nA: {ex['reasoning']}nn"prompt = f"{examples_text}Q: {question}nA:"else:# Zero-shot CoT：只加一句引导语prompt = f"{question}nn请一步步思考，先给出推理过程，再给出最终答案。"response = openai.chat.completions.create(model="gpt-4",messages=[{"role": "system", "content": "你是一个善于推理的AI助手。回答问题时，请先展示详细的推理过程，最后用【最终答案】给出结论。"},{"role": "user", "content": prompt}],temperature=0.3,# CoT 场景建议低温度)return response.choices[0].message.content# ============ 使用示例 ============# Zero-shot CoTresult = cot_prompt("一件商品先涨价20%再打8折，最终价格是原价的百分之几？")# Few-shot CoTexamples = [{"question": "小明有15个苹果，给了小红1/3，又买了6个，还剩多少个？","reasoning": "原有15个。给小红1/3：15×1/3=5个，剩10个。又买6个：10+6=16个。n【最终答案】16个"},{"question": "一个水池A管6小时注满，B管8小时排完，同时开多久注满？","reasoning": "A管每小时注1/6，B管每小时排1/8。同时开：1/6-1/8=1/24。注满需要1÷1/24=24小时。n【最终答案】24小时"}]result = cot_prompt("一件商品先涨价20%再打8折，最终价格是原价的百分之几？", examples)

2.6 CoT 的最佳实践

三、Self‑Consistency：多次推理，少数服从多数

3.1 核心思想

Self‑Consistency（自一致性）是 2022 年提出的进阶技术（论文：Self‑Consistency Improves Chain of Thought Reasoning in Language Models）。核心思路：对同一问题，让模型用 CoT 进行多次独立推理，然后统计各答案的出现频率，选择频次最高的作为最终结果。好比考试做选择题，你算了一遍答案是 A，不太确定；又算一遍还是 A；再算一遍仍然是 A——这时你有十足的信心选 A。

3.2 为什么需要 Self‑Consistency？

CoT 虽然显著提升了推理能力，但模型每次的推理路径并不唯一。同一道数学题，模型可能用不同思路求解：

• 路径 1：先算 A，再算 B → 答案 42 ✅
• 路径 2：先算 C，再算 D → 答案 42 ✅
• 路径 3：某个中间步骤算错了 → 答案 38 ❌

如果只推理一次，恰巧走了路径 3，就会出错。但如果推理 5 次，3 次得到 42，2 次得到 38，取多数答案 42，正确率就上来了。

3.3 Self‑Consistency 的三步流程

┌─────────────────────────────────────────────────────────────┐│Self-Consistency 三步流程 │├─────────────────────────────────────────────────────────────┤│ ││第一步：生成多条推理路径││═════════════════════════════││用 CoT Prompt + 较高的 Temperature，生成 N 个回答 ││（N 通常取 5~40）││ ││▼││ ││第二步：提取每个回答的最终答案 ││═════════════════════════════││从每条推理路径中提取出最终答案（数字/选项/标签） ││ ││▼││ ││第三步：投票选多数││═════════════════════════════││统计每个答案出现的次数，取最多的作为最终结果││ │└─────────────────────────────────────────────────────────────┘

3.4 代码实现

import openaifrom collections import Counterdef self_consistency(question: str, n_samples: int = 10) -> dict:"""Self-Consistency 实现1. 用 CoT 生成多条推理路径2. 提取最终答案3. 投票选多数"""cot_prompt = f"""{question}请一步步思考，先给出详细的推理过程，最后用【最终答案】给出结论。"""# 第一步：生成多条推理路径# 注意：这里用较高的 temperature 来增加多样性reasoning_paths = []for i in range(n_samples):response = openai.chat.completions.create(model="gpt-4",messages=[{"role": "user", "content": cot_prompt}],temperature=0.7,# 较高温度 → 不同推理路径)reasoning_paths.append(response.choices[0].message.content)# 第二步：提取最终答案answers = []for path in reasoning_paths:# 从推理路径中提取【最终答案】后面的内容if "【最终答案】" in path:answer = path.split("【最终答案】")[-1].strip()elif "最终答案" in path:answer = path.split("最终答案")[-1].strip()else:answer = path.strip()# fallback：取最后一行answers.append(answer)# 第三步：投票选多数answer_counts = Counter(answers)most_common = answer_counts.most_common(1)[0]return {"question": question,"final_answer": most_common[0],"confidence": most_common[1] / n_samples,# 置信度 = 多数票占比"answer_distribution": dict(answer_counts),"all_reasoning_paths": reasoning_paths,}# ============ 使用示例 ============result = self_consistency("一个水池A管6小时注满，B管8小时排完，同时开多久注满？",n_samples=5)print(f"最终答案: {result['final_answer']}")print(f"置信度: {result['confidence']:.0%}")print(f"答案分布: {result['answer_distribution']}")# 最终答案: 24小时# 置信度: 80%(5次中有4次得到正确答案)# 答案分布: {'24小时': 4, '12小时': 1}

3.5 效果对比

3.6 Self‑Consistency 的权衡

┌─────────────────────────────────────────────────────────────┐│Self‑Consistency 的成本与收益 │├─────────────────────────────────────────────────────────────┤│ ││采样次数 (N)准确率提升API 调用成本延迟││─────────────────────────────────────────────││1 (仅 CoT)基准1x低 ││5+5~10%5x中 ││10 +8~12%10x 中高 ││20 +10~15% 20x 高 ││40 +12~17% 40x 很高 ││ ││? 推荐配置： ││• 日常使用：N = 5（性价比最高） ││• 重要任务：N = 10~20 ││• 关键决策：N = 20~40 ││ ││⚠️ 注意：N 越大，延迟越高，成本越高││可以通过并行请求来降低延迟 ││ │└─────────────────────────────────────────────────────────────┘

3.7 并行优化：降低延迟

import concurrent.futuresdef self_consistency_parallel(question: str, n_samples: int = 10) -> dict:"""并行版 Self‑Consistency用多线程同时发送请求，大幅降低总延迟"""def single_sample(i):response = openai.chat.completions.create(model="gpt-4",messages=[{"role": "user", "content": f"{question}nn请一步步思考，最后用【最终答案】给出结论。"}],temperature=0.7,)return response.choices[0].message.content# 并行发送所有请求with concurrent.futures.ThreadPoolExecutor(max_workers=n_samples) as executor:futures = [executor.submit(single_sample, i) for i in range(n_samples)]reasoning_paths = [f.result() for f in futures]# 提取答案 + 投票（同上）answers = []for path in reasoning_paths:if "【最终答案】" in path:answers.append(path.split("【最终答案】")[-1].strip())most_common = Counter(answers).most_common(1)[0]return {"final_answer": most_common[0],"confidence": most_common[1] / len(answers),"answer_distribution": dict(Counter(answers)),}

四、三大技巧组合使用

4.1 组合策略矩阵

4.2 终极组合：Few‑shot CoT + Self‑Consistency

这是目前最强的提示策略组合，特别适合高准确率要求的推理任务：

def advanced_reasoning(question: str, n_samples: int = 10) -> dict:"""终极组合：Few-shot CoT + Self-Consistency"""# Few-shot CoT 示例few_shot_cot = """Q: 一件商品原价 100 元，先涨价 25%，再打 8 折，最终价格是多少？A: [推理过程] 原价 100 元。 涨价 25%：100 × 1.25 = 125 元。 打 8 折：125 × 0.8 = 100 元。 [最终答案] 100 元Q: 小红有 50 元，买书花了 60% 的钱，又用剩下的钱买了一支笔花了 5 元，还剩多少？A: [推理过程] 原有 50 元。 买书花了 60%：50 × 0.6 = 30 元，剩下 20 元。 买笔花了 5 元：20 - 5 = 15 元。 [最终答案] 15 元"""prompt = f"""{few_shot_cot}Q: {question}A:"""# Self-Consistency：多次采样answers = []for _ in range(n_samples):response = openai.chat.completions.create(model="gpt-4",messages=[{"role": "user", "content": prompt}],temperature=0.7,# 需要多样性)content = response.choices[0].message.contentif "【最终答案】" in content:answers.append(content.split("【最终答案】")[-1].strip())most_common = Counter(answers).most_common(1)[0]return {"final_answer": most_common[0],"confidence": most_common[1] / len(answers),"distribution": dict(Counter(answers)),}

写在最后

三个高级技巧，本质上都在回答同一个问题：如何让模型“更聪明”？

• Few‑shot 解决的是“怎么做”——用示例教模型你想要的模式
• CoT 解决的是“想清楚”——让模型一步步推理，而不是直接猜答案
• Self‑Consistency 解决的是“更可靠”——多次推理取多数，降低偶然出错

记住一个原则：技巧越复杂，成本越高。不是所有场景都需要 Self‑Consistency，简单的分类任务用 Few‑shot 就够了。选择适合你场景的技巧，才是最高效的做法。

来源：互联网