模型评测体系：大模型输出一致性评估与自动化回归测试

一、大模型评测的"稳定性盲区"：同一输入，不同输出

大语言模型的非确定性是其最被低估的生产风险。同一个 Prompt，在不同时间、不同实例、不同温度参数下，可能产生截然不同的输出。更隐蔽的问题是版本升级导致的行为漂移：模型从 GPT-4-0613 升级到 GPT-4-1106 后，原本稳定的 JSON 输出格式突然开始偶尔丢失字段，导致下游解析器崩溃。

传统的模型评测聚焦于"能力评估"——模型在基准测试上的分数。但生产环境更关心"一致性评估"——同一输入的输出是否稳定、格式是否可靠、边界情况是否可预测。一个在 MMLU 上得分 85% 但输出格式不稳定的大模型，在生产中可能比 MMLU 得分 80% 但输出高度稳定的模型更难用。构建自动化回归测试体系，是模型从"评测通过"到"生产就绪"的必经之路。

二、一致性评估的维度与方法论

2.1 一致性评估的四个维度

flowchart TD
    A[大模型输出一致性评估] --> B[格式一致性<br/>输出结构是否稳定]
    A --> C[语义一致性<br/>相同输入的输出含义是否相同]
    A --> D[行为一致性<br/>边界条件的处理方式是否稳定]
    A --> E[版本一致性<br/>模型升级后行为是否漂移]

    B --> B1["检测项：JSON Schema 合规率<br/>字段完整性、类型正确性"]
    C --> C1["检测项：语义等价率<br/>嵌入向量余弦相似度"]
    D --> D1["检测项：拒绝率、幻觉率<br/>边界输入的响应模式"]
    E --> E1["检测项：版本间差异率<br/>同一测试集的输出对比"]

    style B fill:#e1f5fe
    style C fill:#fff3e0
    style D fill:#e8f5e9
    style E fill:#ffebee

2.2 格式一致性：Schema 验证

大模型作为工具链的一环，输出格式必须严格遵循约定。JSON Schema 验证是最直接的检测手段：定义期望的输出 Schema，对每次输出进行结构验证。关键指标包括：

• 合规率：输出完全符合 Schema 的比例
• 字段缺失率：必需字段缺失的比例
• 类型错误率：字段值类型不匹配的比例

2.3 语义一致性：嵌入向量对比

格式一致性只能检测结构问题，无法判断内容是否语义等价。使用嵌入模型将输出编码为向量，计算同一输入多次输出的余弦相似度，可以量化语义一致性。

2.4 版本一致性：回归测试矩阵

每次模型版本升级时，在固定测试集上运行新旧两个版本，对比输出差异。差异率超过阈值时，触发人工审查。

三、生产级代码实现：自动化回归测试框架

3.1 测试用例定义与执行引擎

import json
import hashlib
from dataclasses import dataclass, field
from typing import Any, Optional
from enum import Enum

class ConsistencyDimension(Enum):
    FORMAT = "format"
    SEMANTIC = "semantic"
    BEHAVIOR = "behavior"
    VERSION = "version"

@dataclass
class TestCase:
    """回归测试用例"""
    id: str
    prompt: str
    category: str
    expected_schema: Optional[dict] = None
    expected_keywords: list[str] = field(default_factory=list)
    forbidden_keywords: list[str] = field(default_factory=list)
    temperature: float = 0.0
    max_tokens: int = 1024

@dataclass
class TestResult:
    """测试结果"""
    test_id: str
    output: str
    format_valid: bool = True
    format_errors: list[str] = field(default_factory=list)
    semantic_similarity: float = 1.0
    keyword_coverage: float = 1.0
    forbidden_violations: list[str] = field(default_factory=list)
    latency_ms: float = 0.0

class RegressionTestRunner:
    """回归测试执行引擎"""

    def __init__(
        self,
        llm_client,
        embed_model=None,
        num_runs: int = 3,  # 每个 case 重复运行次数
    ):
        self.llm_client = llm_client
        self.embed_model = embed_model
        self.num_runs = num_runs

    def run_test(self, test_case: TestCase) -> list[TestResult]:
        """执行单个测试用例（多次运行）"""
        results = []

        for _ in range(self.num_runs):
            import time
            start = time.time()

            output = self.llm_client.generate(
                prompt=test_case.prompt,
                temperature=test_case.temperature,
                max_tokens=test_case.max_tokens,
            )

            latency = (time.time() - start) * 1000

            result = TestResult(
                test_id=test_case.id,
                output=output,
                latency_ms=latency,
            )

            # 格式校验
            if test_case.expected_schema:
                result.format_valid, result.format_errors = (
                    self._validate_format(output, test_case.expected_schema)
                )

            # 关键词覆盖
            if test_case.expected_keywords:
                result.keyword_coverage = self._check_keywords(
                    output, test_case.expected_keywords
                )

            # 禁用词检测
            if test_case.forbidden_keywords:
                result.forbidden_violations = self._check_forbidden(
                    output, test_case.forbidden_keywords
                )

            results.append(result)

        # 语义一致性：多次运行之间的相似度
        if self.embed_model and len(results) > 1:
            similarities = self._compute_semantic_consistency(results)
            for result, sim in zip(results, similarities):
                result.semantic_similarity = sim

        return results

    def _validate_format(
        self, output: str, schema: dict
    ) -> tuple[bool, list[str]]:
        """JSON Schema 格式验证"""
        errors = []

        # 尝试解析 JSON
        try:
            data = json.loads(output)
        except json.JSONDecodeError as e:
            return False, [f"JSON 解析失败: {e}"]

        # Schema 验证
        try:
            import jsonschema
            jsonschema.validate(data, schema)
        except jsonschema.ValidationError as e:
            errors.append(f"Schema 验证失败: {e.message}")

        # 必需字段检查
        required = schema.get("required", [])
        for field_name in required:
            if field_name not in data:
                errors.append(f"缺少必需字段: {field_name}")

        return len(errors) == 0, errors

    def _check_keywords(self, output: str, keywords: list[str]) -> float:
        """关键词覆盖率"""
        output_lower = output.lower()
        covered = sum(1 for kw in keywords if kw.lower() in output_lower)
        return covered / len(keywords) if keywords else 1.0

    def _check_forbidden(self, output: str, forbidden: list[str]) -> list[str]:
        """禁用词检测"""
        output_lower = output.lower()
        return [kw for kw in forbidden if kw.lower() in output_lower]

    def _compute_semantic_consistency(
        self, results: list[TestResult]
    ) -> list[float]:
        """计算多次输出的语义一致性"""
        embeddings = [
            self.embed_model.encode(r.output) for r in results
        ]

        similarities = []
        for i, emb_i in enumerate(embeddings):
            # 与其他输出的平均相似度
            sims = []
            for j, emb_j in enumerate(embeddings):
                if i != j:
                    cos_sim = self._cosine_similarity(emb_i, emb_j)
                    sims.append(cos_sim)
            avg_sim = sum(sims) / len(sims) if sims else 1.0
            similarities.append(avg_sim)

        return similarities

    @staticmethod
    def _cosine_similarity(a, b) -> float:
        import numpy as np
        a, b = np.array(a), np.array(b)
        return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8))

