如何评估 LLM 输出质量：Claude 测评方法论

一、为什么需要系统化的评估方法？

大多数团队评估 LLM 输出质量的方式是：找几个人试用一下，感觉还不错就上线。这种方式有两个致命问题：无法量化（”感觉不错”不能支撑版本对比），无法自动化（每次更新都要重新”感觉一下”）。

没有评估体系的后果是：你不知道新的 Prompt 是真的更好还是只是你的幸存者偏差；模型升级后你不知道哪些场景退步了；线上出现质量问题时你无法快速定位。

二、人工评估框架设计

人工评估不是”随便试用”，需要一套标准化的评分框架，否则不同评估者的结果无法汇总。

通用五维评分框架

评估维度（每项 1-5 分）：

1. 准确性（Accuracy）
   - 5：信息完全正确，无任何错误
   - 3：主要信息正确，有轻微偏差
   - 1：存在明显事实错误或重要遗漏

2. 相关性（Relevance）
   - 5：完全回应了用户的问题，没有偏题
   - 3：基本相关，有少量不相关内容
   - 1：大量偏题内容，核心需求未得到回应

3. 完整性（Completeness）
   - 5：覆盖了所有必要方面，无明显遗漏
   - 3：覆盖主要方面，有次要遗漏
   - 1：明显遗漏重要内容

4. 清晰度（Clarity）
   - 5：表达清晰，结构合理，易于理解
   - 3：基本清晰，有些地方需要反复阅读
   - 1：表达混乱，难以理解

5. 有用性（Usefulness）
   - 5：用户可以直接使用，无需任何修改
   - 3：需要少量调整后可以使用
   - 1：需要大幅修改才能使用

构建黄金测试集（Golden Dataset）

import json
from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime

@dataclass
class GoldenExample:
    """黄金测试集中的一条样本"""
    id:              str
    category:        str           # 任务类型，如 "代码生成" / "摘要" / "问答"
    input:           str           # 用户输入
    expected_output: Optional[str] # 参考输出（部分任务有标准答案）
    evaluation_rubric: str         # 针对这个样本的评估标准
    difficulty:      str           # easy / medium / hard
    tags:            list[str] = field(default_factory=list)
    created_at:      str = field(default_factory=lambda: datetime.now().isoformat())

class GoldenDataset:
    """黄金测试集管理"""

    def __init__(self, path: str = "golden_dataset.json"):
        self.path = path
        self.examples: list[GoldenExample] = []
        self._load()

    def _load(self):
        try:
            with open(self.path, "r", encoding="utf-8") as f:
                data = json.load(f)
                self.examples = [GoldenExample(**ex) for ex in data]
        except FileNotFoundError:
            pass

    def save(self):
        with open(self.path, "w", encoding="utf-8") as f:
            json.dump(
                [ex.__dict__ for ex in self.examples],
                f, ensure_ascii=False, indent=2
            )

    def add(self, example: GoldenExample):
        self.examples.append(example)
        self.save()

    def get_by_category(self, category: str) -> list[GoldenExample]:
        return [ex for ex in self.examples if ex.category == category]

    def summary(self):
        from collections import Counter
        cats = Counter(ex.category for ex in self.examples)
        diffs = Counter(ex.difficulty for ex in self.examples)
        print(f"总样本数：{len(self.examples)}")
        print(f"按类别：{dict(cats)}")
        print(f"按难度：{dict(diffs)}")


# 构建测试集示例
dataset = GoldenDataset()

dataset.add(GoldenExample(
    id="code_001",
    category="代码生成",
    input="写一个 Python 函数，对列表去重并保持原始顺序",
    expected_output=None,  # 代码题没有唯一答案
    evaluation_rubric="""
    评估标准：
    1. 功能正确性：必须能正确去重且保持顺序（可运行验证）
    2. 代码风格：符合 Python 惯用法（Pythonic）
    3. 边界处理：空列表、单元素列表、全相同元素
    4. 效率：时间复杂度应为 O(n)
    """,
    difficulty="easy",
    tags=["python", "list", "deduplication"]
))

dataset.add(GoldenExample(
    id="summary_001",
    category="摘要",
    input="[500字新闻文章]",
    expected_output="[人工写的参考摘要]",
    evaluation_rubric="""
    评估标准：
    1. 覆盖所有关键事实（5W：何时、何地、何人、何事、为何）
    2. 不添加原文没有的信息
    3. 100字以内
    4. 语言通顺，无语法错误
    """,
    difficulty="medium",
    tags=["news", "summarization"]
))

