提示工程最佳实践

1
prompt = """
2
从以下新闻中提取关键信息，以 JSON 格式输出：
3

4
新闻：
5
"特斯拉 CEO 埃隆·马斯克于 2024 年 10 月 15 日宣布，
6
公司将在德克萨斯州奥斯汀建立新的超级工厂，预计投资 50 亿美元。"
7

8
请提取：
9
{
10
  "公司": "",
11
  "CEO": "",
12
  "事件": "",
13
  "日期": "",
14
  "地点": "",
15
  "金额": ""
16
}
17
"""

1
你是一个情感分析专家。请判断句子的情感倾向。
2

3
示例：
4
句子：这家餐厅的服务很差。
5
情感：负面
6

7
句子：今天天气真不错！
8
情感：正面
9

10
句子：我买了一本书。
11
情感：中性
12

13
现在，请分析：
14
句子：这个产品性价比很高。
15
情感：

1
from sklearn.metrics.pairwise import cosine_similarity
2
import numpy as np
3

4
def select_few_shot_examples(query, example_pool, embeddings, k=3):
5
    """
6
    根据查询语句，从示例池中选择最相似的 k 个示例
7
    """
8
    query_embedding = get_embedding(query)
9

10
    # 计算相似度
11
    similarities = cosine_similarity([query_embedding], embeddings)[0]
12

13
    # 选择最相似的 k 个
14
    top_k_indices = np.argsort(similarities)[-k:][::-1]
15

16
    return [example_pool[i] for i in top_k_indices]
17

18
# 使用
19
examples = select_few_shot_examples(
20
    query="这款手机拍照效果很好",
21
    example_pool=all_labeled_examples,
22
    embeddings=all_embeddings,
23
    k=3
24
)

1
Q: 咖啡店里有 23 个苹果。如果他们用掉 20 个做午餐，又买了 6 个，现在有多少个？
2
A: 让我们一步步思考：
3
   开始有 23 个苹果
4
   用掉 20 个后：23 - 20 = 3 个
5
   又买了 6 个：3 + 6 = 9 个
6
   答案：9 个苹果
7

8
Q: Leah 有 32 颗巧克力，她姐姐有 42 颗。如果她们吃了 35 颗，还剩多少颗？
9
A: 让我们一步步思考：
10
   Leah 和姐姐总共：32 + 42 = 74 颗
11
   吃了 35 颗后：74 - 35 = 39 颗
12
   答案：39 颗
13

14
Q: Jason 有 20 个棒棒糖。他给 Denny 一些后，还剩 12 个。他给了 Denny 多少个？
15
A:

1
def self_consistency_cot(question, model, num_samples=5):
2
    prompt = f"{question}\n\nLet's think step by step."
3

4
    # 生成多个推理路径
5
    answers = []
6
    for _ in range(num_samples):
7
        response = model.generate(
8
            prompt,
9
            temperature=0.7,  # 增加随机性
10
            max_tokens=256
11
        )
12
        # 提取最终答案
13
        answer = extract_answer(response)
14
        answers.append(answer)
15

16
    # 多数投票
17
    from collections import Counter
18
    most_common = Counter(answers).most_common(1)[0][0]
19

20
    return most_common
21

22
# 使用
23
answer = self_consistency_cot(
24
    "一个数字的两倍加 5 等于 13，这个数字是多少？",
25
    model=gpt_model,
26
    num_samples=5
27
)

1
问题：Tom 有 5 个苹果，Mary 的苹果数是 Tom 的 3 倍，John 的苹果数是 Mary 的一半。
2
他们总共有多少个苹果？
3

4
让我们分解这个问题：
5

6
子问题 1：Mary 有多少个苹果？
7
- Tom 有 5 个
8
- Mary 是 Tom 的 3 倍：5 × 3 = 15 个
9

10
子问题 2：John 有多少个苹果？
11
- Mary 有 15 个
12
- John 是 Mary 的一半：15 ÷ 2 = 7.5 个（假设可以有半个）
13

