提示工程最佳实践

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

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

请提取：
{
  "公司": "",
  "CEO": "",
  "事件": "",
  "日期": "",
  "地点": "",
  "金额": ""
}
"""

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

def select_few_shot_examples(query, example_pool, embeddings, k=3):
    """
    根据查询语句，从示例池中选择最相似的 k 个示例
    """
    query_embedding = get_embedding(query)
    
    # 计算相似度
    similarities = cosine_similarity([query_embedding], embeddings)[0]
    
    # 选择最相似的 k 个
    top_k_indices = np.argsort(similarities)[-k:][::-1]
    
    return [example_pool[i] for i in top_k_indices]

# 使用
examples = select_few_shot_examples(
    query="这款手机拍照效果很好",
    example_pool=all_labeled_examples,
    embeddings=all_embeddings,
    k=3
)

prompt = f"""
问题：{question}

Let's think step by step.
"""

# 中文版本
prompt = f"""
问题：{question}

让我们一步步思考：
"""

def self_consistency_cot(question, model, num_samples=5):
    prompt = f"{question}\n\nLet's think step by step."
    
    # 生成多个推理路径
    answers = []
    for _ in range(num_samples):
        response = model.generate(
            prompt,
            temperature=0.7,  # 增加随机性
            max_tokens=256
        )
        # 提取最终答案
        answer = extract_answer(response)
        answers.append(answer)
    
    # 多数投票
    from collections import Counter
    most_common = Counter(answers).most_common(1)[0][0]
    
    return most_common

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

def tree_of_thoughts(problem, model, depth=3, breadth=3):
    """
    在每一步生成多个可能的推理步骤，构建思维树
    """
    def explore(state, depth_left):
        if depth_left == 0:
            return evaluate_solution(state)
        
        # 生成 breadth 个下一步推理
        next_steps = model.generate_next_thoughts(state, k=breadth)
        
        # 递归探索每个分支
        results = []
        for step in next_steps:
            new_state = state + [step]
            score = explore(new_state, depth_left - 1)
            results.append((score, new_state))
        
        # 返回最佳分支
        return max(results, key=lambda x: x[0])
    
    return explore([], depth)

import re
from typing import List, Dict, Callable

class ReActAgent:
    def __init__(self, model, tools: Dict[str, Callable], max_steps=5):
        self.model = model
        self.tools = tools
        self.max_steps = max_steps
        
    def run(self, question: str) -> str:
        prompt = self._build_initial_prompt(question)
        
        for step in range(self.max_steps):
            # 生成下一步推理
            response = self.model.generate(prompt)
            
            # 解析 Thought 和 Action
            thought = self._extract_thought(response)
            action = self._extract_action(response)
            
            if "Final Answer:" in response:
                return self._extract_final_answer(response)
            
            # 执行 Action
            observation = self._execute_action(action)
            
            # 更新 prompt
            prompt += f"\nObservation {step+1}: {observation}\n"
        
        return "达到最大步数限制"
    
    def _execute_action(self, action: str) -> str:
        # 解析 Action[tool_name, input]
        match = re.search(r'(\w+)\[(.*?)\]', action)
        if match:
            tool_name, tool_input = match.groups()
            if tool_name in self.tools:
                return self.tools[tool_name](tool_input)
        return "无效的 Action"
    
    def _build_initial_prompt(self, question: str) -> str:
        tools_desc = "\n".join([
            f"- {name}: {func.__doc__}"
            for name, func in self.tools.items()
        ])
        
        return f"""
Answer the following question using this format:

Thought: [your reasoning]
Action: [tool_name[input]]
Observation: [result will be provided]
... (repeat Thought/Action/Observation)
Thought: I now know the final answer
Final Answer: [your final answer]

Available tools:
{tools_desc}

Question: {question}