三、LLM-as-Judge：用 Claude 自动评估

LLM-as-Judge 是目前最流行的自动化评估方案——用一个强大的 LLM（通常是 Claude Opus 或 Sonnet）来评估另一个 LLM 的输出质量。它的核心优势是：速度快（秒级完成）、成本低（比人工便宜90%+）、可扩展（批量处理数千条）。

基础评估器

import anthropic
import json
from dataclasses import dataclass
from typing import Optional

client = anthropic.Anthropic()

@dataclass
class EvaluationResult:
    score:       float          # 综合分 0-10
    dimensions:  dict           # 各维度得分
    reasoning:   str            # 评分理由
    passed:      bool           # 是否通过质量门禁
    issues:      list[str]      # 发现的主要问题


JUDGE_SYSTEM = """你是一名专业的 AI 输出质量评估专家。
你的职责是客观、严格地评估 AI 助手的输出质量。

评估原则：
- 客观公正，不受输出长度影响（长不等于好）
- 对事实错误零容忍，发现一处扣2分
- 着重关注用户的实际需求是否被满足
- 避免位置偏见（不因内容在输入中的位置而影响评分）"""


def evaluate_output(
    user_input:   str,
    ai_output:    str,
    rubric:       str = "",
    reference:    Optional[str] = None,
    judge_model:  str = "claude-sonnet-4-6",
) -> EvaluationResult:
    """
    用 Claude 评估 AI 输出质量

    Args:
        user_input:  原始用户输入
        ai_output:   被评估的 AI 输出
        rubric:      评估标准（可选，不提供则用通用标准）
        reference:   参考答案（可选）
        judge_model: 用于评估的模型
    """

    reference_section = f"\n\n参考答案（供对比，不要求完全一致）：\n{reference}" if reference else ""

    rubric_section = rubric if rubric else """
    通用评估标准：
    - 准确性：信息是否正确，有无事实错误
    - 相关性：是否直接回应了用户需求
    - 完整性：重要方面是否都已覆盖
    - 清晰度：表达是否清晰易懂
    - 有用性：用户能否直接使用"""

    prompt = f"""请评估以下 AI 输出的质量。

用户输入：
{user_input}

AI 输出：
{ai_output}{reference_section}

评估标准：
{rubric_section}

请以 JSON 格式返回评估结果，只输出 JSON：
{{
  "score": 0到10的浮点数（综合质量分）,
  "dimensions": {{
    "accuracy":     0到10,
    "relevance":    0到10,
    "completeness": 0到10,
    "clarity":      0到10,
    "usefulness":   0到10
  }},
  "reasoning": "评分理由，200字以内，说明主要优缺点",
  "issues": ["问题1", "问题2"],
  "passed": true或false（score >= 7 为通过）
}}"""

    response = client.messages.create(
        model=judge_model,
        max_tokens=1024,
        temperature=0,      # 评估用零温度，确保一致性
        system=JUDGE_SYSTEM,
        messages=[{"role": "user", "content": prompt}]
    )

    text = response.content[0].text.strip()
    if text.startswith("```"):
        text = "\n".join(text.split("\n")[1:-1]).strip()

    data = json.loads(text)
    return EvaluationResult(
        score       = data["score"],
        dimensions  = data["dimensions"],
        reasoning   = data["reasoning"],
        passed      = data["passed"],
        issues      = data.get("issues", []),
    )

防止 LLM-as-Judge 的偏差

LLM 评估器有几个已知偏差需要主动应对：

