第1730篇：提示词工程的评估指标体系——如何量化Prompt的质量改进
2026/4/30大约 11 分钟
第1730篇：提示词工程的评估指标体系——如何量化Prompt的质量改进
"这个Prompt改了之后感觉好多了。"
这句话我在代码评审里从来不接受，在Prompt讨论里也不应该接受。
"感觉好了"不是工程语言。工程语言是：哪个指标提升了多少、在什么测试集上、置信区间是多少。
但Prompt评估确实比代码评估难。代码有单元测试、有明确的通过/失败标准。Prompt的输出往往是自然语言，"好"和"不好"有时候本身就是主观的。
这篇文章来聊这个问题：怎么给Prompt建立一套量化的评估体系，让Prompt的改进从"感觉好了"变成"可以证明的改进"。
评估体系的层次
Prompt的评估不是单一维度的，我把它分成三个层次：
三个层次缺一不可。只关注第一层（任务执行质量），会忽略内容本身的问题；只关注第一和第二层，会在生产环境里碰到成本和稳定性的墙。
层次一：任务执行质量指标
这一层的指标相对客观，可以自动化计算。
1.1 精确匹配率（Exact Match）
最严格的指标，适合结构化输出（JSON字段、分类标签等）：
@Component
public class ExactMatchEvaluator {
/**
* 计算JSON字段级别的精确匹配率
*/
public ExactMatchResult evaluate(String actualJson, String expectedJson) {
try {
Map<String, Object> actual = parseJson(actualJson);
Map<String, Object> expected = parseJson(expectedJson);
int totalFields = expected.size();
int matchedFields = 0;
List<FieldMismatch> mismatches = new ArrayList<>();
for (Map.Entry<String, Object> entry : expected.entrySet()) {
String fieldName = entry.getKey();
Object expectedValue = entry.getValue();
Object actualValue = actual.get(fieldName);
if (Objects.equals(normalizeValue(expectedValue), normalizeValue(actualValue))) {
matchedFields++;
} else {
mismatches.add(new FieldMismatch(fieldName, expectedValue, actualValue));
}
}
double matchRate = (double) matchedFields / totalFields;
return ExactMatchResult.builder()
.matchRate(matchRate)
.matchedFields(matchedFields)
.totalFields(totalFields)
.mismatches(mismatches)
.build();
} catch (JsonParseException e) {
// JSON格式错误也是一种失败
return ExactMatchResult.formatError(e.getMessage());
}
}
// 标准化处理：忽略大小写、去掉多余空格、统一数字格式
private Object normalizeValue(Object value) {
if (value instanceof String) {
return ((String) value).trim().toLowerCase();
}
return value;
}
}1.2 语义匹配率（Semantic Match）
对于不要求精确匹配但需要语义一致的场景：
@Component
public class SemanticMatchEvaluator {
@Autowired
private EmbeddingClient embeddingClient;
private static final double SEMANTIC_MATCH_THRESHOLD = 0.85;
/**
* 计算批量测试案例的语义匹配率
*/
public SemanticMatchResult evaluateBatch(List<EvaluationCase> cases) {
int total = cases.size();
int semanticMatches = 0;
List<CaseMismatch> lowScoreCases = new ArrayList<>();
for (EvaluationCase evalCase : cases) {
double similarity = computeSimilarity(
evalCase.getActualOutput(),
evalCase.getExpectedOutput()
);
if (similarity >= SEMANTIC_MATCH_THRESHOLD) {
semanticMatches++;
} else {
lowScoreCases.add(new CaseMismatch(evalCase, similarity));
}
}
return SemanticMatchResult.builder()
.matchRate((double) semanticMatches / total)
.totalCases(total)
.matchedCases(semanticMatches)
.lowScoreCases(lowScoreCases)
.averageSimilarity(computeAverageSimilarity(cases))
.build();
}
private double computeSimilarity(String text1, String text2) {
float[] embedding1 = embeddingClient.embed(text1);
float[] embedding2 = embeddingClient.embed(text2);
return cosineSimilarity(embedding1, embedding2);
}
}1.3 分类任务的精确率/召回率
对分类任务（意图识别、情感分析等），要同时看精确率和召回率：
@Component
public class ClassificationEvaluator {
public ClassificationMetrics evaluate(List<ClassificationCase> cases) {
// 按类别统计TP、FP、FN
Map<String, ConfusionMatrix> matrixByLabel = new HashMap<>();
for (ClassificationCase c : cases) {
String predicted = c.getPredictedLabel();
String actual = c.getActualLabel();
// 对每个类别更新混淆矩阵
for (String label : c.getAllLabels()) {
ConfusionMatrix matrix = matrixByLabel.computeIfAbsent(label, k -> new ConfusionMatrix());
boolean isPredictedPositive = label.equals(predicted);
boolean isActualPositive = label.equals(actual);
if (isPredictedPositive && isActualPositive) matrix.incrementTP();
else if (isPredictedPositive) matrix.incrementFP();
else if (isActualPositive) matrix.incrementFN();
else matrix.incrementTN();
}
}
// 计算每个类别的精确率、召回率、F1
Map<String, LabelMetrics> labelMetrics = new HashMap<>();
for (Map.Entry<String, ConfusionMatrix> entry : matrixByLabel.entrySet()) {
ConfusionMatrix matrix = entry.getValue();
double precision = matrix.precision();
double recall = matrix.recall();
double f1 = matrix.f1();
labelMetrics.put(entry.getKey(), new LabelMetrics(precision, recall, f1));
}
// 计算宏平均F1（Macro-F1）
double macroF1 = labelMetrics.values().stream()
.mapToDouble(LabelMetrics::getF1)
.average()
.orElse(0);
// 计算加权F1（考虑类别不平衡）
long totalCases = cases.size();
double weightedF1 = labelMetrics.entrySet().stream()
.mapToDouble(e -> {
long labelCount = cases.stream()
.filter(c -> c.getActualLabel().equals(e.getKey()))
.count();
return e.getValue().getF1() * (double) labelCount / totalCases;
})
.sum();
return ClassificationMetrics.builder()
.labelMetrics(labelMetrics)
.macroF1(macroF1)
.weightedF1(weightedF1)
.accuracy(computeAccuracy(cases))
.build();
}
}层次二：生成内容质量指标
这一层更难量化，通常需要借助另一个LLM作为评判者（LLM-as-a-Judge）。
2.1 G-Eval框架的实现
G-Eval是目前较为成熟的LLM自动评估框架，核心思路是用LLM按照指定的评分标准给输出打分：
@Component
public class GEvalEvaluator {
private final LLMClient judgeClient;
/**
* 评估生成内容的四个核心维度
*/
public GEvalResult evaluate(String input, String output, String context) {
double relevanceScore = evaluateDimension(input, output, context, RELEVANCE_CRITERIA);
double coherenceScore = evaluateDimension(input, output, context, COHERENCE_CRITERIA);
double consistencyScore = evaluateDimension(input, output, context, CONSISTENCY_CRITERIA);
double fluencyScore = evaluateDimension(input, output, context, FLUENCY_CRITERIA);
double overall = relevanceScore * 0.35 + coherenceScore * 0.25
+ consistencyScore * 0.25 + fluencyScore * 0.15;
return GEvalResult.builder()
.relevance(relevanceScore)
.coherence(coherenceScore)
.consistency(consistencyScore)
.fluency(fluencyScore)
.overall(overall)
.build();
}
private double evaluateDimension(String input, String output, String context, String criteria) {
String evalPrompt = """
你是一位专业的内容质量评估员。请根据以下标准对AI生成的内容进行评分。
评估标准：
%s
用户输入：
%s
参考上下文（如有）：
%s
AI生成的内容：
%s
评分步骤：
1. 仔细阅读评估标准
2. 分析生成内容是否满足标准中的每个要点
3. 给出1-5的分数（5分最好，1分最差）
4. 提供简短的评分理由（1-2句话）
输出格式（JSON）：
{"score": <1-5的整数>, "reason": "<评分理由>"}
""".formatted(criteria, input, context != null ? context : "无", output);
String result = judgeClient.complete(evalPrompt);
return parseScore(result) / 5.0; // 标准化到0-1
}
// 相关性评估标准
private static final String RELEVANCE_CRITERIA = """
相关性评估标准：
5分：完全解答了用户的问题，没有多余的无关内容
4分：基本解答了问题，但有少量无关内容
3分：部分解答了问题，但重要信息有所缺失
2分：只是边缘性地涉及了问题
1分：完全没有回答用户的问题
""";
// 一致性评估标准（与提供的事实/上下文是否一致）
private static final String CONSISTENCY_CRITERIA = """
一致性评估标准（生成内容是否与给定的事实/上下文一致，无幻觉）：
5分：所有信息都与上下文完全一致，无捏造内容
4分：大部分一致，有1处可能的不确定之处
3分：整体一致，但有1-2处轻微的事实不准确
2分：存在明显的事实错误或与上下文矛盾
1分：包含大量幻觉内容或与事实严重不符
""";
}2.2 对比评估（Pairwise Evaluation）
当两个版本的Prompt都有合理的输出，难以用绝对分数区分时，用对比评估：
@Component
public class PairwiseEvaluator {
private final LLMClient judgeClient;
/**
* 对比两个版本的输出，判断哪个更好
* 为避免位置偏差，随机交换A/B位置，各测一次
*/
public PairwiseResult compare(
String input,
String outputA, String promptAId,
String outputB, String promptBId) {
// 第一次：A在前，B在后
ComparisonResult forwardResult = runComparison(input, outputA, outputB, false);
// 第二次：B在前，A在后（交换位置）
ComparisonResult reverseResult = runComparison(input, outputB, outputA, true);
// 综合两次结果，消除位置偏差
String winner = resolveWinner(forwardResult, reverseResult, promptAId, promptBId);
return PairwiseResult.builder()
.promptAId(promptAId)
.promptBId(promptBId)
.winner(winner)
.forwardResult(forwardResult)
.reverseResult(reverseResult)
.isConsistent(forwardResult.getWinner().equals(reverseResult.getWinner()))
.build();
}
private ComparisonResult runComparison(String input, String output1, String output2, boolean swapped) {
String comparisonPrompt = """
你是一位公正的AI输出质量评估员。请比较以下两个AI回答，判断哪个更好。
用户问题：
%s
回答1：
%s
回答2：
%s
评估维度（按重要性排序）：
1. 准确性：回答是否正确、完整
2. 相关性：是否紧扣问题核心
3. 实用性：是否对用户有实际帮助
4. 清晰度：是否条理清晰、易于理解
请给出你的判断：回答1更好、回答2更好、还是基本相当？
并简要说明理由。
输出格式（JSON）：
{
"winner": "1" 或 "2" 或 "tie",
"confidence": "high" 或 "medium" 或 "low",
"reason": "判断理由（1-2句话）"
}
""".formatted(input, output1, output2);
String result = judgeClient.complete(comparisonPrompt);
return parseComparisonResult(result, swapped);
}
}层次三：系统运行质量指标
这一层完全可以用传统的监控指标来度量：
@Component
public class PromptRuntimeMetricsCollector {
private final MeterRegistry meterRegistry;
// 延迟分布
private final Timer firstTokenLatency;
private final Timer totalLatency;
// Token消耗
private final Counter inputTokenCounter;
private final Counter outputTokenCounter;
// 质量信号
private final Counter userPositiveFeedback;
private final Counter userNegativeFeedback;
private final Counter errorRate;
public PromptRuntimeMetricsCollector(MeterRegistry registry) {
this.meterRegistry = registry;
this.firstTokenLatency = Timer.builder("prompt.latency.first_token")
.description("Time to first token")
.register(registry);
this.totalLatency = Timer.builder("prompt.latency.total")
.description("Total response latency")
.register(registry);
this.inputTokenCounter = Counter.builder("prompt.tokens.input")
.register(registry);
this.outputTokenCounter = Counter.builder("prompt.tokens.output")
.register(registry);
this.userPositiveFeedback = Counter.builder("prompt.feedback.positive")
.register(registry);
this.userNegativeFeedback = Counter.builder("prompt.feedback.negative")
.register(registry);
this.errorRate = Counter.builder("prompt.errors")
.register(registry);
}
public void recordCallMetrics(PromptCallMetrics metrics) {
// 记录延迟
firstTokenLatency.record(metrics.getFirstTokenLatencyMs(), TimeUnit.MILLISECONDS);
totalLatency.record(metrics.getTotalLatencyMs(), TimeUnit.MILLISECONDS);
// 记录Token使用
inputTokenCounter.increment(metrics.getInputTokens());
outputTokenCounter.increment(metrics.getOutputTokens());
// 基于Token计算成本
double costUsd = computeCost(metrics.getInputTokens(), metrics.getOutputTokens(), metrics.getModelId());
meterRegistry.gauge("prompt.cost.usd", costUsd);
// 记录错误
if (metrics.isError()) {
errorRate.increment();
}
}
private double computeCost(int inputTokens, int outputTokens, String modelId) {
// 按不同模型的定价计算
ModelPricing pricing = ModelPricing.of(modelId);
return (inputTokens * pricing.getInputPricePerToken()
+ outputTokens * pricing.getOutputPricePerToken()) / 1000.0;
}
}评估流水线的完整设计
把三个层次的评估整合成一条完整的流水线：
@Service
public class PromptEvaluationPipeline {
@Autowired
private TaskQualityEvaluator taskQualityEvaluator;
@Autowired
private ContentQualityEvaluator contentQualityEvaluator;
@Autowired
private PromptRuntimeMetricsCollector runtimeCollector;
@Autowired
private LLMClient targetLlmClient;
public ComprehensiveEvaluationReport run(
String promptToEvaluate,
EvaluationConfig config) {
log.info("开始评估Prompt，测试集大小: {}", config.getTestCases().size());
// 第一步：运行所有测试案例，收集输出
List<EvaluationCaseResult> caseResults = new ArrayList<>();
for (EvaluationCase testCase : config.getTestCases()) {
long startTime = System.currentTimeMillis();
try {
String actualOutput = targetLlmClient.complete(promptToEvaluate, testCase.getInput());
long latency = System.currentTimeMillis() - startTime;
int inputTokens = countTokens(promptToEvaluate + testCase.getInput());
int outputTokens = countTokens(actualOutput);
caseResults.add(EvaluationCaseResult.builder()
.testCase(testCase)
.actualOutput(actualOutput)
.latencyMs(latency)
.inputTokens(inputTokens)
.outputTokens(outputTokens)
.success(true)
.build());
} catch (Exception e) {
log.error("测试案例执行失败: {}", testCase.getId(), e);
caseResults.add(EvaluationCaseResult.failed(testCase, e.getMessage()));
}
}
// 第二步：计算任务质量指标
TaskQualityMetrics taskMetrics = taskQualityEvaluator.evaluate(caseResults);
// 第三步：对采样子集做内容质量评估（全量太慢太贵）
List<EvaluationCaseResult> sampledResults = sampleForContentEval(caseResults, config.getContentEvalSampleSize());
ContentQualityMetrics contentMetrics = contentQualityEvaluator.evaluate(sampledResults);
// 第四步：计算运行质量指标
RuntimeMetrics runtimeMetrics = computeRuntimeMetrics(caseResults);
// 第五步：生成综合报告
return buildReport(promptToEvaluate, taskMetrics, contentMetrics, runtimeMetrics, caseResults);
}
private ComprehensiveEvaluationReport buildReport(
String prompt,
TaskQualityMetrics taskMetrics,
ContentQualityMetrics contentMetrics,
RuntimeMetrics runtimeMetrics,
List<EvaluationCaseResult> caseResults) {
// 计算综合质量分数（加权平均）
double overallScore =
taskMetrics.getWeightedScore() * 0.5 + // 任务执行质量权重最高
contentMetrics.getWeightedScore() * 0.35 + // 内容质量次之
runtimeMetrics.getNormalizedScore() * 0.15; // 运行质量权重最低
// 找出表现最差的测试案例（用于定向优化）
List<EvaluationCaseResult> worstCases = caseResults.stream()
.filter(r -> r.getQualityScore() < 0.6)
.sorted(Comparator.comparingDouble(EvaluationCaseResult::getQualityScore))
.limit(5)
.collect(Collectors.toList());
return ComprehensiveEvaluationReport.builder()
.promptHash(computeHash(prompt))
.overallScore(overallScore)
.taskQualityMetrics(taskMetrics)
.contentQualityMetrics(contentMetrics)
.runtimeMetrics(runtimeMetrics)
.totalCases(caseResults.size())
.successRate((double) caseResults.stream().filter(EvaluationCaseResult::isSuccess).count() / caseResults.size())
.worstPerformingCases(worstCases)
.evaluatedAt(Instant.now())
.build();
}
}建立基准线和回归测试
有了评估体系之后，还需要建立基准线（Baseline）：
@Service
public class PromptRegressionTestService {
@Autowired
private PromptEvaluationPipeline evaluationPipeline;
@Autowired
private PromptBaselineRepository baselineRepo;
/**
* 将当前最佳版本设为基准线
*/
public PromptBaseline setBaseline(String promptId, String versionId) {
ComprehensiveEvaluationReport report = evaluationPipeline.run(
getPromptContent(promptId, versionId),
getStandardEvalConfig(promptId)
);
PromptBaseline baseline = PromptBaseline.builder()
.promptId(promptId)
.versionId(versionId)
.overallScore(report.getOverallScore())
.taskQualityScore(report.getTaskQualityMetrics().getWeightedScore())
.contentQualityScore(report.getContentQualityMetrics().getWeightedScore())
.avgLatencyMs(report.getRuntimeMetrics().getAvgLatencyMs())
.avgTokensPerCall(report.getRuntimeMetrics().getAvgTotalTokens())
.setAt(Instant.now())
.build();
return baselineRepo.save(baseline);
}
/**
* 对新版本做回归测试，检查是否有指标退步
*/
public RegressionTestResult runRegressionTest(String promptId, String newVersionId) {
PromptBaseline baseline = baselineRepo.findByPromptId(promptId)
.orElseThrow(() -> new BaselineNotSetException("请先设置基准线"));
ComprehensiveEvaluationReport newReport = evaluationPipeline.run(
getPromptContent(promptId, newVersionId),
getStandardEvalConfig(promptId)
);
List<RegressionAlert> alerts = new ArrayList<>();
// 检查各指标是否有显著退步
checkMetricRegression(
"overall_score",
baseline.getOverallScore(),
newReport.getOverallScore(),
0.02, // 超过2%的退步才告警
alerts
);
checkMetricRegression(
"task_quality",
baseline.getTaskQualityScore(),
newReport.getTaskQualityMetrics().getWeightedScore(),
0.03,
alerts
);
checkMetricRegression(
"latency_p99",
(double) baseline.getP99LatencyMs(),
(double) newReport.getRuntimeMetrics().getP99LatencyMs(),
0.20, // 延迟超过20%的增长才告警
alerts
);
boolean passed = alerts.stream().noneMatch(a -> a.getSeverity() == AlertSeverity.CRITICAL);
return RegressionTestResult.builder()
.newVersionId(newVersionId)
.baselineVersionId(baseline.getVersionId())
.passed(passed)
.alerts(alerts)
.newReport(newReport)
.build();
}
private void checkMetricRegression(
String metricName,
double baselineValue,
double newValue,
double toleranceThreshold,
List<RegressionAlert> alerts) {
// 对于越大越好的指标（分数类），退步是newValue < baselineValue
// 对于越小越好的指标（延迟类），退步是newValue > baselineValue
boolean isHigherBetter = !metricName.contains("latency") && !metricName.contains("cost");
double change;
if (isHigherBetter) {
change = (baselineValue - newValue) / baselineValue; // 正数表示退步
} else {
change = (newValue - baselineValue) / baselineValue; // 正数表示退步
}
if (change > toleranceThreshold) {
AlertSeverity severity = change > toleranceThreshold * 3
? AlertSeverity.CRITICAL : AlertSeverity.WARNING;
alerts.add(RegressionAlert.builder()
.metricName(metricName)
.baselineValue(baselineValue)
.newValue(newValue)
.regressionPercent(change * 100)
.severity(severity)
.build());
}
}
}一个关于评估的根本性问题
最后说一个容易被忽视的问题：测试集的代表性。
评估体系再完善，如果测试集不能代表真实的用户查询分布，所有评估结果都是虚的。
我见过一个团队，在他们的测试集上准确率达到了97%，但上线后用户反馈效果很差。排查发现：测试集全是由工程师自己构造的，而真实用户的表达方式和工程师完全不同——用户的问题更口语化、更模糊、更多方言表达，有大量工程师没想到的边界情况。
这要求我们在构建测试集时，至少有一部分要来自真实的用户数据（脱敏后），而不能全靠工程师"想象用户会怎么问"。
小结
量化评估是提示词工程走向成熟的必要步骤。没有量化，就没有方向感，就只能靠"感觉"，就无法在团队里形成共识。
建立评估体系的建议路径：
- 先把任务质量指标做起来（最客观、最容易自动化）
- 在关键版本迭代时补充内容质量评估
- 从上线第一天开始就收集运行质量数据
- 建立基准线，每次修改都跑回归测试
到这里，这个提示词工程系列的核心内容基本讲完了。从最基础的框架设计，到版本管理，再到评估体系，构成一个完整的提示词工程实践闭环。