Prompt A/B测试：数据驱动的Prompt优化方法

“这个 Prompt 效果好不好？“——在没有数据支撑的情况下，这个问题往往只能靠感觉回答。A/B 测试为 Prompt 优化提供了科学的决策依据。

一、为什么需要 A/B 测试？

1.1 主观判断的局限

开发者感觉：新版Prompt更好
实际数据：
┌──────────┬──────────┬──────────┐
│ 指标     │ V1(旧)   │ V2(新)   │
├──────────┼──────────┼──────────┤
│ 准确率   │ 87%      │ 82%      │ ← 实际上更差了
│ 用户评分 │ 4.2      │ 3.8      │
│ 响应长度 │ 120字    │ 230字    │ ← 变得更啰嗦
└──────────┴──────────┴──────────┘
结论：V1更好。如果没有A/B测试，可能会错误上线V2。

1.2 A/B 测试的价值

二、A/B 测试框架

2.1 基础实现

import random
import statistics
from dataclasses import dataclass
from typing import List, Dict, Callable

@dataclass
class ABTestResult:
    version: str
    prompt: str
    sample_size: int
    metrics: Dict[str, float]
    confidence: float

class ABTestFramework:
    """
    Prompt A/B 测试框架
    """
    
    def __init__(self, llm, metric_func: Callable):
        self.llm = llm
        self.metric = metric_func
        self.results = []
    
    def run_test(self, 
                 prompt_a: str,    # 控制组
                 prompt_b: str,    # 实验组
                 test_cases: List[Dict],
                 split_ratio: float = 0.5,
                 num_runs: int = 3) -> ABTestResult:
        """
        运行 A/B 测试
        
        test_cases: [{"input": "问题", "expected": "期望输出"}, ...]
        num_runs: 每组跑几轮（取平均）
        """
        # 分割测试集
        random.shuffle(test_cases)
        split = int(len(test_cases) * split_ratio)
        case_a = test_cases[:split]
        case_b = test_cases[split:]
        
        # 测试 Prompt A
        scores_a = []
        for _ in range(num_runs):
            run_scores = []
            for case in case_a:
                response = self.llm(prompt_a + "\n" + case['input'])
                score = self.metric(response, case['expected'], case['input'])
                run_scores.append(score)
            scores_a.append(statistics.mean(run_scores))
        
        # 测试 Prompt B
        scores_b = []
        for _ in range(num_runs):
            run_scores = []
            for case in case_b:
                response = self.llm(prompt_b + "\n" + case['input'])
                score = self.metric(response, case['expected'], case['input'])
                run_scores.append(score)
            scores_b.append(statistics.mean(run_scores))
        
        # 统计分析
        mean_a = statistics.mean(scores_a)
        mean_b = statistics.mean(scores_b)
        
        return {
            'version_a': {
                'prompt_snippet': prompt_a[:100],
                'mean_score': mean_a,
                'std_dev': statistics.stdev(scores_a) if len(scores_a) > 1 else 0,
                'sample_size': len(case_a)
            },
            'version_b': {
                'prompt_snippet': prompt_b[:100],
                'mean_score': mean_b,
                'std_dev': statistics.stdev(scores_b) if len(scores_b) > 1 else 0,
                'sample_size': len(case_b)
            },
            'improvement': ((mean_b - mean_a) / mean_a * 100) if mean_a > 0 else 0,
            'winner': 'A' if mean_a >= mean_b else 'B'
        }

2.2 生产环境 A/B 测试

class ProductionABTest:
    """
    生产环境 A/B 测试
    真实流量分流，收集用户反馈
    """
    
    def __init__(self):
        self.experiments = {}
    
    def start_experiment(self, 
                         name: str,
                         prompt_a: str,
                         prompt_b: str,
                         traffic_split: float = 0.1,
                         min_samples: int = 1000):
        """
        启动生产环境 A/B 测试
        
        traffic_split: 实验组占流量的比例
        """
        self.experiments[name] = {
            'prompts': {'A': prompt_a, 'B': prompt_b},
            'traffic_split': traffic_split,
            'results': {'A': [], 'B': []},
            'status': 'running'
        }
    
    def assign_version(self, user_id: str, experiment: str) -> str:
        """
        为用户分配实验版本
        """
        if random.random() < self.experiments[experiment]['traffic_split']:
            return 'B'  # 实验组
        return 'A'  # 控制组
    
    def record_result(self, experiment: str, version: str, 
                      user_rating: float, latency: float):
        """
        记录一次结果
        """
        self.experiments[experiment]['results'][version].append({
            'rating': user_rating,
            'latency': latency
        })
    
    def analyze(self, experiment: str) -> dict:
        """
        分析实验结果
        """
        exp = self.experiments[experiment]
        results_a = exp['results']['A']
        results_b = exp['results']['B']
        
        stats_a = {
            'count': len(results_a),
            'avg_rating': mean(r['rating'] for r in results_a),
            'avg_latency': mean(r['latency'] for r in results_a)
        }
        
        return {
            'experiment': experiment,
            'version_a': stats_a,
            'version_b': {
                'count': len(results_b),
                'avg_rating': mean(r['rating'] for r in results_b),
                'avg_latency': mean(r['latency'] for r in results_b)
            },
            'sample_size': len(results_a) + len(results_b),
            'status': exp['status']
        }

三、评估指标设计

3.1 自动化指标

3.2 人工评估矩阵

# 人工评估标准
evaluation_criteria = {
    "准确性（1-5）": {
        "5": "完全正确，信息精准",
        "4": "基本正确，略有遗漏",
        "3": "部分正确，有中等错误",
        "2": "较多错误",
        "1": "完全错误"
    },
    "完整性（1-5）": {
        "5": "包含了所有必要信息",
        "4": "包含了大部分必要信息",
        "3": "缺少一些关键信息",
        "2": "缺少多个关键信息",
        "1": "信息极度不足"
    }
}

四、常见陷阱

4.1 误区清单

五、最佳实践 Checklist

• 定义清晰的评估指标
• 准备足够的测试用例（100+）
• 严格分离训练集和测试集
• 每组跑 3-5 次取平均（LLM 有随机性）
• 一次只改变一个变量
• 记录完整实验信息（版本、日期、结果）
• 关注统计显著性（p < 0.05）
• 上线后继续追踪长期效果

总结

A/B 测试将 Prompt 优化从”艺术”变为”科学”。通过建立可量化的评估指标和系统化的实验流程，团队可以数据驱动地持续提升 Prompt 质量，避免”凭感觉优化”的陷阱。