def evaluate_with_debiasing(
    user_input: str,
    output_a:   str,
    output_b:   str,
    rubric:     str = "",
) -> dict:
    """
    对比评估两个输出，用双向互换法消除位置偏差

    偏差说明：
    - 位置偏差：评估者倾向于偏好第一个或最后一个选项
    - 长度偏差：评估者倾向于认为更长的输出更好
    - 自我偏好：Claude 可能偏好 Claude 自己的风格

    解决方案：
    - 正向评估（A在前）和反向评估（B在前）各做一次
    - 结果一致则置信度高；不一致则需要人工复查
    """

    def compare(first: str, second: str, labels: tuple) -> dict:
        prompt = f"""对比以下两个 AI 输出，判断哪个质量更好。

用户问题：{user_input}

{labels[0]}：
{first}

{labels[1]}：
{second}

{f'评估标准：{rubric}' if rubric else ''}

以 JSON 返回：
{{
  "winner": "{labels[0]}" 或 "{labels[1]}" 或 "tie",
  "confidence": "high/medium/low",
  "reasoning": "选择理由，100字以内",
  "scores": {{"{labels[0]}": 0-10, "{labels[1]}": 0-10}}
}}
只输出 JSON。"""

        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=512,
            temperature=0,
            system=JUDGE_SYSTEM,
            messages=[{"role": "user", "content": prompt}]
        )
        text = response.content[0].text.strip()
        if text.startswith("```"):
            text = "\n".join(text.split("\n")[1:-1]).strip()
        return json.loads(text)

    # 正向：A 在前
    forward  = compare(output_a, output_b, ("输出A", "输出B"))
    # 反向：B 在前
    backward = compare(output_b, output_a, ("输出B", "输出A"))

    # 判断结果一致性
    # 正向 A 赢 且 反向 B 赢（即 A 始终赢）→ A 确实更好
    forward_winner  = forward["winner"]
    backward_winner = backward["winner"]

    consistent = (
        (forward_winner == "输出A" and backward_winner == "输出B") or
        (forward_winner == "输出B" and backward_winner == "输出A") or
        (forward_winner == "tie"   and backward_winner == "tie")
    )

    final_winner = "A" if forward_winner == "输出A" else (
                   "B" if forward_winner == "输出B" else "tie")

    return {
        "winner":         final_winner,
        "consistent":     consistent,
        "confidence":     "high" if consistent else "low",
        "forward_result": forward,
        "backward_result":backward,
        "needs_human_review": not consistent,
    }

四、批量基准测试

import time
from statistics import mean, stdev
from concurrent.futures import ThreadPoolExecutor, as_completed

def run_benchmark(
    test_cases:   list[dict],
    system_prompt: str,
    model:        str = "claude-sonnet-4-6",
    max_workers:  int = 5,
    pass_threshold: float = 7.0,
) -> dict:
    """
    批量运行基准测试并生成报告

    Args:
        test_cases:  测试用例列表，每个包含 input/rubric/reference(可选)
        system_prompt: 被测系统的 System Prompt
        model:       被测模型
        max_workers: 并发数
        pass_threshold: 通过分数线（默认7分）
    """
    results = []

    def run_single(case: dict) -> dict:
        start = time.time()

        # 运行被测模型
        response = client.messages.create(
            model=model,
            max_tokens=2048,
            temperature=0.3,
            system=system_prompt,
            messages=[{"role": "user", "content": case["input"]}]
        )
        output = response.content[0].text
        latency = time.time() - start

        # 用 Claude 评估输出
        eval_result = evaluate_output(
            user_input = case["input"],
            ai_output  = output,
            rubric     = case.get("rubric", ""),
            reference  = case.get("reference"),
        )

        return {
            "id":       case.get("id", "unknown"),
            "category": case.get("category", "unknown"),
            "input":    case["input"][:100] + "...",
            "output":   output[:200] + "...",
            "score":    eval_result.score,
            "passed":   eval_result.score >= pass_threshold,
            "issues":   eval_result.issues,
            "reasoning":eval_result.reasoning,
            "latency":  round(latency, 2),
            "tokens":   response.usage.input_tokens + response.usage.output_tokens,
        }

    # 并发执行
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {executor.submit(run_single, case): case for case in test_cases}
        for future in as_completed(futures):
            try:
                results.append(future.result())
            except Exception as e:
                print(f"测试用例失败：{e}")

    # 汇总统计
    scores   = [r["score"] for r in results]
    passed   = [r for r in results if r["passed"]]
    failed   = [r for r in results if not r["passed"]]
    latencies= [r["latency"] for r in results]

    # 按类别统计
    by_category = {}
    for r in results:
        cat = r["category"]
        if cat not in by_category:
            by_category[cat] = {"scores": [], "passed": 0, "total": 0}
        by_category[cat]["scores"].append(r["score"])
        by_category[cat]["total"] += 1
        if r["passed"]:
            by_category[cat]["passed"] += 1

    report = {
        "summary": {
            "total":        len(results),
            "passed":       len(passed),
            "failed":       len(failed),
            "pass_rate":    len(passed) / len(results) if results else 0,
            "avg_score":    round(mean(scores), 2) if scores else 0,
            "min_score":    round(min(scores), 2) if scores else 0,
            "score_stdev":  round(stdev(scores), 2) if len(scores) > 1 else 0,
            "avg_latency":  round(mean(latencies), 2) if latencies else 0,
        },
        "by_category": {
            cat: {
                "avg_score": round(mean(data["scores"]), 2),
                "pass_rate": data["passed"] / data["total"],
                "total":     data["total"],
            }
            for cat, data in by_category.items()
        },
        "failed_cases": [
            {"id": r["id"], "score": r["score"], "issues": r["issues"]}
            for r in sorted(failed, key=lambda x: x["score"])
        ],
        "all_results": results,
    }

    # 打印摘要
    s = report["summary"]
    print(f"\n{'='*50}")
    print(f"基准测试报告")
    print(f"{'='*50}")
    print(f"通过率：{s['pass_rate']:.1%} ({s['passed']}/{s['total']})")
    print(f"平均分：{s['avg_score']}/10 (最低 {s['min_score']}，标准差 {s['score_stdev']})")
    print(f"平均延迟：{s['avg_latency']}s")
    print(f"\n按类别：")
    for cat, data in report["by_category"].items():
        print(f"  {cat}: {data['avg_score']}/10, 通过率 {data['pass_rate']:.0%}")

    if report["failed_cases"]:
        print(f"\n最需要关注的失败案例：")
        for case in report["failed_cases"][:3]:
            print(f"  [{case['score']}分] {case['id']}: {', '.join(case['issues'][:2])}")

    return report