14
最终问题：总共有多少个？
15
- Tom: 5 个
16
- Mary: 15 个
17
- John: 7.5 个
18
- 总计：5 + 15 + 7.5 = 27.5 个

1
def tree_of_thoughts(problem, model, depth=3, breadth=3):
2
    """
3
    在每一步生成多个可能的推理步骤，构建思维树
4
    """
5
    def explore(state, depth_left):
6
        if depth_left == 0:
7
            return evaluate_solution(state)
8

9
        # 生成 breadth 个下一步推理
10
        next_steps = model.generate_next_thoughts(state, k=breadth)
11

12
        # 递归探索每个分支
13
        results = []
14
        for step in next_steps:
15
            new_state = state + [step]
16
            score = explore(new_state, depth_left - 1)
17
            results.append((score, new_state))
18

19
        # 返回最佳分支
20
        return max(results, key=lambda x: x[0])
21

22
    return explore([], depth)

1
import re
2
from typing import List, Dict, Callable
3

4
class ReActAgent:
5
    def __init__(self, model, tools: Dict[str, Callable], max_steps=5):
6
        self.model = model
7
        self.tools = tools
8
        self.max_steps = max_steps
9

10
    def run(self, question: str) -> str:
11
        prompt = self._build_initial_prompt(question)
12

13
        for step in range(self.max_steps):
14
            # 生成下一步推理
15
            response = self.model.generate(prompt)
16

17
            # 解析 Thought 和 Action
18
            thought = self._extract_thought(response)
19
            action = self._extract_action(response)
20

21
            if "Final Answer:" in response:
22
                return self._extract_final_answer(response)
23

24
            # 执行 Action
25
            observation = self._execute_action(action)
26

27
            # 更新 prompt
28
            prompt += f"\nObservation {step+1}: {observation}\n"
29

30
        return "达到最大步数限制"
31

32
    def _execute_action(self, action: str) -> str:
33
        # 解析 Action[tool_name, input]
34
        match = re.search(r'(\w+)\[(.*?)\]', action)
35
        if match:
36
            tool_name, tool_input = match.groups()
37
            if tool_name in self.tools:
38
                return self.tools[tool_name](tool_input)
39
        return "无效的 Action"
40

41
    def _build_initial_prompt(self, question: str) -> str:
42
        tools_desc = "\n".join([
43
            f"- {name}: {func.__doc__}"
44
            for name, func in self.tools.items()
45
        ])
46

47
        return f"""
48
Answer the following question using this format:
49

50
Thought: [your reasoning]
51
Action: [tool_name[input]]
52
Observation: [result will be provided]
53
... (repeat Thought/Action/Observation)
54
Thought: I now know the final answer
55
Final Answer: [your final answer]
56

57
Available tools:
58
{tools_desc}
59

60
Question: {question}
61

62
Thought 1:"""
63

64
# 定义工具
65
def search(query: str) -> str:
66
    """Search the web for information"""
67
    # 实际实现中调用搜索 API
68
    return f"Search results for '{query}': ..."
69

70
def calculate(expression: str) -> str:
71
    """Evaluate a mathematical expression"""
72
    try:
73
        return str(eval(expression))
74
    except:
75
        return "Invalid expression"
76

77
def lookup(keyword: str) -> str:
78
    """Look up information in a knowledge base"""
79
    # 实际实现中查询数据库
80
    return f"Information about '{keyword}': ..."
81

82
# 使用
83
agent = ReActAgent(
84
    model=gpt_model,
85
    tools={
86
        "Search": search,
87
        "Calculate": calculate,
88
        "Lookup": lookup
89
    }
90
)
91

92
answer = agent.run("埃隆·马斯克的年龄的平方是多少？")

1
# 基础版本
2
prompt = "解释量子力学"
3

