Prompt工程¶

# 基础Prompt示例
basic_prompt = """
你是一个专业的技术文档撰写者,擅长将复杂的技术概念转化为易于理解的文档。

你的任务是将以下技术术语解释为通俗易懂的内容。

输入术语:Transformer

请按照以下格式输出:
- 术语名称
- 简单定义
- 核心原理
- 应用场景
- 举例说明

注意:
- 使用简洁明了的语言
- 避免过于专业的术语
- 提供实际应用案例
"""

# ❌ 不好的角色设定
bad_role = "你是一个助手。"

# ✅ 好的角色设定
good_role = """
你是一位拥有10年经验的资深机器学习工程师,
专注于深度学习和自然语言处理领域。
你的表达风格专业、准确,善于用通俗的语言解释复杂概念。
"""

from openai import OpenAI

client = OpenAI(api_key="your-api-key")

def create_role_based_prompt(task, role_expertise):
    """创建基于角色的Prompt"""
    prompt = f"""
你是一位{role_expertise['title']},
拥有{role_expertise['experience']}年经验,
专注于{role_expertise['specialty']}领域。

你的专业特长包括:
{chr(10).join(f"- {skill}" for skill in role_expertise['skills'])}

任务:{task}

请根据你的专业背景,提供详细、准确、专业的解答。
"""
    return prompt

# 使用示例
ml_engineer = {
    'title': '资深机器学习工程师',
    'experience': 10,
    'specialty': '深度学习和自然语言处理',
    'skills': [
        'Transformer架构设计',
        '大模型微调',
        'Prompt工程优化',
        '模型部署与优化'
    ]
}

task = "解释什么是LoRA微调技术"
prompt = create_role_based_prompt(task, ml_engineer)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}]
)

print(response.choices[0].message.content)

# ❌ 不好的任务描述
bad_task = "分析这段文本"

# ✅ 好的任务描述
good_task = """
请对以下文本进行情感分析,具体要求如下:

1. 判断文本的情感倾向(正面/负面/中性)
2. 给出情感强度评分(1-10分)
3. 识别文本中的关键情感词
4. 简要说明判断理由

文本内容:
[待分析文本]
"""

def create_task_prompt(task_type, input_data, requirements):
    """创建任务导向的Prompt"""
    task_templates = {
        'summarization': {
            'description': '文本摘要',
            'template': """
请对以下文本进行摘要,具体要求:

1. 摘要长度:{length}字左右
2. 包含关键信息: {key_points}
3. 语言风格: {style}
4. 结构要求: {structure}

原文:
{text}
"""
        },
        'analysis': {
            'description': '文本分析',
            'template': """
请对以下文本进行分析,具体要求:

分析维度:
{dimensions}

输出格式:
- 分析维度1: [结果]
- 分析维度2: [结果]
...

原文:
{text}
"""
        },
        'generation': {
            'description': '内容生成',
            'template': """
请根据以下要求生成内容:

主题: {topic}
类型: {content_type}
长度: {length}
风格: {style}

具体要求:
{specific_requirements}
"""
        }
    }

    template = task_templates[task_type]['template']
    return template.format(**requirements, text=input_data)

# 使用示例
long_text = """
人工智能（AI）正在深刻改变我们的生活和工作方式。从智能手机中的语音助手到自动驾驶汽车，
AI技术已经渗透到各个领域。在医疗领域，AI帮助医生更准确地诊断疾病；
在教育领域，AI提供个性化的学习体验；在金融领域，AI用于风险评估和欺诈检测。
然而，AI的发展也带来了一些挑战，如隐私保护、就业影响等问题需要社会共同面对。
"""

requirements = {
    'length': '200',
    'key_points': '主要观点、关键数据、结论',
    'style': '简洁专业',
    'structure': '总-分-总'
}

prompt = create_task_prompt('summarization', long_text, requirements)
print(prompt)

