大模型能力评估与评测体系：科学衡量 AI 智能

前言

随着大语言模型（LLM）如雨后春笋般涌现，如何科学、客观地评估模型能力成为重要课题。一个清晰的评测体系不仅能帮助我们选择合适的模型，还能指导模型优化方向。

我最近在项目中对比了多个模型的效果，对评测方法有了更深的理解。今天分享一些主流的评测方法和实践经验。

评测维度

基础能力

1. 语言理解：阅读理解、意图识别、情感分析
2. 语言生成：文本生成、对话能力、创意写作
3. 知识储备：事实性知识、专业领域知识
4. 推理能力：逻辑推理、数学推理、代码推理

进阶能力

1. 上下文学习：从示例中学习新任务
2. 长程依赖：处理长文本、长对话
3. 多语言能力：中英翻译、跨语言理解
4. 安全对齐：有害内容过滤、偏见检测

主流评测基准

MTEB：多任务文本嵌入基准

MTEB（Massive Text Embedding Benchmark）是评估 Embedding 模型的标准基准：

from mteb import MTEB
from sentence_transformers import SentenceTransformer

# 加载模型
model = SentenceTransformer('BAAI/bge-large-zh')

# 评估任务列表
evaluation = MTEB(
    task_names=[
        "STS22",        # 语义相似度
        "MSMARCO",      # 检索
        "NFCoram",      # 分类
    ]
)

# 运行评估
results = evaluation.run(
    model,
    output_folder=f"./results/{model_name}"
)

print(results)

HELM：语言模型全景评估

HELM（Holistic Evaluation of Language Models）提供全面评估：

from helms.run import run_model

# 运行 HELM 评估
results = run_model(
    model_name="huggingface/mistral-7b",
    benchmark="full",
    num_trials=3
)

# 查看各项指标
for scenario, metrics in results.items():
    print(f"\n{scenario}:")
    for metric_name, value in metrics.items():
        print(f"  {metric_name}: {value:.4f}")

大模型专用评测

class LLMEvaluator:
    """LLM 评测器"""
    
    def __init__(self, model):
        self.model = model
    
    def evaluate(self, dataset: str) -> dict:
        """运行全面评估"""
        if dataset == "mmlu":
            return self._evaluate_mmlu()
        elif dataset == "humaneval":
            return self._evaluate_humaneval()
        elif dataset == "gsm8k":
            return self._evaluate_gsm8k()
    
    def _evaluate_mmlu(self) -> dict:
        """MMLU 多任务语言理解"""
        from datasets import load_dataset
        
        mmlu = load_dataset("cais/mmlu", "all", split="test")
        
        correct = 0
        total = 0
        
        for item in mmlu:
            prompt = self._build_mmlu_prompt(item)
            response = self.model.chat(prompt)
            answer = self._extract_answer(response)
            
            if answer == item["answer"]:
                correct += 1
            total += 1
        
        return {
            "accuracy": correct / total,
            "correct": correct,
            "total": total
        }
    
    def _evaluate_humaneval(self) -> dict:
        """HumanEval 代码生成"""
        from datasets import load_dataset
        
        humaneval = load_dataset("openai/openai_humaneval", split="test")
        
        correct = 0
        total = 0
        
        for item in humaneval:
            prompt = f"Complete the following Python function:\n\n{item['prompt']}"
            response = self.model.chat(prompt)
            code = self._extract_code(response)
            
            if self._verify_code(item["prompt"], code, item["test"]):
                correct += 1
            total += 1
        
        return {
            "pass_at_1": correct / total,
            "correct": correct,
            "total": total
        }

常用评测数据集

英文评测集

数据集	任务	说明
MMLU	多选问答	57 个学科领域
GSM8K	数学推理	8K 小学数学题
HumanEval	代码生成	Python 代码补全
BIG-Bench	多任务	200+ 推理任务
TruthfulQA	真实性	问答真实性

中文评测集

数据集	任务	说明
C-Eval	多选问答	52 个中文领域
CMMLU	多选问答	67 个中文领域
GAOKAO	高考题	中国高考真题
CMRC	阅读理解	中文阅读理解
XLSAT	数学推理	中文数学题

评测实践

构建评测 pipeline

from dataclasses import dataclass
from typing import List, Callable
import json

@dataclass
class EvalResult:
    """评测结果"""
    task_name: str
    metric_name: str
    value: float
    confidence: float = None