4
# 角色增强版本
5
prompt = """
6
你是一位获得诺贝尔物理学奖的量子力学专家，擅长用通俗易懂的语言
7
向非专业人士解释复杂概念。请用初中生能理解的方式解释量子力学。
8
"""
9

10
# 多角色对话
11
prompt = """
12
你将扮演三个角色进行对话：
13
1. 学生（好奇但缺乏背景知识）
14
2. 老师（耐心且善于类比）
15
3. 科学家（严谨且注重细节）
16

17
请围绕"什么是黑洞"展开一场对话。
18
"""

1
prompt = f"""
2
请分析以下产品评论的情感，并严格按照 JSON 格式输出：
3

4
评论："{review}"
5

6
输出格式（必须严格遵守）：
7
{% raw %}{{
8
  "sentiment": "positive/negative/neutral",
9
  "confidence": 0.0-1.0,
10
  "key_phrases": ["phrase1", "phrase2"],
11
  "summary": "一句话总结"
12
}}{% endraw %}
13

14
不要输出除 JSON 之外的任何内容。
15
"""

1
meta_prompt = """
2
我想要一个 prompt，能让 AI 模型生成高质量的产品描述。
3
这个 prompt 应该：
4
1. 包含产品的核心特性
5
2. 突出卖点
6
3. 引发情感共鸣
7
4. 控制在 100 字以内
8

9
请帮我设计这个 prompt。
10
"""
11

12
# 模型生成的 prompt：
13
generated_prompt = """
14
请为以下产品撰写吸引人的描述：
15

16
产品名称：{name}
17
核心特性：{features}
18
目标用户：{audience}
19

20
要求：
21
- 开头用一个引人注目的问题或场景
22
- 突出 2-3 个最重要的卖点
23
- 用感性语言描述使用体验
24
- 以行动号召结尾
25
- 总字数 80-100 字
26
"""

1
class PromptOptimizer:
2
    def __init__(self, model, eval_dataset):
3
        self.model = model
4
        self.eval_dataset = eval_dataset
5

6
    def optimize(self, initial_prompt, num_iterations=5):
7
        current_prompt = initial_prompt
8
        best_score = 0
9

10
        for i in range(num_iterations):
11
            # 1. 评估当前 prompt
12
            score = self.evaluate(current_prompt)
13
            print(f"Iteration {i+1}: Score = {score:.2f}")
14

15
            if score > best_score:
16
                best_score = score
17
                best_prompt = current_prompt
18

19
            # 2. 分析失败案例
20
            failures = self.get_failure_cases(current_prompt)
21

22
            # 3. 生成改进建议
23
            suggestions = self.generate_suggestions(
24
                current_prompt, failures
25
            )
26

27
            # 4. 修改 prompt
28
            current_prompt = self.apply_suggestions(
29
                current_prompt, suggestions
30
            )
31

32
        return best_prompt, best_score
33

34
    def evaluate(self, prompt):
35
        """在评估集上测试 prompt"""
36
        correct = 0
37
        for example in self.eval_dataset:
38
            response = self.model.generate(
39
                prompt.format(**example)
40
            )
41
            if self.is_correct(response, example['answer']):
42
                correct += 1
43
        return correct / len(self.eval_dataset)

1
import pandas as pd
2
from scipy import stats
3

4
class PromptABTest:
5
    def __init__(self, model, test_cases):
6
        self.model = model
7
        self.test_cases = test_cases
8

9
    def compare(self, prompt_a, prompt_b, metric='accuracy'):
10
        results_a = []
11
        results_b = []
12

13
        for case in self.test_cases:
14
            # 测试 Prompt A
15
            response_a = self.model.generate(prompt_a.format(**case))
16
            score_a = self.evaluate_response(response_a, case)
17
            results_a.append(score_a)
18

19
            # 测试 Prompt B
20
            response_b = self.model.generate(prompt_b.format(**case))
21
            score_b = self.evaluate_response(response_b, case)
22
            results_b.append(score_b)