Thought 1:"""

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

def calculate(expression: str) -> str:
    """Evaluate a mathematical expression"""
    try:
        return str(eval(expression))
    except:
        return "Invalid expression"

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

# 使用
agent = ReActAgent(
    model=gpt_model,
    tools={
        "Search": search,
        "Calculate": calculate,
        "Lookup": lookup
    }
)

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

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

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

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

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

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

评论："{review}"

输出格式（必须严格遵守）：
{{
  "sentiment": "positive/negative/neutral",
  "confidence": 0.0-1.0,
  "key_phrases": ["phrase1", "phrase2"],
  "summary": "一句话总结"
}}

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

# 方法 1：明确指定
prompt = "用不超过 50 个字总结这篇文章"

# 方法 2：使用模板
prompt = """
请总结以下文章。

文章：{article}

总结（50字以内）：
"""

# 方法 3：Token 限制
response = model.generate(prompt, max_tokens=100)

style_templates = {
    "formal": "请用正式、学术的语气回答",
    "casual": "请用轻松、口语化的方式回答",
    "technical": "请用专业术语和技术细节回答",
    "eli5": "请用向 5 岁小孩解释的方式回答"
}

prompt = f"""
{style_templates["eli5"]}

问题：什么是区块链？
"""

prompt = """
请帮我写一篇关于人工智能的文章。按照以下步骤进行：

步骤 1：列出文章的 5 个主要章节标题
步骤 2：为每个章节写 3-5 个要点
步骤 3：为第一章节写一个详细的段落（200字）
步骤 4：总结全文的核心观点（50字）

现在开始步骤 1：
"""

prompt = """
以下是两种写作风格的对比。请学习"好的风格"，避免"差的风格"。

❌ 差的风格（冗长、模糊）：
"这个产品在某种程度上可能会对用户的使用体验产生一定的影响，
具体来说可能涉及到多个方面的因素..."

✅ 好的风格（简洁、明确）：
"这个产品有三个缺点：1)启动慢 2)界面复杂 3)价格偏高"

现在，请用"好的风格"重写以下段落：
"{text}"
"""

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

请帮我设计这个 prompt。
"""

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

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

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

class PromptOptimizer:
    def __init__(self, model, eval_dataset):
        self.model = model
        self.eval_dataset = eval_dataset
        
    def optimize(self, initial_prompt, num_iterations=5):
        current_prompt = initial_prompt
        best_score = 0
        
        for i in range(num_iterations):
            # 1. 评估当前 prompt
            score = self.evaluate(current_prompt)
            print(f"Iteration {i+1}: Score = {score:.2f}")
            
            if score > best_score:
                best_score = score
                best_prompt = current_prompt
            
            # 2. 分析失败案例
            failures = self.get_failure_cases(current_prompt)
            
            # 3. 生成改进建议
            suggestions = self.generate_suggestions(
                current_prompt, failures
            )
            
            # 4. 修改 prompt
            current_prompt = self.apply_suggestions(
                current_prompt, suggestions
            )
        
        return best_prompt, best_score
    
    def evaluate(self, prompt):
        """在评估集上测试 prompt"""
        correct = 0
        for example in self.eval_dataset:
            response = self.model.generate(
                prompt.format(**example)
            )
            if self.is_correct(response, example['answer']):
                correct += 1
        return correct / len(self.eval_dataset)

import pandas as pd
from scipy import stats

class PromptABTest:
    def __init__(self, model, test_cases):
        self.model = model
        self.test_cases = test_cases
        
    def compare(self, prompt_a, prompt_b, metric='accuracy'):
        results_a = []
        results_b = []
        
        for case in self.test_cases:
            # 测试 Prompt A
            response_a = self.model.generate(prompt_a.format(**case))
            score_a = self.evaluate_response(response_a, case)
            results_a.append(score_a)
            
            # 测试 Prompt B
            response_b = self.model.generate(prompt_b.format(**case))
            score_b = self.evaluate_response(response_b, case)
            results_b.append(score_b)
        
        # 统计显著性检验
        t_stat, p_value = stats.ttest_rel(results_a, results_b)
        
        report = {
            'prompt_a_mean': np.mean(results_a),
            'prompt_b_mean': np.mean(results_b),
            'improvement': np.mean(results_b) - np.mean(results_a),
            'p_value': p_value,
            'significant': p_value < 0.05
        }
        
        return report

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

from promptflow import PromptTemplate, Optimizer

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