五、Prompt 版本回归测试

def regression_test(
    test_cases:       list[dict],
    baseline_prompt:  str,
    new_prompt:       str,
    model:            str = "claude-sonnet-4-6",
    significance:     float = 0.5,  # 分数差异超过此值才算显著
) -> dict:
    """
    对比新旧 Prompt 的质量，确保新版本没有退步

    Args:
        significance: 认为有显著差异的分数阈值
    """
    print("运行基线测试...")
    baseline_results = run_benchmark(test_cases, baseline_prompt, model)

    print("运行新版本测试...")
    new_results      = run_benchmark(test_cases, new_prompt, model)

    baseline_scores = {r["id"]: r["score"] for r in baseline_results["all_results"]}
    new_scores      = {r["id"]: r["score"] for r in new_results["all_results"]}

    regressions    = []
    improvements   = []
    no_change      = []

    for case_id in baseline_scores:
        if case_id not in new_scores:
            continue
        diff = new_scores[case_id] - baseline_scores[case_id]
        entry = {
            "id":       case_id,
            "baseline": baseline_scores[case_id],
            "new":      new_scores[case_id],
            "diff":     round(diff, 2)
        }
        if diff < -significance:
            regressions.append(entry)
        elif diff > significance:
            improvements.append(entry)
        else:
            no_change.append(entry)

    baseline_avg = baseline_results["summary"]["avg_score"]
    new_avg      = new_results["summary"]["avg_score"]
    overall_diff = new_avg - baseline_avg

    report = {
        "overall": {
            "baseline_avg": baseline_avg,
            "new_avg":      new_avg,
            "diff":         round(overall_diff, 2),
            "recommendation": "✅ 推荐升级" if overall_diff >= 0 and not regressions
                              else ("⚠️ 谨慎升级" if overall_diff > 0 else "❌ 不推荐升级"),
        },
        "regressions":  regressions,
        "improvements": improvements,
        "no_change":    no_change,
    }

    print(f"\n回归测试结果：")
    print(f"基线平均分：{baseline_avg} → 新版平均分：{new_avg} (变化：{overall_diff:+.2f})")
    print(f"退步案例：{len(regressions)} | 提升案例：{len(improvements)} | 无变化：{len(no_change)}")
    print(f"建议：{report['overall']['recommendation']}")

    if regressions:
        print(f"\n退步案例（需要重点关注）：")
        for r in sorted(regressions, key=lambda x: x["diff"])[:5]:
            print(f"  {r['id']}: {r['baseline']} → {r['new']} ({r['diff']:+.1f})")

    return report

六、接入 CI/CD 的质量门禁

#!/usr/bin/env python3
"""
quality_gate.py
在 CI/CD 流水线中自动运行质量评估
用法：python quality_gate.py --prompt prompts/v2.txt --threshold 0.80
"""
import argparse
import sys
import json
from pathlib import Path