class EvalPipeline:
    """评测流水线"""
    
    def __init__(self, model, tasks: List[dict]):
        self.model = model
        self.tasks = tasks
        self.results = []
    
    def run(self) -> List[EvalResult]:
        """运行所有评测任务"""
        for task in self.tasks:
            print(f"Running {task['name']}...")
            
            try:
                result = self._run_task(task)
                self.results.extend(result)
            except Exception as e:
                print(f"Error in {task['name']}: {e}")
        
        return self.results
    
    def _run_task(self, task: dict) -> List[EvalResult]:
        """运行单个任务"""
        if task["type"] == "multiple_choice":
            return self._eval_multiple_choice(task)
        elif task["type"] == "generation":
            return self._eval_generation(task)
        elif task["type"] == "retrieval":
            return self._eval_retrieval(task)
    
    def _eval_multiple_choice(self, task: dict) -> List[EvalResult]:
        """选择题评测"""
        dataset = self._load_dataset(task["dataset"])
        
        correct = 0
        total = len(dataset)
        
        for item in dataset:
            prompt = self._format_prompt(task["prompt_template"], item)
            response = self.model.chat(prompt)
            answer = self._extract_choice(response)
            
            if answer == item["answer"]:
                correct += 1
        
        return [EvalResult(
            task_name=task["name"],
            metric_name="accuracy",
            value=correct / total
        )]
    
    def _eval_generation(self, task: dict) -> List[EvalResult]:
        """生成任务评测"""
        # 复杂评测，需要考虑 BLEU、ROUGE 等指标
        pass
    
    def _format_prompt(self, template: str, item: dict) -> str:
        """格式化 prompt"""
        return template.format(**item)
    
    def _extract_choice(self, response: str) -> str:
        """提取选项"""
        # 简单实现：查找 A/B/C/D
        for choice in ["A", "B", "C", "D"]:
            if choice in response.upper():
                return choice
        return None

对比评测

class ModelComparison:
    """模型对比"""
    
    def __init__(self, datasets: dict):
        self.datasets = datasets
    
    def compare(
        self, 
        models: List[tuple],  # [(name, model), ...]
        tasks: List[str]
    ) -> pd.DataFrame:
        """对比多个模型"""
        results = []
        
        for model_name, model in models:
            print(f"\nEvaluating {model_name}...")
            
            for task in tasks:
                evaluator = LLMEvaluator(model)
                task_results = evaluator.evaluate(task)
                
                for result in task_results:
                    results.append({
                        "model": model_name,
                        "task": result.task_name,
                        "metric": result.metric_name,
                        "value": result.value
                    })
        
        return pd.DataFrame(results)
    
    def visualize(self, results: pd.DataFrame):
        """可视化结果"""
        import matplotlib.pyplot as plt
        
        # 创建对比表
        pivot = results.pivot_table(
            index="model",
            columns="task",
            values="value"
        )
        
        # 热力图
        plt.figure(figsize=(12, 8))
        plt.imshow(pivot.values, cmap='RdYlGn', aspect='auto')
        plt.colorbar(label='Score')
        plt.xticks(range(len(pivot.columns)), pivot.columns, rotation=45)
        plt.yticks(range(len(pivot.index)), pivot.index)
        plt.title('Model Comparison')
        plt.tight_layout()
        plt.savefig('comparison.png')

评测中的常见问题

1. 评估指标选择

# 不同任务适合不同指标
class MetricSelector:
    """指标选择器"""
    
    TASK_METRICS = {
        "classification": ["accuracy", "f1", "precision", "recall"],
        "generation": ["bleu", "rouge", "bert_score"],
        "retrieval": ["ndcg", "mrr", "recall@k"],
        "code_generation": ["pass@k", "compilation_rate"],
    }
    
    @classmethod
    def get_metrics(cls, task_type: str) -> List[str]:
        return cls.TASK_METRICS.get(task_type, [])

2. 评测稳定性

class StableEvaluator:
    """稳定评测（多次运行取平均）"""
    
    def __init__(self, model, num_trials: int = 5):
        self.model = model
        self.num_trials = num_trials
    
    def evaluate(self, task) -> dict:
        """多次评测取平均"""
        scores = []
        
        for _ in range(self.num_trials):
            score = self._single_eval(task)
            scores.append(score)
        
        import numpy as np
        return {
            "mean": np.mean(scores),
            "std": np.std(scores),
            "ci_95": 1.96 * np.std(scores) / np.sqrt(self.num_trials)
        }

3. 提示敏感性

class PromptRobustnessEval:
    """Prompt 鲁棒性评测"""
    
    def __init__(self, model):
        self.model = model
    
    def evaluate(self, task, prompts: List[str]) -> dict:
        """测试不同 prompt 的表现"""
        results = []
        
        for prompt in prompts:
            score = self._evaluate_with_prompt(task, prompt)
            results.append(score)
        
        return {
            "mean": np.mean(results),
            "std": np.std(results),
            "min": np.min(results),
            "max": np.max(results)
        }

总结

大模型评测需要：

1. 多维度：不能只看单一指标，要综合评估
2. 多数据集：不同数据集反映不同能力
3. 可复现：评测方法和条件要明确
4. 持续跟踪：模型在迭代，要持续评测

关键要点：

• MTEB 是 Embedding 评测的标准
• 大模型用 MMLU、HumanEval、GSM8K 等
• 多次运行取平均保证稳定性
• 对比评测要控制变量

希望这些评测方法和经验对大家有帮助。