def create_few_shot_prompt(task_description, examples, test_input):
    """创建Few-shot Prompt"""
    prompt = f"""
{task_description}

以下是几个示例:

"""

    for i, example in enumerate(examples, 1):  # enumerate同时获取索引和元素
        prompt += f"""
示例 {i}:
输入: {example['input']}
输出: {example['output']}

"""

    prompt += f"""
现在请处理以下输入:
输入: {test_input}
输出:
"""

    return prompt

# 使用示例:情感分类
task_description = "你是一个情感分析专家,请判断文本的情感倾向。"

examples = [
    {
        'input': '这个产品太棒了,我非常喜欢!',
        'output': '正面'
    },
    {
        'input': '服务态度很差,不会再来了。',
        'output': '负面'
    },
    {
        'input': '今天天气不错。',
        'output': '中性'
    }
]

test_input = '这个功能设计得很好,用起来很方便。'

prompt = create_few_shot_prompt(task_description, examples, test_input)
print(prompt)

import numpy as np
from sentence_transformers import SentenceTransformer

class DynamicExampleSelector:
    """动态示例选择器"""

    def __init__(self, examples, model_name='all-MiniLM-L6-v2'):
        self.examples = examples
        self.model = SentenceTransformer(model_name)
        self.example_embeddings = self.model.encode(
            [ex['input'] for ex in examples]
        )

    def select_examples(self, test_input, k=3):
        """选择最相似的k个示例"""
        test_embedding = self.model.encode([test_input])

        # 计算相似度
        similarities = np.dot(self.example_embeddings, test_embedding.T).flatten()

        # 选择top-k
        top_indices = np.argsort(similarities)[-k:][::-1]

        return [self.examples[i] for i in top_indices]

# 使用示例
examples = [
    {'input': '产品很好', 'output': '正面'},
    {'input': '服务太差', 'output': '负面'},
    {'input': '价格合理', 'output': '正面'},
    {'input': '质量不行', 'output': '负面'},
    {'input': '还可以', 'output': '中性'},
]

selector = DynamicExampleSelector(examples)
selected = selector.select_examples('这个商品质量不错', k=3)

print("选中的示例:")
for ex in selected:
    print(f"输入: {ex['input']}, 输出: {ex['output']}")

def create_format_prompt(task, output_format, schema=None):
    """创建格式化输出Prompt"""

    format_templates = {
        'json': f"""
请以JSON格式输出结果,遵循以下schema:
{schema if schema else '{{"key": "value"}}'}

任务:{task}

输出:
""",

        'markdown': f"""
请以Markdown格式输出结果,使用适当的标题、列表和代码块。

任务:{task}

输出:
""",

        'table': f"""
请以表格格式输出结果,包含以下列:
{schema if schema else '列1, 列2, 列3'}

任务:{task}

输出:
""",

        'list': f"""
请以列表格式输出结果,每个项目用-开头。

任务:{task}

输出:
"""
    }

    return format_templates.get(output_format, '')

# 使用示例
task = "分析以下产品的优缺点:智能手机"

# JSON格式
json_prompt = create_format_prompt(
    task,
    'json',
    '''{
    "advantages": ["优点1", "优点2"],
    "disadvantages": ["缺点1", "缺点2"]
}'''
)

# Markdown格式
md_prompt = create_format_prompt(task, 'markdown')

print("JSON格式Prompt:")
print(json_prompt)

import json
import re

def validate_json_output(output, schema):
    """验证JSON输出是否符合schema"""
    try:  # try/except捕获异常，防止程序崩溃
        data = json.loads(output)  # json.loads将JSON字符串→Python对象

        # 简单验证
        for key in schema.keys():
            if key not in data:
                return False, f"缺少字段: {key}"

        return True, "验证通过"

    except json.JSONDecodeError as e:
        return False, f"JSON格式错误: {str(e)}"

