提示词优化策略 #

为什么需要优化? #

提示词优化的必要性 #

text
┌─────────────────────────────────────────────────────────────┐
│                   提示词优化价值                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  初始提示词:                                                │
│  "写一个排序算法"                                            │
│  ├── 输出不确定                                             │
│  ├── 可能不符合需求                                         │
│  └── 难以复现                                               │
│                                                             │
│  优化后提示词:                                              │
│  "用 Python 实现快速排序算法,要求:                         │
│   - 添加类型注解和文档字符串                                 │
│   - 时间复杂度 O(n log n)                                   │
│   - 包含测试用例                                            │
│   - 代码风格遵循 PEP 8"                                     │
│  ├── 输出可预测                                             │
│  ├── 符合具体需求                                           │
│  └── 可复现、可维护                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

优化的目标 #

text
1. 准确性
   └── 输出结果正确、符合预期

2. 一致性
   └── 多次运行结果稳定

3. 完整性
   └── 输出包含所有需要的信息

4. 格式规范
   └── 输出格式符合要求

5. 效率
   └── Token 消耗合理,响应时间可接受

优化流程 #

标准优化流程 #

text
┌─────────────────────────────────────────────────────────────┐
│                    提示词优化流程                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────┐                                              │
│  │ 1. 定义目标│                                              │
│  │ 明确需求   │                                              │
│  └─────┬────┘                                              │
│        ↓                                                    │
│  ┌──────────┐                                              │
│  │ 2. 编写初版│                                              │
│  │ 基础提示词 │                                              │
│  └─────┬────┘                                              │
│        ↓                                                    │
│  ┌──────────┐    ┌──────────┐                              │
│  │ 3. 测试评估│ → │ 4. 分析问题│                              │
│  │ 运行测试   │    │ 识别不足   │                              │
│  └─────┬────┘    └─────┬────┘                              │
│        │               │                                    │
│        ↓               ↓                                    │
│  ┌──────────┐    ┌──────────┐                              │
│  │ 5. 制定方案│ ← │ 6. 实施改进│                              │
│  │ 优化策略   │    │ 修改提示词 │                              │
│  └─────┬────┘    └─────┬────┘                              │
│        │               │                                    │
│        └───────┬───────┘                                    │
│                ↓                                            │
│        ┌──────────┐                                        │
│        │ 7. 验证效果│                                        │
│        │ 对比测试   │ ──→ 不满意则返回步骤 3                  │
│        └─────┬────┘                                        │
│              ↓                                              │
│        ┌──────────┐                                        │
│        │ 8. 文档化 │                                        │
│        │ 记录版本   │                                        │
│        └──────────┘                                        │
│                                                             │
└─────────────────────────────────────────────────────────────┘

迭代优化示例 #

text
迭代 1:初始版本
─────────────────────────────────────────────────
提示词:"写一个函数计算斐波那契数列"

输出:
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

问题:
- 没有类型注解
- 没有文档字符串
- 递归效率低

─────────────────────────────────────────────────

迭代 2:添加要求
─────────────────────────────────────────────────
提示词:"用 Python 写一个计算斐波那契数列的函数,
       添加类型注解和文档字符串"