def main():
    parser = argparse.ArgumentParser(description="LLM 输出质量门禁")
    parser.add_argument("--prompt",      required=True, help="System Prompt 文件路径")
    parser.add_argument("--test-cases",  default="tests/golden_dataset.json", help="测试集路径")
    parser.add_argument("--threshold",   type=float, default=0.80, help="通过率阈值（默认80%）")
    parser.add_argument("--min-score",   type=float, default=6.5,  help="最低平均分（默认6.5）")
    parser.add_argument("--output",      default="eval_report.json", help="报告输出路径")
    args = parser.parse_args()

    # 读取 Prompt
    prompt = Path(args.prompt).read_text(encoding="utf-8")

    # 读取测试集
    with open(args.test_cases, "r", encoding="utf-8") as f:
        test_cases = json.load(f)

    # 运行基准测试
    report = run_benchmark(test_cases, prompt)

    # 保存报告
    with open(args.output, "w", encoding="utf-8") as f:
        json.dump(report, f, ensure_ascii=False, indent=2)

    # 质量门禁判断
    pass_rate = report["summary"]["pass_rate"]
    avg_score = report["summary"]["avg_score"]

    print(f"\n质量门禁检查：")
    print(f"  通过率：{pass_rate:.1%} (要求 ≥ {args.threshold:.0%}) {'✅' if pass_rate >= args.threshold else '❌'}")
    print(f"  平均分：{avg_score} (要求 ≥ {args.min_score}) {'✅' if avg_score >= args.min_score else '❌'}")

    if pass_rate < args.threshold or avg_score < args.min_score:
        print("\n❌ 质量门禁未通过，阻断本次部署")
        print(f"详细报告已保存到：{args.output}")
        sys.exit(1)  # 非零退出码，触发 CI 失败

    print(f"\n✅ 质量门禁通过，可以继续部署")
    sys.exit(0)


if __name__ == "__main__":
    main()

GitHub Actions 集成

# .github/workflows/llm-quality-gate.yml
name: LLM Quality Gate

on:
  pull_request:
    paths:
      - 'prompts/**'
      - 'src/ai/**'

jobs:
  quality-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: pip install anthropic

      - name: Run Quality Gate
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          python quality_gate.py \
            --prompt prompts/system.txt \
            --test-cases tests/golden_dataset.json \
            --threshold 0.80 \
            --min-score 6.5 \
            --output eval_report.json

      - name: Upload Report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-report
          path: eval_report.json

七、常见评估误区

误区一：测试集太小
10-20个测试案例无法覆盖真实使用场景的分布。建议每个核心任务类型至少30-50个案例，且要包含边界情况和难例——容易的案例提高不了区分度。

误区二：用评估模型评估自己
用 claude-sonnet-4-6 同时做生成和评估，存在自我偏好问题。建议生成用 Sonnet，评估用 Opus；或者用不同厂商的模型（如用 GPT 评估 Claude 的输出）做交叉验证。

误区三：忽略延迟和成本指标
质量评估不能只看分数，延迟和 token 消耗同样重要。一个质量从7分提升到7.5分但延迟从1秒增加到5秒的版本，对用户体验来说不一定是进步。把延迟和成本也纳入评估报告。

误区四：测试集过拟合
如果你反复用同一批测试集优化 Prompt，会出现对这批测试集过拟合的问题——Prompt 在测试集上表现很好，但在真实用户使用时效果一般。建议保留一批"保留测试集"（holdout set），只在关键决策时使用，平时不用于优化。

常见问题

Q：LLM-as-Judge 的评分和人工评分的一致性有多高？
根据公开研究，强模型（如 Claude Opus、GPT-4）作为 Judge 的评分与人工评分的相关系数通常在 0.7-0.85 之间。不同任务类型差异较大：客观性强的任务（代码、信息提取）相关性更高；主观性强的任务（创意写作）相关性较低。建议定期用人工评估校准 LLM-as-Judge 的分数，确保两者不要偏差太大。

Q：每次 PR 都运行评估成本太高怎么办？
可以分层：每次 PR 只运行核心的20-30个关键测试案例（用 Haiku 做快速评估，成本极低）；每周运行一次完整的基准测试（用 Sonnet/Opus）；重大版本发布前运行全套评估。这样日常 CI 成本可以控制在每次 $0.1 以下。

Q：评估指标设计没有参考怎么办？
可以先参考业界公开的 LLM 评估框架（如 MT-Bench、HELM、RAGAS），根据你的具体任务类型选择适合的维度。最重要的是：评估指标要和业务目标对齐——如果你的产品核心是准确性，那准确性维度的权重就要最高。

总结

LLM 评估体系的建立不是一次性工程，而是随着产品迭代持续完善的过程。起步建议：第一周，手工构建20-30个黄金测试案例；第二周，实现 LLM-as-Judge 自动评估；第三周，接入 CI/CD 做质量门禁。有了这个基础，每次 Prompt 迭代、模型升级都有数据支撑，从"感觉更好"到"数据证明更好"。