def ensure_structured_output(client, prompt, max_retries=3):
    """确保输出符合结构化要求"""

    for attempt in range(max_retries):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        )

        output = response.choices[0].message.content

        # 尝试提取JSON
        # ⚠️ 注意: 此正则提取方式较脆弱，贪婪匹配可能跨越多个JSON对象或匹配非JSON花括号。
        # 推荐: 使用 OpenAI 的 JSON Mode (response_format={"type": "json_object"}) 获取可靠的结构化输出。
        json_match = re.search(r'\{.*\}', output, re.DOTALL)  # re.search正则表达式搜索匹配
        if json_match:
            json_str = json_match.group()
            try:
                json.loads(json_str)
                return json_str
            except json.JSONDecodeError:
                pass

        # 如果失败,要求重新生成
        if attempt < max_retries - 1:
            prompt += f"\n\n请重新生成,确保输出格式正确。之前的输出:\n{output}"

    return None

# 使用示例
schema = {
    "advantages": list,
    "disadvantages": list
}

prompt = create_format_prompt(task, 'json', json.dumps(schema))  # json.dumps将Python对象→JSON字符串
output = ensure_structured_output(client, prompt)

if output:
    print("结构化输出:")
    print(output)
    is_valid, msg = validate_json_output(output, schema)
    print(f"验证结果: {msg}")

def create_constrained_prompt(task, constraints):
    """创建带约束条件的Prompt"""

    constraint_templates = {
        'length': f"输出长度限制在{constraints['min']}-{constraints['max']}字之间。",
        'content': f"输出内容必须包含: {', '.join(constraints['keywords'])}",
        'language': f"使用{constraints['language']}语言输出。",
        'style': f"使用{constraints['style']}风格输出。",
        'format': f"严格按照{constraints['format']}格式输出。"
    }

    prompt = f"""
任务: {task}

约束条件:
"""

    for constraint_type, constraint_value in constraints.items():
        if constraint_type in constraint_templates:
            prompt += f"- {constraint_templates[constraint_type]}\n"

    prompt += "\n请严格遵守以上约束条件。"

    return prompt

# 使用示例
task = "写一篇关于AI发展的短文"

constraints = {
    'length': {'min': 200, 'max': 300},
    'keywords': ['深度学习', 'Transformer', '大模型'],
    'language': '中文',
    'style': '专业学术',
    'format': '段落式'
}

prompt = create_constrained_prompt(task, constraints)
print(prompt)

class PromptOptimizer:
    """Prompt优化器"""

    def __init__(self, client, model="gpt-4o"):
        self.client = client
        self.model = model
        self.history = []

    def evaluate_prompt(self, prompt, test_cases):
        """评估Prompt效果"""
        results = []
        for test_case in test_cases:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[{"role": "user", "content": prompt.format(**test_case)}]
            )

            output = response.choices[0].message.content
            results.append({
                'input': test_case,
                'output': output,
                'expected': test_case.get('expected', None)
            })

        return results

    def analyze_results(self, results):
        """分析结果,找出问题"""
        issues = []

        for i, result in enumerate(results):
            if result['expected']:
                if result['output'] != result['expected']:
                    issues.append({
                        'index': i,
                        'input': result['input'],
                        'expected': result['expected'],
                        'actual': result['output']
                    })

        return issues

    def optimize_prompt(self, prompt, test_cases, max_iterations=5):
        """迭代优化Prompt"""
        current_prompt = prompt

        for iteration in range(max_iterations):
            print(f"\n=== 迭代 {iteration + 1} ===")

            # 评估当前Prompt
            results = self.evaluate_prompt(current_prompt, test_cases)

            # 分析结果
            issues = self.analyze_results(results)

            print(f"测试用例数: {len(test_cases)}")
            print(f"问题数: {len(issues)}")

            if len(issues) == 0:
                print("✓ Prompt已优化完成!")
                break

            # 生成改进建议
            improvement_prompt = f"""
当前Prompt:
{current_prompt}

遇到的问题:
{chr(10).join(f"- {issue}" for issue in issues[:3])}

请分析这些问题,并给出改进Prompt的建议,使其能够正确处理这些情况。
"""

            response = self.client.chat.completions.create(
                model=self.model,
                messages=[{"role": "user", "content": improvement_prompt}]
            )

            suggestions = response.choices[0].message.content
            print(f"\n改进建议:\n{suggestions}")

            # 记录历史
            self.history.append({
                'iteration': iteration,
                'prompt': current_prompt,
                'issues': issues,
                'suggestions': suggestions
            })

            # 手动应用改进(实际应用中可以自动化)
            print("\n请根据建议手动改进Prompt,然后继续...")
            break

        return current_prompt