23

24
        # 统计显著性检验
25
        t_stat, p_value = stats.ttest_rel(results_a, results_b)
26

27
        report = {
28
            'prompt_a_mean': np.mean(results_a),
29
            'prompt_b_mean': np.mean(results_b),
30
            'improvement': np.mean(results_b) - np.mean(results_a),
31
            'p_value': p_value,
32
            'significant': p_value < 0.05
33
        }
34

35
        return report
36

37
# 使用
38
tester = PromptABTest(model, test_cases)
39
result = tester.compare(
40
    prompt_a="Translate to French: {text}",
41
    prompt_b="You are a professional translator. Translate to French: {text}"
42
)
43
print(f"Improvement: {result['improvement']:.2%}")
44
print(f"Significant: {result['significant']}")

1
from promptflow import PromptTemplate, Optimizer
2

3
# 定义模板（带占位符）
4
template = PromptTemplate("""
5
{role_description}
6

7
Task: {task_description}
8

9
{few_shot_examples}
10

11
Input: {input}
12
Output:
13
""")
14

15
# 自动搜索最佳配置
16
optimizer = Optimizer(
17
    template=template,
18
    model=model,
19
    eval_dataset=eval_data,
20
    search_space={
21
        'role_description': [
22
            'You are an expert.',
23
            'You are a helpful assistant.',
24
            'You are a domain specialist.'
25
        ],
26
        'task_description': [
27
            'Classify the sentiment.',
28
            'Analyze the sentiment and explain.',
29
        ],
30
        'few_shot_examples': [0, 2, 4]  # 示例数量
31
    }
32
)
33

34
best_prompt = optimizer.optimize(
35
    metric='f1_score',
36
    num_trials=50
37
)

1
code_prompt = """
2
你是一位资深的 Python 工程师。请编写高质量、可维护的代码。
3

4
任务：{task_description}
5

6
要求：
7
1. 使用类型提示（type hints）
8
2. 添加 docstring 文档
9
3. 包含错误处理
10
4. 编写单元测试
11
5. 遵循 PEP 8 规范
12

13
示例格式：
14
```python
15
def function_name(param: Type) -> ReturnType:
16
    \"\"\"
17
    Function description.
18

19
    Args:
20
        param: Parameter description
21

22
    Returns:
23
        Return value description
24

25
    Raises:
26
        ExceptionType: When this exception occurs
27
    \"\"\"
28
    # Implementation
29
    pass

1
### 6.2 数据分析
2

3
```python
4
analysis_prompt = """
5
你是一位数据分析专家。请对以下数据进行分析：
6

7
数据：
8
{data}
9

10
分析要求：
11
1. 描述性统计（均值、中位数、标准差）
12
2. 识别异常值
13
3. 发现趋势和模式
14
4. 提出业务洞察
15
5. 给出可视化建议
16

17
请按照以下格式输出：
18

19
## 数据概览
20
[统计摘要]
21

22
## 关键发现
23
- 发现 1：[具体数据支撑]
24
- 发现 2：[具体数据支撑]
25

26
## 业务建议
27
[可执行的建议]
28

29
## 可视化方案
30
[推荐的图表类型及原因]
31
"""

1
creative_prompt = """
2
你是一位获得雨果奖的科幻小说作家。
3

4
写作任务：创作一个短篇故事开头
5

6
故事设定：
7
- 时间：{time_period}
8
- 地点：{location}
9
- 主角：{protagonist}
10
- 冲突：{conflict}
11

12
写作风格：
13
- 开门见山，直接进入场景
14
- 使用感官细节（视觉、听觉、触觉）
15
- 制造悬念，引发好奇
16
- 展示而非告知（show, don't tell）
17

18
字数：300-500 字
19

20
现在开始写作：
21
"""

1
def rag_prompt(question, retrieved_docs):
2
    context = "\n\n".join([
3
        f"文档 {i+1}：{doc}"
4
        for i, doc in enumerate(retrieved_docs)
5
    ])
6

7
    return f"""
