大模型评测体系：从基准测试到业务指标的对齐方法论

一、评测的"虚高"困境：基准分数与业务效果的断裂

大模型评测领域存在一个普遍现象：模型在公开基准测试（MMLU、HumanEval、C-Eval）上分数持续攀升，但在实际业务中的表现却远不如分数所暗示的水平。某金融科技公司评测了三个在 MMLU 上得分超过 80 的模型用于合同审查任务，发现准确率最高的模型仅为 63%，最低的仅 41%——与基准分数的差距高达 20-40 个百分点。

这种断裂的根因在于：公开基准测试测量的是"通用能力"，而业务场景需要的是"特定能力"。一个模型可能在常识推理上表现优异，但在识别合同中的风险条款时却频频失误。更深层的问题是"数据污染"——部分模型在训练数据中包含了基准测试的题目，导致基准分数虚高，无法反映真实的泛化能力。

构建一套与业务效果对齐的评测体系，是大模型从"能跑分"到"能落地"的关键一步。

二、三层评测体系架构

flowchart TB
    subgraph L1["第一层：基础能力评测"]
        L1A[通用推理: MMLU/C-Eval]
        L1B[代码能力: HumanEval/MBPP]
        L1C[语言理解: HellaSwag/ARC]
    end

    subgraph L2["第二层：领域适配评测"]
        L2A[领域知识: 专业题库]
        L2B[领域推理: 案例分析]
        L2C[领域格式: 输出合规性]
    end

    subgraph L3["第三层：业务效果评测"]
        L3A[任务完成率: 端到端指标]
        L3B[人工验收率: 人类评审]
        L3C[成本效率: Token/延迟/费用]
    end

    L1 --> L2
    L2 --> L3

    L3 -->|反馈调优| L2
    L2 -->|反馈调优| L1

    style L1 fill:#eef,stroke:#333
    style L2 fill:#efe,stroke:#333
    style L3 fill:#fee,stroke:#333

三层体系的设计逻辑：

第一层使用公开基准测试快速筛选候选模型，过滤掉基础能力明显不足的选项。这一层的成本最低（自动化运行），但预测业务效果的能力最弱。

第二层构建领域专属评测集，测量模型在目标领域的知识储备和推理能力。这是连接基准分数和业务效果的关键桥梁。

第三层直接测量业务效果，包括任务完成率、人工验收率和成本效率。这是最终决策的依据，但成本最高（需要人工评审和业务环境部署）。

三、领域评测集构建与评测引擎实现

import json
import time
from dataclasses import dataclass, field
from typing import Callable, Optional

@dataclass
class EvalCase:
    """评测用例"""
    id: str
    category: str              # 评测类别
    prompt: str                # 输入 Prompt
    reference: str             # 参考答案
    scoring_criteria: dict     # 评分标准
    difficulty: str            # easy/medium/hard
    source: str                # 来源标注（防止数据污染）

@dataclass
class EvalResult:
    """单条评测结果"""
    case_id: str
    model_output: str
    scores: dict[str, float]   # 各维度分数
    passed: bool
    latency_ms: float
    token_count: int

@dataclass
class EvalReport:
    """评测报告"""
    model_name: str
    total_cases: int
    pass_rate: float
    category_scores: dict[str, float]
    difficulty_scores: dict[str, float]
    avg_latency_ms: float
    avg_token_count: float
    cost_per_1k_calls: float   # 每千次调用成本