# 使用示例
client = OpenAI(api_key="your-api-key")
optimizer = PromptOptimizer(client)

# 测试用例
test_cases = [
    {
        'text': '这个产品太棒了!',
        'expected': '正面'
    },
    {
        'text': '服务态度很差。',
        'expected': '负面'
    },
    {
        'text': '今天天气不错。',
        'expected': '中性'
    }
]

# 初始Prompt
initial_prompt = """
判断以下文本的情感倾向(正面/负面/中性):
{text}
"""

# 优化Prompt
# optimized_prompt = optimizer.optimize_prompt(initial_prompt, test_cases)

import numpy as np

class PromptABTester:
    """Prompt A/B测试器"""

    def __init__(self, client, model="gpt-4o"):
        self.client = client
        self.model = model

    def run_test(self, prompts: list[str], test_cases: list[dict]) -> dict:
        """运行A/B测试"""
        results = {}

        for i, prompt in enumerate(prompts):
            prompt_name = f"Prompt_{i+1}"
            results[prompt_name] = {
                'prompt': prompt,
                'outputs': [],
                'metrics': {}
            }

            for test_case in test_cases:
                response = self.client.chat.completions.create(
                    model=self.model,
                    messages=[{"role": "user", "content": prompt.format(**test_case)}]
                )

                output = response.choices[0].message.content
                results[prompt_name]['outputs'].append({
                    'input': test_case,
                    'output': output,
                    'expected': test_case.get('expected', None)
                })

        # 计算指标
        for prompt_name, data in results.items():
            metrics = self.calculate_metrics(data['outputs'])
            results[prompt_name]['metrics'] = metrics

        return results

    def calculate_metrics(self, outputs: list[dict]) -> dict:
        """计算评估指标"""
        total = len(outputs)
        correct = 0
        token_count = 0

        for output in outputs:
            if output['expected']:
                if output['output'] == output['expected']:
                    correct += 1

            # 估算Token数
            token_count += len(output['output'].split())

        avg_tokens = token_count / total if total > 0 else 0
        accuracy = correct / total if total > 0 else 0

        return {
            'accuracy': accuracy,
            'avg_tokens': avg_tokens,
            'total_tests': total,
            'correct_count': correct
        }

    def compare_results(self, results: dict) -> str:
        """比较结果,生成报告"""
        report = "=== A/B测试报告 ===\n\n"

        # 按准确率排序
        sorted_results = sorted(
            results.items(),
            key=lambda x: x[1]['metrics']['accuracy'],  # lambda匿名函数
            reverse=True
        )

        for rank, (prompt_name, data) in enumerate(sorted_results, 1):
            metrics = data['metrics']
            report += f"排名 {rank}: {prompt_name}\n"
            report += f"  准确率: {metrics['accuracy']:.2%}\n"
            report += f"  平均Token数: {metrics['avg_tokens']:.1f}\n"
            report += f"  测试数: {metrics['total_tests']}\n"
            report += f"  正确数: {metrics['correct_count']}\n\n"

        return report

# 使用示例
client = OpenAI(api_key="your-api-key")
tester = PromptABTester(client)

# 两个不同的Prompt
prompt_a = """
判断以下文本的情感倾向(正面/负面/中性):
{text}
"""

prompt_b = """
你是一个情感分析专家。请仔细分析以下文本的情感,并判断其倾向(正面/负面/中性)。

文本: {text}

请直接输出情感倾向,不要添加其他内容。
"""

prompts = [prompt_a, prompt_b]