3.2 版本回归对比器

@dataclass
class VersionDiff:
    """版本间差异"""
    test_id: str
    old_output: str
    new_output: str
    format_changed: bool
    semantic_similarity: float
    category: str

class VersionRegressor:
    """版本回归对比器"""

    def __init__(
        self,
        runner: RegressionTestRunner,
        similarity_threshold: float = 0.85,
        format_change_threshold: float = 0.05,
    ):
        self.runner = runner
        self.similarity_threshold = similarity_threshold
        self.format_change_threshold = format_change_threshold

    def compare_versions(
        self,
        test_cases: list[TestCase],
        old_version: str,
        new_version: str,
    ) -> dict:
        """对比两个模型版本在测试集上的差异"""

        diffs = []
        format_regression_count = 0
        semantic_regression_count = 0

        for case in test_cases:
            # 旧版本输出
            old_results = self.runner.run_test(case)
            old_output = old_results[0].output

            # 新版本输出
            new_results = self.runner.run_test(case)
            new_output = new_results[0].output

            # 格式变化检测
            format_changed = (
                old_results[0].format_valid and not new_results[0].format_valid
            )

            # 语义相似度
            if self.runner.embed_model:
                old_emb = self.runner.embed_model.encode(old_output)
                new_emb = self.runner.embed_model.encode(new_output)
                sim = RegressionTestRunner._cosine_similarity(old_emb, new_emb)
            else:
                sim = 1.0

            diff = VersionDiff(
                test_id=case.id,
                old_output=old_output,
                new_output=new_output,
                format_changed=format_changed,
                semantic_similarity=sim,
                category=case.category,
            )
            diffs.append(diff)

            if format_changed:
                format_regression_count += 1
            if sim < self.similarity_threshold:
                semantic_regression_count += 1

        total = len(test_cases)
        return {
            "total_cases": total,
            "format_regressions": format_regression_count,
            "format_regression_rate": format_regression_count / total,
            "semantic_regressions": semantic_regression_count,
            "semantic_regression_rate": semantic_regression_count / total,
            "details": diffs,
        }

3.3 CI 集成：自动化回归门禁

def regression_gate(report: dict, strict: bool = False) -> bool:
    """回归测试门禁：决定是否允许模型版本上线

    Args:
        report: VersionRegressor.compare_versions 的输出
        strict: 严格模式，任何回归都阻止上线
    """
    if strict:
        return (
            report["format_regressions"] == 0
            and report["semantic_regressions"] == 0
        )

    # 宽松模式：允许少量回归
    format_rate = report["format_regression_rate"]
    semantic_rate = report["semantic_regression_rate"]

    if format_rate > 0.05:
        print(f"格式回归率过高: {format_rate:.2%} > 5%")
        return False

    if semantic_rate > 0.10:
        print(f"语义回归率过高: {semantic_rate:.2%} > 10%")
        return False

    return True

四、一致性评估的工程权衡

4.1 测试用例的覆盖度与维护成本

测试用例数量越多，回归检测越全面，但维护成本也越高。每次业务逻辑变更都需要同步更新测试用例。建议策略：核心场景（支付、权限、数据输出）100% 覆盖，边缘场景按优先级逐步补充。

4.2 语义相似度的阈值设定

余弦相似度阈值过低（如 0.7）会漏检语义漂移，过高（如 0.95）会产生大量误报。不同任务类型需要不同阈值：结构化输出任务（JSON）阈值应设为 0.95+，开放式生成任务阈值可放宽到 0.80。

4.3 评测成本与频率

完整回归测试可能需要数百次 LLM 调用，成本不可忽视。建议策略：每次版本升级运行完整测试集；日常开发中只运行冒烟测试子集（10-20 个核心用例）。

五、总结

大模型输出一致性评估是生产部署的必要环节，其重要性不亚于能力评测。四个评估维度各有侧重：格式一致性保障下游解析可靠，语义一致性确保输出含义稳定，行为一致性控制边界条件响应，版本一致性防止升级漂移。关键实践：将回归测试集成到 CI/CD 流水线，设定合理的通过阈值，在模型版本上线前自动执行一致性门禁检查。一致性不是"锦上添花"，而是"生产底线"。