class DomainEvalEngine:
    """领域评测引擎"""

    def __init__(
        self,
        llm_generate: Callable[[str], str],
        llm_judge: Optional[Callable[[str], str], float]] = None,
        contamination_check: bool = True
    ):
        self.llm_generate = llm_generate
        self.llm_judge = llm_judge  # LLM-as-Judge 评分器
        self.contamination_check = contamination_check

    def load_eval_set(self, path: str) -> list[EvalCase]:
        """加载领域评测集"""
        with open(path, 'r', encoding='utf-8') as f:
            data = json.load(f)
        cases = []
        for item in data:
            cases.append(EvalCase(
                id=item['id'],
                category=item['category'],
                prompt=item['prompt'],
                reference=item['reference'],
                scoring_criteria=item.get('scoring_criteria', {}),
                difficulty=item.get('difficulty', 'medium'),
                source=item.get('source', 'unknown')
            ))
        return cases

    def run_eval(
        self,
        cases: list[EvalCase],
        model_name: str,
        max_concurrent: int = 5
    ) -> EvalReport:
        """执行评测"""
        results: list[EvalResult] = []

        for case in cases:
            start = time.time()
            output = self.llm_generate(case.prompt)
            latency = (time.time() - start) * 1000

            # 多维度评分
            scores = self._score_output(case, output)

            results.append(EvalResult(
                case_id=case.id,
                model_output=output,
                scores=scores,
                passed=all(v >= 0.6 for v in scores.values()),
                latency_ms=latency,
                token_count=len(output) // 1.5  # 近似 Token 数
            ))

        # 聚合报告
        return self._aggregate_report(results, model_name)

    def _score_output(self, case: EvalCase, output: str) -> dict[str, float]:
        """多维度评分"""
        scores = {}

        # 维度1：关键词覆盖度
        if 'key_points' in case.scoring_criteria:
            key_points = case.scoring_criteria['key_points']
            covered = sum(1 for kp in key_points if kp.lower() in output.lower())
            scores['keyword_coverage'] = covered / len(key_points) if key_points else 0

        # 维度2：LLM-as-Judge 语义评分
        if self.llm_judge:
            judge_prompt = (
                f"参考答案：{case.reference}\n"
                f"模型输出：{output}\n"
                f"评分标准：{case.scoring_criteria.get('judge_criteria', '准确性、完整性')}\n"
                "请评分（0-1），仅输出数字："
            )
            try:
                score = float(self.llm_judge(judge_prompt))
                scores['semantic_score'] = min(max(score, 0), 1)
            except (ValueError, TypeError):
                scores['semantic_score'] = 0.5

        # 维度3：格式合规性
        if 'format_requirements' in case.scoring_criteria:
            fmt_req = case.scoring_criteria['format_requirements']
            fmt_score = 1.0
            if fmt_req.get('must_include'):
                for item in fmt_req['must_include']:
                    if item not in output:
                        fmt_score -= 0.3
            if fmt_req.get('must_not_include'):
                for item in fmt_req['must_not_include']:
                    if item in output:
                        fmt_score -= 0.5
            scores['format_compliance'] = max(fmt_score, 0)

        return scores

    def _aggregate_report(self, results: list[EvalResult], model_name: str) -> EvalReport:
        """聚合评测报告"""
        total = len(results)
        passed = sum(1 for r in results if r.passed)

        # 按类别聚合
        category_scores = {}
        for r in results:
            cat = r.case_id.split('_')[0]  # 简化的类别提取
            avg_score = sum(r.scores.values()) / len(r.scores) if r.scores else 0
            category_scores.setdefault(cat, []).append(avg_score)
        category_scores = {k: round(sum(v)/len(v), 3) for k, v in category_scores.items()}

        return EvalReport(
            model_name=model_name,
            total_cases=total,
            pass_rate=round(passed / total, 3) if total else 0,
            category_scores=category_scores,
            difficulty_scores={},  # 简化
            avg_latency_ms=round(sum(r.latency_ms for r in results) / total, 1),
            avg_token_count=round(sum(r.token_count for r in results) / total, 1),
            cost_per_1k_calls=0  # 需根据实际定价计算
        )

    def compare_models(self, reports: list[EvalReport]) -> dict:
        """多模型对比"""
        comparison = {
            "models": [r.model_name for r in reports],
            "pass_rates": [r.pass_rate for r in reports],
            "avg_latency": [r.avg_latency_ms for r in reports],
            "category_comparison": {},
        }
        # 按类别对比
        all_categories = set()
        for r in reports:
            all_categories.update(r.category_scores.keys())
        for cat in all_categories:
            comparison["category_comparison"][cat] = [
                r.category_scores.get(cat, 0) for r in reports
            ]
        return comparison

四、评测体系落地的关键 Trade-offs

评测集规模与代表性的矛盾。评测集越大，统计显著性越高，但构建成本（尤其是人工标注）也越高。实践中，领域评测集 200-500 条是性价比最优的规模——足够检测出模型间的显著差异，同时标注成本可控。

LLM-as-Judge 的偏差问题。用大模型评判大模型的输出，存在"自我偏好"偏差——某些模型倾向于给风格相似的输出更高分数。缓解方案是使用与被评测模型不同的 Judge 模型，并对 Judge 本身进行校准测试。

数据污染检测的困难。完全检测训练数据是否包含评测题目几乎不可能。务实的策略是：自建领域评测集（不公开）、定期更换评测题目、关注模型在"未见过的"题目类型上的泛化表现而非分数绝对值。

业务指标与评测指标的滞后性。评测指标可以快速迭代，但业务效果需要上线后才能验证。建议建立"评测指标 → 业务效果"的预测模型，用历史数据校准评测分数对业务效果的预测能力。

五、总结

大模型评测体系的核心价值不在于给出一个绝对分数，而在于建立"基准测试 → 领域评测 → 业务效果"的可追溯链路。三层评测架构将通用能力筛选、领域适配验证和业务效果测量分层解耦，使评测结果能够有效预测业务表现。领域评测集的自建、LLM-as-Judge 的校准和数据污染的防护，是保证评测可信度的三个关键工程措施。最终，评测体系的目标不是选出"分数最高的模型"，而是选出"业务效果最好的模型"。