# 运行测试
results = tester.run_test(prompts, test_cases)

# 生成报告
report = tester.compare_results(results)
print(report)

class AutoPromptEngineer:
    """自动化Prompt工程师"""

    def __init__(self, client, model="gpt-4o"):
        self.client = client
        self.model = model

    def generate_prompt(self, task_description, examples):
        """自动生成Prompt"""

        prompt = f"""
任务描述: {task_description}

示例:
{chr(10).join(f"输入: {ex['input']}\n输出: {ex['output']}\n" for ex in examples)}

请根据以上任务描述和示例,设计一个高质量的Prompt,使其能够:
1. 清晰地描述任务
2. 提供必要的上下文
3. 指定输出格式
4. 包含适当的示例

请直接输出Prompt内容,不要添加其他解释。
"""

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

    def optimize_prompt_automatically(self, current_prompt, failing_cases):
        """自动优化Prompt"""

        prompt = f"""
当前Prompt:
{current_prompt}

以下是一些失败的测试用例:
{chr(10).join(f"输入: {case['input']}\n期望输出: {case['expected']}\n实际输出: {case['actual']}\n" for case in failing_cases[:5])}

请分析这些失败案例,并改进Prompt,使其能够正确处理这些情况。
请输出改进后的完整Prompt。
"""

        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

# 使用示例
client = OpenAI(api_key="your-api-key")
auto_engineer = AutoPromptEngineer(client)

# 任务描述
task_description = "判断文本的情感倾向(正面/负面/中性)"

# 示例
examples = [
    {'input': '这个产品太棒了!', 'output': '正面'},
    {'input': '服务态度很差。', 'output': '负面'},
    {'input': '今天天气不错。', 'output': '中性'}
]

# 自动生成Prompt
generated_prompt = auto_engineer.generate_prompt(task_description, examples)
print("自动生成的Prompt:")
print(generated_prompt)

customer_service_prompt = """
你是一位专业的客服代表,拥有丰富的产品知识和服务经验。

你的职责:
1. 准确理解用户问题
2. 提供清晰、准确的答案
3. 保持友好、专业的态度
4. 必要时引导用户获取更多信息

回答要求:
- 使用简洁明了的语言
- 避免使用过于专业的术语
- 提供具体的解决方案
- 保持积极、友好的语气

如果遇到无法回答的问题,请:
1. 礼貌地说明情况
2. 提供替代建议
3. 建议用户联系人工客服

用户问题: {user_question}

请提供专业、友好的回答:
"""

def customer_service_response(user_question):
    """生成客服回复"""
    client = OpenAI(api_key="your-api-key")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "你是一位专业的客服代表。"},
            {"role": "user", "content": customer_service_prompt.format(user_question=user_question)}
        ],
        temperature=0.7
    )

    return response.choices[0].message.content

# 测试
question = "我的订单什么时候能发货?"
answer = customer_service_response(question)
print(f"用户问题: {question}")
print(f"客服回复: {answer}")

code_review_prompt = """
你是一位资深的软件工程师,擅长代码审查和质量改进。

请对以下代码进行审查,重点关注:
1. 代码质量和可读性
2. 潜在的bug和问题
3. 性能优化建议
4. 最佳实践建议
5. 安全性考虑

代码语言: {language}

代码内容:
```
{code}
```

请按照以下格式输出审查结果:

## 总体评价
[对代码的总体评价]

## 优点
- [优点1]
- [优点2]

## 问题与建议
### 严重问题
- [问题描述]
  - 位置: [代码位置]
  - 建议: [改进建议]

### 改进建议
- [建议1]
  - 位置: [代码位置]
  - 说明: [详细说明]

## 重构建议
[如果需要重构,提供重构建议]
"""

def code_review(code, language='python'):
    """代码审查"""
    client = OpenAI(api_key="your-api-key")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "你是一位资深的软件工程师。"},
            {"role": "user", "content": code_review_prompt.format(code=code, language=language)}
        ],
        temperature=0.3
    )

    return response.choices[0].message.content

