推理模型评估：基准与自定义测试

为什么评估对推理模型尤为重要

推理模型的"推理 Token"是黑箱——模型声称"思考了很多"，但思考过程可能包含大量无效探索，甚至绕圈子。没有系统的评估，你无法判断：增加 budget_tokens 是否真的提升了质量？模型 A 是否真的比模型 B 更适合你的业务？推理模型的高额成本是否带来了相应的价值回报？

主流推理基准解读

pass@k 采样策略详解

对于有确定性答案的任务（数学、代码），pass@k 是标准的采样评估策略，它测量"在 k 次机会内至少答对一次"的概率：

import numpy as np
from typing import List, Callable

def estimate_pass_at_k(n: int, c: int, k: int) -> float:
    """
    无偏估计 pass@k
    n: 总采样次数（推荐 10-20）
    c: 正确答案的数量（0 ≤ c ≤ n）
    k: 给定的机会数（pass@1 = 直接正确率, pass@10 = 10次中至少一次正确）
    原理：1 - P(全部失败) = 1 - C(n-c, k) / C(n, k)
    """
    if n - c < k:
        return 1.0  # 正确数量足够，必然 pass
    return 1.0 - np.prod(
        1.0 - k / np.arange(n - c + 1, n + 1)
    )

# 实际意义：
print(f"10次采样中4次正确 → pass@1: {estimate_pass_at_k(10, 4, 1):.1%}")  # 40%
print(f"10次采样中4次正确 → pass@3: {estimate_pass_at_k(10, 4, 3):.1%}")  # ~73%
print(f"10次采样中4次正确 → pass@5: {estimate_pass_at_k(10, 4, 5):.1%}")  # ~87%

def evaluate_with_pass_at_k(
    problems: List[dict],
    model_fn: Callable,
    n_samples: int = 10,
    k_values: List[int] = [1, 3, 10]
) -> dict:
    """对问题集进行 pass@k 评估"""
    all_results = {k: [] for k in k_values}

    for problem in problems:
        # 采样 n 个输出
        outputs = [model_fn(problem["question"]) for _ in range(n_samples)]

        # 统计正确数量
        correct_count = sum(
            verify_answer(problem["correct_answer"], output)
            for output in outputs
        )

        # 计算每个 k 的 pass 概率
        for k in k_values:
            score = estimate_pass_at_k(n_samples, correct_count, k)
            all_results[k].append(score)

    # 返回平均 pass@k
    return {
        f"pass@{k}": np.mean(scores)
        for k, scores in all_results.items()
    }

# 不同 k 值的业务含义：
# pass@1：用户一次查询的准确率（直接部署场景）
# pass@3：用户选择最好的3个答案之一的准确率（多选场景）
# pass@10：验证模型"是否能解决这类问题"（研究场景）

LLM-as-Judge：评估开放性推理回答

数学和代码可以自动验证，但开放性推理任务（策略分析、科学解释、法律推导）需要 LLM 作为评判者：

from pydantic import BaseModel

class JudgmentResult(BaseModel):
    score: int               # 1-10 总分
    accuracy: int            # 准确性 1-10
    completeness: int        # 完整性 1-10
    reasoning_quality: int  # 推理质量 1-10（推理模型特有）
    reason: str              # 评分理由（50字以内）

JUDGE_SYSTEM = """你是一个严格、客观的 AI 回答评估者。
评估维度：
1. accuracy（准确性）：核心信息是否正确
2. completeness（完整性）：是否覆盖了所有必要方面
3. reasoning_quality（推理质量）：推理过程是否严谨、有逻辑
4. score（总分）：综合评估

评分标准：
1-3：严重错误或缺失  4-5：部分正确  6-7：基本正确
8-9：优秀  10：完美

只输出 JSON，不要其他内容。"""

def llm_judge_reasoning(
    question: str,
    reference_answer: str,
    model_answer: str,
    judge_model: str = "claude-opus-4-6"  # 用更强的模型作为评判者
) -> JudgmentResult:
    response = client.messages.create(
        model=judge_model,
        max_tokens=512,
        system=JUDGE_SYSTEM,
        messages=[{"role": "user", "content": f"""
问题：{question}

参考答案（标准答案）：{reference_answer}

被评估的答案：{model_answer}

请按上述标准评估被评估答案的质量："""}]
    )
    return JudgmentResult.model_validate_json(response.content[0].text)

# 批量评估并生成报告
def batch_reasoning_evaluation(
    test_cases: list,
    model_fn: Callable
) -> dict:
    judgments = []
    for case in test_cases:
        answer = model_fn(case["question"])
        judgment = llm_judge_reasoning(
            case["question"],
            case["reference"],
            answer
        )
        judgments.append(judgment)

    # 计算各维度均值
    n = len(judgments)
    return {
        "n_samples": n,
        "avg_score": sum(j.score for j in judgments) / n,
        "avg_accuracy": sum(j.accuracy for j in judgments) / n,
        "avg_completeness": sum(j.completeness for j in judgments) / n,
        "avg_reasoning_quality": sum(j.reasoning_quality for j in judgments) / n,
    }

构建业务自定义评估集

公开基准衡量通用能力，但只有业务自定义评估集才能告诉你：模型在你的实际场景中表现如何。

import json
from pathlib import Path
from dataclasses import dataclass
from datetime import datetime

@dataclass
class EvalCase:
    """单个评估用例"""
    id: str
    question: str
    reference_answer: str
    difficulty: str         # easy / medium / hard
    category: str           # 业务分类（如 math / code / analysis）
    eval_method: str        # exact_match / llm_judge / unit_test
    tags: list[str]         # 标签（如 regression、edge_case）

class EvalSuite:
    """业务评估套件"""

    def __init__(self, path: str):
        self.path = Path(path)
        self.cases: list[EvalCase] = self.load()

    def run(self, model_fn: Callable, tag_filter: str = None) -> dict:
        """运行评估，返回各维度分数"""
        cases = self.cases
        if tag_filter:
            cases = [c for c in cases if tag_filter in c.tags]

        results = []
        for case in cases:
            answer = model_fn(case.question)

            if case.eval_method == "exact_match":
                score = 1.0 if case.reference_answer.strip() == answer.strip() else 0.0
            elif case.eval_method == "llm_judge":
                judgment = llm_judge_reasoning(case.question, case.reference_answer, answer)
                score = judgment.score / 10.0
            elif case.eval_method == "unit_test":
                score = run_unit_tests(answer, case.reference_answer)

            results.append({
                "case_id": case.id,
                "difficulty": case.difficulty,
                "score": score
            })

        # 按难度和总体统计分数
        return {
            "total": sum(r["score"] for r in results) / len(results),
            "by_difficulty": {
                d: np.mean([r["score"] for r in results if r["difficulty"] == d])
                for d in ["easy", "medium", "hard"]
            },
            "timestamp": datetime.now().isoformat()
        }