输出:
def fibonacci(n: int) -> int:
    """计算斐波那契数列的第 n 项"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

问题:
- 仍然使用递归,效率问题未解决

─────────────────────────────────────────────────

迭代 3:优化性能
─────────────────────────────────────────────────
提示词:"用 Python 写一个计算斐波那契数列的函数:
       - 添加类型注解和文档字符串
       - 使用迭代方式,避免递归
       - 时间复杂度 O(n)"

输出:
def fibonacci(n: int) -> int:
    """计算斐波那契数列的第 n 项
    
    Args:
        n: 要计算的项数(从 0 开始)
    
    Returns:
        斐波那契数列的第 n 项
    
    时间复杂度: O(n)
    空间复杂度: O(1)
    """
    if n <= 1:
        return n
    
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

✅ 满足所有要求

问题诊断方法 #

常见问题类型 #

text
┌─────────────────────────────────────────────────────────────┐
│                    常见问题分类                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  1. 内容问题                                                │
│     ├── 输出不准确                                          │
│     ├── 信息不完整                                          │
│     ├── 偏离主题                                            │
│     └── 幻觉(编造信息)                                     │
│                                                             │
│  2. 格式问题                                                │
│     ├── 格式不符合要求                                       │
│     ├── 结构混乱                                            │
│     ├── 长度不当                                            │
│     └── 缺少必要元素                                         │
│                                                             │
│  3. 风格问题                                                │
│     ├── 语气不当                                            │
│     ├── 风格不一致                                          │
│     ├── 专业度不够                                          │
│     └── 受众不匹配                                          │
│                                                             │
│  4. 一致性问题                                              │
│     ├── 多次运行结果不同                                     │
│     ├── 相同输入不同输出                                     │
│     └── 随机性过高                                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

诊断检查清单 #

text
内容检查:
□ 输出是否回答了问题?
□ 信息是否准确?
□ 是否包含所有要求的要点?
□ 是否有明显的错误?

格式检查:
□ 输出格式是否正确?
□ 结构是否清晰?
□ 长度是否合适?
□ 是否有遗漏的元素?

风格检查:
□ 语气是否恰当?
□ 风格是否一致?
□ 是否适合目标受众?
□ 专业术语使用是否得当?

一致性检查:
□ 多次运行结果是否相似?
□ 相同输入是否得到相同输出?
□ Temperature 设置是否合适?

问题诊断示例 #

text
问题:输出偏离主题

诊断过程:
1. 检查提示词
   - 任务描述是否清晰?
   - 是否有歧义?
   - 是否有干扰信息?

2. 分析输出
   - 偏离的部分是什么?
   - 可能的原因是什么?

3. 制定方案
   - 添加约束条件
   - 明确范围限制
   - 提供示例引导

示例:
─────────────────────────────────────────────────
原提示词:
"介绍一下 Python"

输出:
Python 是一种编程语言...(然后开始讲 Python 的历史、
创始人、命名由来等,偏离了技术介绍的重点)

诊断:
- 提示词太宽泛
- 没有明确重点

改进后:
"请从技术角度介绍 Python 编程语言,包括:
 1. 语言特点
 2. 主要应用领域
 3. 基本语法示例
 不需要介绍历史背景。"
─────────────────────────────────────────────────

A/B 测试 #

A/B 测试流程 #

text
┌─────────────────────────────────────────────────────────────┐
│                    A/B 测试流程                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  步骤 1:确定测试目标                                        │
│  ├── 要优化什么指标?                                       │
│  └── 期望达到什么效果?                                      │
│                                                             │
│  步骤 2:设计测试变体                                        │
│  ├── 版本 A(对照组):当前版本                              │
│  └── 版本 B(实验组):改进版本                              │
│                                                             │
│  步骤 3:准备测试数据                                        │
│  ├── 选择代表性输入                                         │
│  └── 准备评估标准                                           │
│                                                             │
│  步骤 4:执行测试                                            │
│  ├── 对相同输入运行两个版本                                  │
│  └── 记录输出结果                                           │
│                                                             │
│  步骤 5:评估结果                                            │
│  ├── 对比输出质量                                           │
│  ├── 统计成功率                                             │
│  └── 分析差异原因                                           │
│                                                             │
│  步骤 6:选择最优版本                                        │
│  ├── 确定胜出版本                                           │
│  └── 记录优化经验                                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

A/B 测试示例 #

text
测试目标:提高代码生成的注释质量

版本 A(对照组):
─────────────────────────────────────────────────
提示词:
"请用 Python 实现二分查找算法"

输出:
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1
─────────────────────────────────────────────────

版本 B(实验组):
─────────────────────────────────────────────────
提示词:
"请用 Python 实现二分查找算法,要求:
 - 添加详细的中文注释
 - 解释每个步骤的作用
 - 说明时间复杂度"

输出:
def binary_search(arr: list, target: int) -> int:
    """二分查找算法
    
    在有序数组中查找目标值,返回其索引。
    如果未找到,返回 -1。
    
    时间复杂度: O(log n)
    空间复杂度: O(1)
    """
    left, right = 0, len(arr) - 1
    
    while left <= right:
        # 计算中间位置
        mid = (left + right) // 2
        
        # 找到目标值
        if arr[mid] == target:
            return mid
        
        # 目标值在右半部分
        elif arr[mid] < target:
            left = mid + 1
        
        # 目标值在左半部分
        else:
            right = mid - 1
    
    # 未找到目标值
    return -1
─────────────────────────────────────────────────

评估结果:
| 指标 | 版本 A | 版本 B |
|------|--------|--------|
| 有注释 | 否 | 是 |
| 注释详细度 | 0/5 | 5/5 |
| 有类型注解 | 否 | 是 |
| 有文档字符串 | 否 | 是 |

结论:版本 B 胜出

版本管理 #

版本记录格式 #

text
# 提示词版本记录

## 版本:v1.3
## 日期:2024-01-15
## 作者:[作者]

### 变更内容
- 增加了输出格式要求
- 优化了角色描述
- 添加了示例

### 变更原因
- v1.2 输出格式不稳定
- 需要更专业的角色设定

### 测试结果
- 准确率:95%(+5%)
- 格式符合率:100%(+20%)
- 用户满意度:4.5/5

### 提示词内容
[完整的提示词内容]

### 备注
- 需要关注 Token 消耗
- 下版本考虑精简示例

版本对比表 #

text
| 版本 | 日期 | 主要变更 | 准确率 | Token消耗 | 备注 |
|------|------|----------|--------|-----------|------|
| v1.0 | 01-01 | 初始版本 | 70% | 200 | 基础功能 |
| v1.1 | 01-05 | 添加示例 | 80% | 350 | 效果提升 |
| v1.2 | 01-10 | 优化结构 | 85% | 300 | Token优化 |
| v1.3 | 01-15 | 增强约束 | 95% | 320 | 当前版本 |

优化技巧总结 #

技巧一:渐进式优化 #

text
不要一次性修改太多,每次只改一个方面:

迭代 1:修复内容问题
迭代 2:优化格式问题
迭代 3:改进风格问题
迭代 4:提升一致性

好处:
├── 容易定位问题
├── 可以评估每个改动的影响
└── 便于回滚

技巧二:问题优先级 #

text
优先级排序:
1. 准确性问题(最高优先级)
   └── 输出错误必须首先解决

2. 完整性问题
   └── 确保输出包含所有必要信息

3. 格式问题
   └── 规范输出格式

4. 风格问题
   └── 调整语气和风格

5. 效率问题
   └── 优化 Token 消耗

技巧三:建立优化日志 #

text
优化日志模板:

日期:2024-01-15
提示词:[名称/ID]

问题描述:
输出缺少类型注解

诊断分析:
提示词中没有明确要求类型注解

解决方案:
添加"请添加类型注解"的要求

测试结果:
✅ 输出包含类型注解

经验总结:
代码生成任务应明确要求类型注解

下一步 #

现在你已经掌握了提示词优化策略,接下来学习 安全与防护,了解如何保护你的 AI 应用!

最后更新:2026-04-05