# 测试
sample_code = """
def calculate_sum(numbers):
    result = 0
    for i in range(len(numbers)):
        result += numbers[i]
    return result
"""

review = code_review(sample_code, 'python')
print(review)

doc_generation_prompt = """
你是一位技术文档撰写专家,擅长从代码生成清晰、准确的技术文档。

请分析以下代码,生成完整的技术文档,包括:

## 模块概述
[模块的功能和用途]

## 函数列表
- [函数名]: [简要说明]

## 详细文档

### 函数名
**功能**: [函数功能描述]

**参数**:
- `param1`: [参数说明]
- `param2`: [参数说明]

**返回值**:
- [返回值类型]: [返回值说明]

**示例**:
```
[使用示例]
```

**注意事项**:
- [注意事项1]
- [注意事项2]

代码内容:
```text
{code}
```

请生成完整的技术文档:
"""

def generate_documentation(code, language='python'):
    """生成技术文档"""
    client = OpenAI(api_key="your-api-key")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "你是一位技术文档撰写专家。"},
            {"role": "user", "content": doc_generation_prompt.format(code=code, language=language)}
        ],
        temperature=0.5
    )

    return response.choices[0].message.content

# 测试
sample_code = """
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)
"""

docs = generate_documentation(sample_code, 'python')
print(docs)

from openai import OpenAI

client = OpenAI()

def summarize(text: str, focus: str = None, max_words: int = 50) -> str:
    """
    文本概括：将长文本压缩为简短摘要

    关键技巧:
    1. 指定字数/句数限制
    2. 指定概括的侧重点
    3. 区分"总结(summary)"和"提取(extract)"
    """
    if focus:
        prompt = f"""请用不超过{max_words}个字概括以下文本，侧重于{focus}方面的内容。

文本：
{text}
"""
    else:
        prompt = f"""请用不超过{max_words}个字概括以下文本的核心内容。

文本：
{text}
"""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )
    return response.choices[0].message.content

# 示例：商品评论概括
review = """
这款蓝牙耳机音质非常出色，降噪效果也很好，在嘈杂的地铁上也能享受音乐。
电池续航大约6小时，充电盒可以再充3次。佩戴舒适，跑步时也不容易掉。
唯一的缺点是通话时对方反映有轻微回声，希望后续固件能优化。价格399元，性价比很高。
"""

# 不同侧重点的概括
# summary_shipping = summarize(review, focus="物流配送")
# summary_product  = summarize(review, focus="产品品质")
# summary_price    = summarize(review, focus="性价比")

print("""
概括技巧小结:
┌─────────────────┬──────────────────────────────────┐
│ 技巧            │ 示例Prompt片段                    │
├─────────────────┼──────────────────────────────────┤
│ 限制长度        │ "用不超过30个字概括"              │
│ 指定侧重        │ "侧重于产品功能方面"              │
│ 格式化输出      │ "以要点列表形式概括3个核心信息"   │
│ 提取而非概括    │ "提取与价格相关的信息"            │
│ 多层次概括      │ "分别用一句话和一段话概括"        │
└─────────────────┴──────────────────────────────────┘
""")

def infer_sentiment(text: str) -> dict:
    """
    文本推断：从文本中提取隐含信息

    推断类型:
    1. 情感分析
    2. 信息提取（实体、关系）
    3. 主题识别
    4. 意图识别
    """
    prompt = f"""分析以下文本，以JSON格式返回：
1. sentiment: 情感倾向（positive/negative/neutral）
2. emotions: 检测到的情绪列表
3. topics: 文本涉及的主题
4. key_entities: 提到的关键实体
5. intent: 作者的意图

文本：
{text}

请严格以JSON格式输出。
"""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        response_format={"type": "json_object"}
    )
    import json
    return json.loads(response.choices[0].message.content)

# 示例
sample_text = "虽然这次更新修复了很多bug，但新增的广告太多了，严重影响使用体验。希望开发团队能重视用户反馈。"
# result = infer_sentiment(sample_text)