Task: {task_description}

{few_shot_examples}

Input: {input}
Output:
""")

# 自动搜索最佳配置
optimizer = Optimizer(
    template=template,
    model=model,
    eval_dataset=eval_data,
    search_space={
        'role_description': [
            'You are an expert.',
            'You are a helpful assistant.',
            'You are a domain specialist.'
        ],
        'task_description': [
            'Classify the sentiment.',
            'Analyze the sentiment and explain.',
        ],
        'few_shot_examples': [0, 2, 4]  # 示例数量
    }
)

best_prompt = optimizer.optimize(
    metric='f1_score',
    num_trials=50
)

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

任务：{task_description}

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

示例格式：
```python
def function_name(param: Type) -> ReturnType:
    \"\"\"
    Function description.
    
    Args:
        param: Parameter description
        
    Returns:
        Return value description
        
    Raises:
        ExceptionType: When this exception occurs
    \"\"\"
    # Implementation
    pass

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

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

故事设定：
- 时间：{time_period}
- 地点：{location}
- 主角：{protagonist}
- 冲突：{conflict}

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

字数：300-500 字

现在开始写作：
"""

prompt = """
请回答以下问题，并为每个关键事实标注来源。
如果不确定，请明确说明"我不确定"。

问题：{question}

回答格式：
[主要回答]

来源：
1. [事实 1] - 来源：[...]
2. [事实 2] - 来源：[...]
"""

def rag_prompt(question, retrieved_docs):
    context = "\n\n".join([
        f"文档 {i+1}：{doc}"
        for i, doc in enumerate(retrieved_docs)
    ])
    
    return f"""
请基于以下文档回答问题。只使用文档中的信息，不要添加额外内容。
如果文档中没有答案，请说"文档中未找到相关信息"。

文档：
{context}

问题：{question}

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

import json
import re

def enforce_json_output(prompt, model, max_retries=3):
    """确保模型输出有效的 JSON"""
    for attempt in range(max_retries):
        response = model.generate(prompt)
        
        # 尝试提取 JSON
        json_match = re.search(r'\{.*\}', response, re.DOTALL)
        if json_match:
            try:
                return json.loads(json_match.group())
            except json.JSONDecodeError:
                pass
        
        # 如果失败，修改 prompt 重试
        prompt += "\n\n请确保输出是有效的 JSON 格式，不要包含任何其他文本。"
    
    raise ValueError("无法获取有效的 JSON 输出")

def smart_truncation(text, max_tokens, model):
    """智能截断，保留最重要的部分"""
    # 方法 1：截取首尾
    tokens = model.tokenize(text)
    if len(tokens) <= max_tokens:
        return text
    
    # 保留 70% 开头 + 30% 结尾
    head_len = int(max_tokens * 0.7)
    tail_len = max_tokens - head_len
    
    truncated_tokens = tokens[:head_len] + tokens[-tail_len:]
    return model.detokenize(truncated_tokens)

# 方法 2：分块处理 + 汇总
def process_long_text(text, task, model):
    chunks = split_into_chunks(text, max_tokens=2000)
    
    # 对每个块处理
    chunk_results = []
    for chunk in chunks:
        result = model.generate(f"{task}\n\nText: {chunk}")
        chunk_results.append(result)
    
    # 汇总结果
    final_prompt = f"""
以下是对文档各部分的分析结果：

{chr(10).join(chunk_results)}

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

from langchain import PromptTemplate, LLMChain
from langchain.llms import OpenAI

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

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

文案：
"""
)

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

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

from guidance import models, gen

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

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

评论：{review}

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

from promptbench import PromptEvaluator

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

results = evaluator.evaluate([
    "Classify sentiment: {text}",
    "What is the sentiment? {text}",
    "Analyze: {text} Sentiment:"
])

print(evaluator.rank_prompts())

# 图像 + 文本提示
prompt = {
    "image": "path/to/image.jpg",
    "text": """
请描述这张图片中的场景，并回答：
1. 图片的主题是什么？
2. 有哪些值得注意的细节？
3. 这张图片可能用于什么场景？
"""
}