8
请基于以下文档回答问题。只使用文档中的信息，不要添加额外内容。
9
如果文档中没有答案，请说"文档中未找到相关信息"。
10

11
文档：
12
{context}
13

14
问题：{question}
15

16
回答（必须基于文档）：
17
"""

1
import json
2
import re
3

4
def enforce_json_output(prompt, model, max_retries=3):
5
    """确保模型输出有效的 JSON"""
6
    for attempt in range(max_retries):
7
        response = model.generate(prompt)
8

9
        # 尝试提取 JSON
10
        json_match = re.search(r'\{.*\}', response, re.DOTALL)
11
        if json_match:
12
            try:
13
                return json.loads(json_match.group())
14
            except json.JSONDecodeError:
15
                pass
16

17
        # 如果失败，修改 prompt 重试
18
        prompt += "\n\n请确保输出是有效的 JSON 格式，不要包含任何其他文本。"
19

20
    raise ValueError("无法获取有效的 JSON 输出")

1
def smart_truncation(text, max_tokens, model):
2
    """智能截断，保留最重要的部分"""
3
    # 方法 1：截取首尾
4
    tokens = model.tokenize(text)
5
    if len(tokens) <= max_tokens:
6
        return text
7

8
    # 保留 70% 开头 + 30% 结尾
9
    head_len = int(max_tokens * 0.7)
10
    tail_len = max_tokens - head_len
11

12
    truncated_tokens = tokens[:head_len] + tokens[-tail_len:]
13
    return model.detokenize(truncated_tokens)
14

15
# 方法 2：分块处理 + 汇总
16
def process_long_text(text, task, model):
17
    chunks = split_into_chunks(text, max_tokens=2000)
18

19
    # 对每个块处理
20
    chunk_results = []
21
    for chunk in chunks:
22
        result = model.generate(f"{task}\n\nText: {chunk}")
23
        chunk_results.append(result)
24

25
    # 汇总结果
26
    final_prompt = f"""
27
以下是对文档各部分的分析结果：
28

29
{chr(10).join(chunk_results)}
30

31
请综合以上分析，给出整体结论：
32
"""
33
    return model.generate(final_prompt)

1
from langchain import PromptTemplate, LLMChain
2
from langchain.llms import OpenAI
3

4
# 定义模板
5
template = PromptTemplate(
6
    input_variables=["product", "audience"],
7
    template="""
8
为 {product} 写一段营销文案，目标受众是 {audience}。
9

10
文案应该：
11
- 突出核心价值
12
- 引发情感共鸣
13
- 包含行动号召
14

15
文案：
16
"""
17
)
18

19
# 创建链
20
chain = LLMChain(llm=OpenAI(), prompt=template)
21

22
# 使用
23
result = chain.run(product="智能手表", audience="运动爱好者")

1
from guidance import models, gen
2

3
# 定义结构化生成
4
gpt = models.OpenAI("gpt-3.5-turbo")
5

6
result = gpt + f"""
7
请分析以下评论的情感：
8

9
评论：{review}
10

11
情感分析：
12
- 情感倾向：{gen('sentiment', regex='(positive|negative|neutral)')}
13
- 置信度：{gen('confidence', regex='[0-9]\\.[0-9]+')}
14
- 关键词：{gen('keywords', list_append=True, n=3)}
15
"""

1
from promptbench import PromptEvaluator
2

3
evaluator = PromptEvaluator(
4
    model="gpt-3.5-turbo",
5
    dataset="sst2",  # 情感分析数据集
6
    metrics=["accuracy", "f1", "consistency"]
7
)
8

9
results = evaluator.evaluate([
10
    "Classify sentiment: {text}",
11
    "What is the sentiment? {text}",
12
    "Analyze: {text} Sentiment:"
13
])
14

15
print(evaluator.rank_prompts())