print("""
推断应用场景:
├── 情感分析: 评论情感分类、舆情监控
├── 信息提取: 从简历提取技能、从合同提取条款
├── 主题识别: 新闻分类、话题聚类
├── 意图识别: 客服意图分类、搜索意图理解
└── 关系推理: "小明是小红的哥哥" → 小红是小明的妹妹
""")

def transform_text(text: str, transformation: str, **kwargs) -> str:  # **kwargs收集关键字参数
    """
    文本转换：翻译、格式转换、风格转换等

    transformation类型:
    - translate: 翻译
    - formalize: 正式化
    - simplify: 简化
    - rewrite: 改写风格
    - fix_grammar: 修正语法
    - format_convert: 格式转换(JSON→YAML等)
    """
    prompts = {
        "translate": f"将以下文本翻译为{kwargs.get('target_lang', '英文')}，保持原文风格:\n{text}",

        "formalize": f"将以下口语化文本改写为正式商务风格，保持原意:\n{text}",

        "simplify": f"用小学生能理解的语言重新解释以下内容:\n{text}",

        "rewrite": f"以{kwargs.get('style', '幽默')}的风格重写以下文本:\n{text}",

        "fix_grammar": f"修正以下文本中的语法和拼写错误，列出所有修改:\n{text}",

        "format_convert": f"将以下{kwargs.get('from_format', 'JSON')}转换为{kwargs.get('to_format', 'YAML')}:\n{text}",
    }

    prompt = prompts.get(transformation, f"对以下文本进行{transformation}:\n{text}")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )
    return response.choices[0].message.content

# 一封邮件的多种转换
email_draft = "老板，那个项目搞不定了，客户又改需求了，能不能再加两个人？急！"

# formal = transform_text(email_draft, "formalize")
# english = transform_text(email_draft, "translate", target_lang="英文")

print("""
转换应用大全:
┌─────────────────┬──────────────────────────────────┐
│ 转换类型        │ 实用场景                          │
├─────────────────┼──────────────────────────────────┤
│ 语言翻译        │ 多语言内容、文档本地化            │
│ 语气转换        │ 口语→正式、正式→亲切             │
│ 格式转换        │ JSON↔YAML, Markdown→HTML         │
│ 语法修正        │ 文档校对、非母语写作辅助          │
│ 简化/扩写       │ 面向不同受众的内容适配            │
│ 代码转换        │ Python→JavaScript, SQL→ORM       │
│ 风格迁移        │ 学术→科普, 新闻→故事体           │
└─────────────────┴──────────────────────────────────┘
""")

def expand_text(seed: str, task: str = "email", **kwargs) -> str:
    """
    文本扩展：从简短输入生成详细内容

    关键注意:
    1. 控制temperature避免胡编乱造
    2. 提供足够的约束和上下文
    3. 指定输出的结构和长度
    """
    prompts = {
        "email": f"""根据以下信息撰写一封完整的邮件:
要点: {seed}
语气: {kwargs.get('tone', '专业友好')}
长度: {kwargs.get('length', '150-200字')}

要求:
1. 包含恰当的开头和结尾
2. 逻辑清晰，条理分明
3. 不要编造未提及的具体事实
""",
        "article": f"""根据以下大纲扩写为一篇完整文章:
大纲: {seed}
目标读者: {kwargs.get('audience', '技术人员')}
字数要求: {kwargs.get('length', '500-800字')}
""",
        "reply": f"""基于以下客户反馈，撰写一封回复邮件:
客户反馈: {seed}
回复语气: {kwargs.get('tone', '专业且富有同理心')}
要求: 针对每个问题给出具体解决方案
"""
    }

    prompt = prompts.get(task, f"请将以下内容扩展为详细的文本:\n{seed}")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        temperature=kwargs.get('temperature', 0.5)  # 扩展任务适当提高创造性
    )
    return response.choices[0].message.content

print("""
文本扩展最佳实践:
━━━━━━━━━━━━━━━━━

✅ 推荐做法:
  - 提供清晰的要点/大纲作为种子
  - 指定目标受众和语气
  - 设置长度和格式约束
  - 使用temperature 0.3-0.7

❌ 避免做法:
  - 种子信息过于模糊("写篇好文章")
  - 不设长度限制(可能过长或过短)
  - temperature过高(>1.0容易产生幻觉)
  - 不提供上下文(容易偏离主题)
""")

def skeleton_of_thought(question: str) -> str:
    """
    骨架提示 (Skeleton of Thought)

    核心思想: 先让LLM生成回答的骨架（要点列表），
    再对每个要点并行扩展 → 加速推理 + 提高结构性

    两阶段:
    1. Skeleton Stage: 生成3-10个要点
    2. Point-Expanding Stage: 对每个要点扩展（可并行）
    """
    # 阶段1: 生成骨架
    skeleton_prompt = f"""请为以下问题列出回答的核心要点骨架。
只输出3-8个简短的要点标题，每行一个，用数字编号。
不要展开解释。

问题: {question}
"""

    skeleton_response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": skeleton_prompt}],
        temperature=0.3
    )
    skeleton = skeleton_response.choices[0].message.content

    # 阶段2: 逐点扩展（实际可并行调用）
    points = [line.strip() for line in skeleton.split('\n') if line.strip()]  # 链式调用：strip去除空白

    expanded_parts = []
    for point in points:
        expand_prompt = f"""问题: {question}

这是回答骨架中的一个要点: {point}

请针对这个要点展开详细说明（2-4句话）。只回答这一个要点，不要重复其他要点。
"""
        expand_response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": expand_prompt}],
            temperature=0.5
        )
        expanded_parts.append(expand_response.choices[0].message.content)

    # 组合最终回答
    final_answer = f"## {question}\n\n"
    for point, expansion in zip(points, expanded_parts):  # zip按位置配对多个可迭代对象
        final_answer += f"### {point}\n{expansion}\n\n"

    return final_answer

print("""
SoT (Skeleton of Thought) 优势:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. 加速推理: 各要点可并行扩展，总时间 ≈ max(各点时间)
   传统: 顺序生成 → 时间 = 所有token生成时间
   SoT:  骨架 + 并行扩展 → 时间 ≈ 骨架 + 最长要点

2. 结构更清晰: 强制分点论述，避免"意识流"回答

3. 质量更可控: 骨架阶段可以人工审核/调整

4. 适合批量处理: 扩展阶段天然支持并行API调用

适用场景: 问答、文章生成、教程撰写
不适用: 创意写作、对话、简短回答
""")

translation_prompt = """
你是一位专业的翻译家,精通中英双语,擅长保持原文的风格和语气。

翻译要求:
1. 准确传达原文含义
2. 保持原文的风格和语气
3. 使用自然的中文表达
4. 注意文化差异
5. 保持原文的格式

原文:
{text}

请翻译成中文:
"""

ner_prompt = """
你是一个命名实体识别专家。请识别文本中的命名实体(人名、地名、组织名)。

示例:

示例1:
输入: 张三在北京的清华大学工作。
输出:
- 人名: 张三
- 地名: 北京
- 组织名: 清华大学

示例2:
输入: 李四去了上海,加入了阿里巴巴公司。
输出:
- 人名: 李四
- 地名: 上海
- 组织名: 阿里巴巴公司

示例3:
输入: 王五在深圳的腾讯公司工作。
输出:
- 人名: 王五
- 地名: 深圳
- 组织名: 腾讯公司

现在请识别以下文本中的命名实体:
输入: {text}

输出:
"""

analysis_prompt = """
请对以下文本进行分析,并以JSON格式输出结果。

输出格式要求:

article_prompt = """
请写一篇关于AI的短文。

约束条件:
1. 字数: 200-300字
2. 必须包含关键词: "机器学习", "深度学习"
3. 语言风格: 专业学术
4. 结构: 总-分-总

请严格遵守以上约束条件。
"""