EvalScope大模型评测新手指南

FunTester

438人浏览 · 2026-07-04 13:45:51

FunTester · 2026-07-04 13:45:51 发布

📋 目录

EvalScope 简介
官方链接
安装部署
支持的数据集大全
数据集获取与配置（在线 vs 本地）
数据集：是否需要裁判？
评测模型配置：model/api-url/api-key 使用场景
快速判断表
评测模型配置指南
常用评测任务实战
高级功能与技巧
查看评测结果
常见问题与解决方案
最佳实践与优化建议

1. EvalScope 简介

EvalScope 是由**魔搭社区（ModelScope）**打造的一站式大模型评测框架，提供：

┌────────────────────────────────────────────────────────┐
│              EvalScope 核心功能                        │
├────────────────────────────────────────────────────────┤
│  📊 模型能力评测                                     │
│     用标准数据集评估模型推理、数学、代码等能力        │
│                                                       │
│  ⚡ 推理性能压测                                     │
│     测试模型服务的吞吐量、延迟、QPS                   │
│                                                       │
│  📈 结果可视化                                       │
│     Web界面展示评测报告，支持多模型对比              │
└────────────────────────────────────────────────────────┘

🎯 核心价值

✅ 统一评测接口 → 告别重复造轮子
✅ 丰富的基准数据集 → 覆盖主流评测需求
✅ 自动化评测流程 → 一键启动，坐等结果
✅ 多维度的评估报告 → 可视化 + 量化指标
✅ 支持本地 + API 模型 → 灵活适配各种场景

2. 官方链接

类型	链接
📖 中文文档	https://evalscope.readthedocs.io/zh-cn/latest/
🌐 ModelScope 文档	https://www.modelscope.cn/docs/model-evaluation/
🐙 GitHub 仓库	https://github.com/modelscope/evalscope
📦 PyPI 包	`pip install evalscope`

3. 安装部署

🍎 macOS 安装

# 1. 确认 Python 版本（需要 3.9+）
python3 --version

# 2. 基础安装（CPU 推理，或调用 API 评测）
pip3 install evalscope

# 3. 如需本地 GPU 推理（Mac Apple Silicon 无 CUDA，用 MLX 加速）
# ⚠️ Mac 不支持 CUDA，本地推理建议用 openai_api 方式调用云端模型
# 或安装 vLLM（仅 Linux/Windows 支持）
pip3 install 'evalscope[service]'   # 含可视化服务

# 4. 验证安装
evalscope --version

⚠️ Mac 用户注意：

Mac 无法用 CUDA 加速本地推理
建议用 --eval-type openai_api 方式评测（见第7章）

🪟 Windows 安装

# 1. 安装 Python 3.9+（从 python.org 下载）

# 2. 创建虚拟环境（推荐）
python -m venv evalscope-env
evalscope-env\Scripts\activate

# 3. 基础安装
pip install evalscope

# 4. 如需本地 GPU 推理（需要 NVIDIA 显卡 + CUDA 12.x）
# 先安装 PyTorch（GPU 版）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
# 再安装 evalscope
pip install evalscope

# 5. 含可视化服务
pip install "evalscope[service]"

# 6. 验证
evalscope --version

⚠️ Windows 用户注意：

本地 GPU 推理需要 CUDA
若无显卡统一用 openai_api 方式

🤔 大白话解释：什么场景需要本地GPU推理？

💡 什么是"本地GPU推理"？

大白话：

本地推理 = 模型跑在你自己的电脑/服务器上
GPU推理 = 用显卡（NVIDIA）加速模型运行
对比：调用API = 模型跑在别人的服务器上（如OpenAI），你只是发送请求

📊 场景对比表

场景	需要什么？	适合谁？	优点	缺点
本地GPU推理	NVIDIA显卡 + CUDA	有显卡的台式机/服务器	数据不泄露、无API费用	需要买显卡、配置复杂
调用API	能上网就行	个人电脑/无显卡环境	配置简单、无需显卡	API费用、数据发到外网
CPU推理	啥显卡都不需要	笔记本/老机器	啥电脑都能跑	速度巨慢（可能10分钟跑1个样本）

✅ 需要本地GPU推理的场景

┌─────────────────────────────────────────────────┐
│          需要本地GPU推理的场景                   │
├─────────────────────────────────────────────────┤
│ 1. 数据保密要求高                           │
│    → 公司数据不能发到外网                    │
│    → 必须在本机/内网服务器跑                │
│                                              │
│ 2. 评测量大，API费用太高                   │
│    → 要跑10万条数据                         │
│    → 用API可能花几千块                     │
│    → 本地跑啥钱都不花                      │
│                                              │
│ 3. 需要修改模型/深度定制                  │
│    → 要测试不同温度参数/采样策略            │
│    → API接口可能不支持                      │
│                                              │
│ 4. 公司有自己的GPU服务器                  │
│    → 反正显卡闲着也是闲着                  │
│    → 不如拿来跑评测                        │
└─────────────────────────────────────────────────┘

❌ 不需要本地GPU推理的场景（用API就行）

┌─────────────────────────────────────────────────┐
│       不需要本地GPU推理（用API就行）            │
├─────────────────────────────────────────────────┤
│ 1. 个人学习/快速验证                       │
│    → 只想跑10个样本看看效果                │
│    → 用API几秒钟就出结果                  │
│                                              │
│ 2. 没有NVIDIA显卡                        │
│    → Mac电脑（Apple Silicon）               │
│    → 普通办公笔记本                       │
│    → 用API最省事                          │
│                                              │
│ 3. 数据不敏感                             │
│    → 用公开数据集评测                     │
│    → 不怕发送到外网                        │
│                                              │
│ 4. 公司提供内部API服务                   │
│    → 有内网API可以调用                    │
│    → 不需要自己部署模型                    │
└─────────────────────────────────────────────────┘

🔍 如何判断本地有没有NVIDIA显卡 + CUDA？

🪟 Windows用户：3步判断

第1步：确认有没有NVIDIA显卡

方法1：设备管理器查看

1. 右键"此电脑" → 管理 → 设备管理器
2. 展开"显示适配器"
3. 看有没有 NVIDIA xxx（如 NVIDIA GeForce RTX 4090）
   → 有 = 有NVIDIA显卡 ✅
   → 没有 或 只有 Intel/AMD = 无NVIDIA显卡 ❌

方法2：命令行查看

# 打开 CMD/PowerShell，运行：
nvidia-smi

# 输出示例（有显卡）：
# Sat Jul  4 11:20:00 2026
# +-----------------------------------------------------------------------------+
# | NVIDIA-SMI 535.129.03   Driver Version: 535.129.03   CUDA Version: 12.2  |
# |-------------------------------+----------------------+----------------------+
# | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
# | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
# |                               |                      |               MIG M. |
# |===============================+======================+======================|
# |   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0  On |                  N/A |
# |  0%   45C    P8    10W / 450W |    256MiB / 24564MiB |      0%      Default |
# +-------------------------------+----------------------+----------------------+

# 如果输出"command not found"或"不是内部命令"
# → 没有NVIDIA显卡 或 没装驱动 ❌

第2步：确认CUDA版本

# 接上面命令，看"CUDA Version: 12.x"
# 如果是 12.1 / 12.2 / 12.4 → 满足要求 ✅
# 如果是 11.x → 需要升级到 12.x
# 如果没显示 → 需要安装 CUDA Toolkit

如何安装/升级CUDA？

1. 访问 NVIDIA CUDA 下载页：
   https://developer.nvidia.com/cuda-downloads

2. 选择你的系统（Windows/x86_64）
3. 下载安装包（约 3GB）
4. 双击安装，一路"下一步"
5. 安装完后重启电脑
6. 再次运行 nvidia-smi 确认版本

第3步：确认PyTorch能识别显卡

# 运行 Python，测试 PyTorch 是否能用 CUDA
python -c "import torch; print(torch.cuda.is_available())"

# 输出：
# True  → CUDA 配置正确 ✅
# False → CUDA 配置有问题 ❌

🍎 Mac用户：直接放弃本地GPU推理

大白话：

Mac电脑（无论是 Intel 还是 Apple Silicon M1/M2/M3）
都没有 NVIDIA 显卡
都不支持 CUDA
无法做本地GPU推理

Mac用户的选项：

选项1：用 openai_api 方式（推荐）
   → 调用云端模型（GPT/Claude/Qwen等）
   → 啥配置都不需要

选项2：用 CPU 推理（不推荐）
   → 速度极慢，评测可能要跑几天
   → 只适合跑几个样本验证

选项3：远程连接到有GPU的服务器
   → ssh 连接到公司/学校的 GPU 服务器
   → 在服务器上跑评测

🐧 Linux用户：和Windows类似

# 1. 查看显卡
nvidia-smi

# 2. 查看 CUDA 版本
nvcc --version
# 或
cat /usr/local/cuda/version.txt

# 3. 测试 PyTorch
python -c "import torch; print(torch.cuda.is_available())"

📋 快速判断流程图

┌─────────────────────────────────────────┐
│  我的电脑能跑本地GPU推理吗？           │
└─────────────────────────────────────────┘
                    ↓
         ┌──────────────────┐
         │  是 Windows/Linux？ │
         └──────────────────┘
            ↓ 是          ↓ 否（Mac）
        有NVIDIA显卡？    直接用API方式
            ↓              
    有CUDA 12.x？        
            ↓              
PyTorch能识别cuda？     
            ↓              
         ✅ 可以本地GPU推理

🔧 一键判断脚本（Windows/Mac/Linux通用）

保存为 check_gpu.py：

import sys

def check_gpu():
    print("=" * 60)
    print("🔍 EvalScope 环境检测工具")
    print("=" * 60)
    
    # 1. 检查操作系统
    import platform
    os_name = platform.system()
    print(f"\n📊 操作系统：{os_name}")
    
    if os_name == "Darwin":
        print("   ⚠️ Mac 系统，不支持 CUDA 本地GPU推理")
        print("   ✅ 推荐用 --eval-type openai_api 方式")
        return
    
    # 2. 检查 Python 版本
    py_version = sys.version_info
    print(f"\n🐍 Python 版本：{py_version.major}.{py_version.minor}.{py_version.micro}")
    if py_version.major < 3 or (py_version.major == 3 and py_version.minor < 9):
        print("   ❌ Python 版本太低，需要 3.9+")
        return
    else:
        print("   ✅ Python 版本满足要求")
    
    # 3. 检查 NVIDIA 显卡（仅 Windows/Linux）
    try:
        import subprocess
        result = subprocess.run(['nvidia-smi'], capture_output=True, text=True, timeout=5)
        if result.returncode == 0:
            print("\n🎮 NVIDIA 显卡：✅ 检测到")
            # 提取 CUDA 版本
            for line in result.stdout.split('\n'):
                if 'CUDA Version' in line:
                    cuda_version = line.split('CUDA Version:')[1].strip().split()[0]
                    print(f"   CUDA 版本：{cuda_version}")
                    if cuda_version.startswith('12'):
                        print("   ✅ CUDA 版本满足要求（12.x）")
                    else:
                        print("   ⚠️ 建议升级到 CUDA 12.x")
                    break
        else:
            print("\n🎮 NVIDIA 显卡：❌ 未检测到")
            print("   ✅ 推荐用 --eval-type openai_api 方式")
    except:
        print("\n🎮 NVIDIA 显卡：❌ 未检测到（或驱动未安装）")
        print("   ✅ 推荐用 --eval-type openai_api 方式")
    
    # 4. 检查 PyTorch 是否支持 CUDA
    try:
        import torch
        print(f"\n🔥 PyTorch 版本：{torch.__version__}")
        if torch.cuda.is_available():
            print("   ✅ PyTorch 可以使用 CUDA")
            print(f"   显卡数量：{torch.cuda.device_count()}")
            print(f"   当前显卡：{torch.cuda.get_device_name(0)}")
        else:
            print("   ❌ PyTorch 无法使用 CUDA")
            print("   ⚠️ 需要重新安装 PyTorch（GPU版）")
    except ImportError:
        print("\n🔥 PyTorch：❌ 未安装")
        print("   ⚠️ 需要先安装：pip install torch")
    
    print("\n" + "=" * 60)
    print("💡 结论：")
    if os_name != "Darwin":
        try:
            import torch
            if torch.cuda.is_available():
                print("   ✅ 你的环境支持本地GPU推理")
                print("   ✅ 可以跑：--eval-type local")
            else:
                print("   ⚠️ 你的环境不支持本地GPU推理")
                print("   ✅ 推荐用：--eval-type openai_api")
        except:
            print("   ⚠️ 无法判断，请先安装 PyTorch")
    else:
        print("   ⚠️ Mac 系统不支持本地GPU推理")
        print("   ✅ 推荐用：--eval-type openai_api")
    print("=" * 60)

if __name__ == "__main__":
    check_gpu()

使用方法：

# 1. 保存上面的代码为 check_gpu.py

# 2. 运行
python check_gpu.py

# 3. 查看输出，按照提示操作

💡 总结：你应该用哪种方式？

你的环境	推荐方式	原因
Windows + NVIDIA显卡	本地GPU推理	速度最快，费用最低
Windows + 无NVIDIA显卡	openai_api	配置简单，无需显卡
Mac（任何型号）	openai_api	Mac不支持CUDA
Linux服务器 + NVIDIA显卡	本地GPU推理	服务器标配
Linux服务器 + 无NVIDIA显卡	openai_api	只能调用API
公司内网 + 有GPU服务器	本地GPU推理	数据不泄露
公司内网 + 无GPU	内部API服务	用公司内部模型

4. 支持的数据集大全

EvalScope 支持 100+ 主流中英文评测数据集，覆盖知识、推理、数学、代码等多个维度。

📚 数据集分类速查表

🇨🇳 中文数据集

数据集	任务类型	样本量	适用模型	核心能力
CMMLU	知识问答	11.5K	中文模型	综合中文知识
C-Eval	知识问答	13.9K	中文模型	学科知识
MMLU-CN	知识问答	14K	中英模型	中英对照知识
GAOKAO	复杂推理	2.8K	强推理模型	高考题目
AGIEval	综合考试	8K	强推理模型	国家考试题
C3	阅读理解	13.5K	理解模型	中文阅读理解

🌍 英文数据集

数据集	任务类型	样本量	适用模型	核心能力
MMLU	知识问答	15.9K	英文模型	综合英文知识
GSM8K	数学推理	8.8K	推理模型	小学数学中的数学
HumanEval	代码生成	164	代码模型	Python 函数生成
BIG-Bench	综合推理	204+	强推理模型	多样化推理任务
TruthfulQA	真实性	817	对话模型	抗幻觉能力
HellaSwag	常识推理	70K	理解模型	常识推理

💻 代码与数学专项

数据集	任务类型	样本量	亮点
HumanEval	代码生成	164	标准代码评测基准
MBPP	代码生成	974	入门级 Python 编程
MATH	数学竞赛	12.5K	高中数学竞赛题
GSM8K	数学推理	8.8K	小学数学中的多步推理
CodeContests	算法竞赛	13K	竞技编程题目

🛠️ 数据集使用技巧

# 技巧1：指定数据集的子集（减少评测时间）
datasets=['cmmlu'],
dataset_args={'cmmlu': {'subset': 'law'}},  # 只评测法律子集

# 技巧2：限制样本数量（快速验证）
dataset_args={'cmmlu': {'num_samples': 100}},  # 只评测100个样本

# 技巧3：多数据集联合评测
datasets=['cmmlu', 'mmlu', 'gsm8k'],  # 一次性评测多个数据集

5. 数据集获取与配置（在线 vs 本地）

📥 核心结论：默认在线，特殊情况本地下载

┌──────────────────────────────────────────────────────────┐
│                  数据集加载策略                           │
├──────────────────────────────────────────────────────────┤
│  🌐 默认：在线自动下载                                 │
│     → 评测时 evalscope 自动从 ModelScope/HuggingFace   │
│       下载数据集                                         │
│     → 首次下载后自动缓存到本地                          │
│     → 下次跑同一个数据集不再重新下载                     │
│                                                         │
│  💾 必须本地下载的场景：                               │
│     1. 内网环境，机器无法访问 ModelScope/HuggingFace   │
│     2. 数据集较大，想提前下载避免评测时等待            │
│     3. 需要修改数据集内容（自定义答案）                │
└──────────────────────────────────────────────────────────┘

📦 数据集来源（Git 地址说明）

⚠️ 重要：EvalScope 本身不存储数据集，数据集托管在 ModelScope 或 HuggingFace。

平台	地址格式	示例
ModelScope	`https://modelscope.cn/datasets/{dataset_id}`	https://modelscope.cn/datasets/modelscope/gsm8k
HuggingFace	`https://huggingface.co/datasets/{dataset_id}`	https://huggingface.co/datasets/echo840/OCRBench
EvalScope GitHub	`https://github.com/modelscope/evalscope`	只有框架代码，不含数据集

⚠️ 关键认知：

没有单独的"数据集 Git 地址"
数据集是通过 modelscope download 或 huggingface 自带的 datasets 库自动拉取的
不是 git clone

🛠️ 手动下载到本地（内网环境必备）

方式一：从 ModelScope 下载

# 下载到本地目录
modelscope download \
  --dataset modelscope/gsm8k \
  --local_dir ./data/gsm8k

方式二：从 HuggingFace 下载

# 下载到本地目录
huggingface-cli download \
  echo840/OCRBench \
  --local-dir ./data/ocr_bench

下载后如何指定本地路径评测？

evalscope eval \
  --model xxx \
  --datasets gsm8k \
  --dataset-args '{"gsm8k": {"local_path": "./data/gsm8k"}}'

Python API 方式：

from evalscope.config import TaskConfig

task_config = TaskConfig(
    model='your-model',
    datasets=['gsm8k'],
    dataset_args={
        'gsm8k': {'local_path': './data/gsm8k'}
    },
    work_dir='outputs/gsm8k_eval',
)

📊 常用数据集下载地址汇总

数据集	ModelScope ID	HuggingFace ID	大小	是否必须本地下载
gsm8k	`modelscope/gsm8k`	`gsm8k`	~10MB	❌ 可不本地下载
mmlu	`modelscope/MMLU`	`cais/mmlu`	~50MB	❌ 可不本地下载
mmlu_pro	`modelscope/MMLU-Pro`	`TIGER-AI-Lab/MMLU-Pro`	~20MB	❌ 可不本地下载
ai2_arc	`modelscope/ai2_arc`	`ai2_arc`	~10MB	❌ 可不本地下载
ceval	`modelscope/ceval`	无	~15MB	❌ 可不本地下载
chinese_simpleqa	`modelscope/chinese_simpleqa`	无	~5MB	❌ 可不本地下载
cmmlu	`modelscope/CMMLU`	无	~30MB	❌ 可不本地下载
humaneval	`modelscope/humaneval`	`openai/humaneval`	~1MB	❌ 可不本地下载
gpqa_diamond	`modelscope/gpqa`	`Idavidr/GPQA`	~5MB	❌ 可不本地下载

✅ 结论：以上常用数据集都不大（均 < 100MB），评测时在线自动下载即可，不需要提前本地下载。

🤔 什么情况下必须本地下载？

✅ 可以不本地下载（推荐）

场景：外网环境 + 数据集 < 100MB

# 直接指定数据集名称，evalscope 自动处理
evalscope eval \
  --model Qwen/Qwen2-7B-Instruct \
  --datasets gsm8k

优点：

无需手动管理数据集文件
自动使用最新版本数据集
命令更简洁

⚠️ 必须本地下载

场景1：内网环境

机器无法访问 modelscope.cn 或 huggingface.co

解决方案：

先在一台能上网的机器下载数据集
拷贝到内网机器
用 --dataset-args '{"xxx": {"local_path": "/path"}}' 指定本地路径

# 步骤1：在外网机器下载
modelscope download \
  --dataset modelscope/gsm8k \
  --local_dir /tmp/gsm8k

# 步骤2：拷贝到内网机器（假设挂载到 /data）
scp -r /tmp/gsm8k user@internal-machine:/data/gsm8k

# 步骤3：在内网机器评测
evalscope eval \
  --model xxx \
  --datasets gsm8k \
  --dataset-args '{"gsm8k": {"local_path": "/data/gsm8k"}}'

场景2：数据集特别大（如 LongBench-v2 > 1GB）

问题：评测时在线下载可能超时

解决方案：提前下载到本地

# 提前下载
modelscope download \
  --dataset modelscope/longbench_v2 \
  --local_dir ./data/longbench_v2

# 评测时指定本地路径
evalscope eval \
  --model xxx \
  --datasets longbench_v2 \
  --dataset-args '{"longbench_v2": {"local_path": "./data/longbench_v2"}}'

🔄 切换数据集来源（ModelScope ↔ HuggingFace）

默认情况下，evalscope 从 ModelScope 加载数据集。如果需要切换到 HuggingFace：

命令行方式

# 默认从 ModelScope 加载
evalscope eval --datasets gsm8k

# 切换到 HuggingFace
evalscope eval \
  --datasets gsm8k \
  --dataset-hub huggingface

Python API 方式

from evalscope.config import TaskConfig

# 从 ModelScope 加载（默认）
task_config = TaskConfig(
    model='your-model',
    datasets=['gsm8k'],
    work_dir='outputs/gsm8k_eval',
)

# 从 HuggingFace 加载
task_config = TaskConfig(
    model='your-model',
    datasets=['gsm8k'],
    dataset_hub='huggingface',  # 切换到 HuggingFace
    work_dir='outputs/gsm8k_eval',
)

💡 一句话总结

数据集不需要 git clone，
评测时 evalscope 自动从 ModelScope 下载并缓存。
内网环境才需要手动下载放到本地，
用 local_path 指定路径。

6. 数据集：是否需要裁判？

✅ 不需要裁判（有标准答案，自动评分）

数据集	任务类型	评分方式
gsm8k	数学推理	数字答案精确匹配
mmlu / mmlu_pro	多任务选择题	ABCD 精确匹配
ai2_arc	科学推理选择题	ABCD 精确匹配
hellaswag	常识推理完形	选项匹配
truthfulqa	事实性判断	MC 选项匹配
chinese_simpleqa	中文简单问答	短答案包含匹配
cmmlu	中文多任务选择题	ABCD 精确匹配

特点：

有标准答案（ground truth）
评测时自动比对，无需人工干预
适合快速验证模型基础能力

⚠️ 需要裁判（开放式生成，无标准答案）

数据集	任务类型	裁判方式
arena_hard	对战式评测	AI 裁判比对
alpacaeval	指令跟随质量	AI 裁判打分
wildbench	真实场景对话	AI 裁判评分
自定义开放式数据集	创意写作/翻译/代码	AI 裁判或人工

特点：

无标准答案，需要 AI 模型或人工评判
需要配置裁判模型（--judge-model-args）
适合评测模型创造性、流畅性等主观能力

7. 评测模型配置：model/api-url/api-key 使用场景

场景1：本地 GPU 直接加载模型 ✅ 只需 model

# 前提：本机有 GPU（Linux/Windows），模型可本地加载
evalscope eval \
  --model Qwen/Qwen2.5-0.5B-Instruct \
  --datasets gsm8k \
  --limit 10

# --eval-type local 是默认值，可省略
# 不需要 --api-url，不需要 --api-key

适用场景：

本地有 GPU
模型可以本地加载（HuggingFace 格式）
不需要调用外部 API

场景2：调用外部 API 服务 ✅ 需要 api-url + api-key

# 前提：模型部署在云端或有内部 API 服务，提供 OpenAI 兼容接口
evalscope eval \
  --model gpt-4o \
  --api-url https://api.openai.com/v1 \
  --api-key $OPENAI_API_KEY \
  --eval-type openai_api \
  --datasets gsm8k \
  --limit 10

适用场景：

调用 OpenAI / Claude / 其他云端 API
内部部署了 OpenAI 兼容的推理服务
本地无 GPU，用云端模型评测

场景3：调用内部 API 服务，无认证 ✅ 需要 api-url，api-key 填 EMPTY

# 前提：内部服务没有鉴权（内网可信环境）
evalscope eval \
  --model wps-ai-model \
  --api-url http://10.x.x.x:8801/v1 \
  --api-key EMPTY \
  --eval-type openai_api \
  --datasets gsm8k mmlu_pro \
  --limit 50

适用场景：

内网环境，API 服务无鉴权
公司内部模型服务
测试环境快速验证

场景4：需要裁判模型的完整写法 ✅ 主模型 + 裁判模型都要配

evalscope eval \
  --model wps-ai-model \
  --api-url http://internal-api/v1 \
  --api-key EMPTY \
  --eval-type openai_api \
  --datasets open_qa_dataset \
  --judge-strategy auto \
  --judge-model-args '{
    "model_id": "Qwen/Qwen2.5-72B-Instruct",
    "api_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
    "api_key": "YOUR_DASHSCOPE_KEY"
  }' \
  --limit 20

适用场景：

评测开放式生成任务（无标准答案）
需要用强模型（如 Qwen2.5-72B）作为裁判
对战式评测（arena_hard 等）

8. 快速判断表

🤔 问：模型跑在哪里？

┌─────────────────────────────────────────┐
│  模型跑在哪里？                        │
├─────────────────────────────────────────┤
│  → 本机 GPU                          │
│     ✅ 只需 --model                   │
│                                       │
│  → 远程 API 服务                      │
│     ✅ 需要 --api-url + --api-key    │
└─────────────────────────────────────────┘

🔐 问：API 服务需要鉴权吗？

┌─────────────────────────────────────────┐
│  API 服务需要鉴权吗？                 │
├─────────────────────────────────────────┤
│  → 需要                              │
│     ✅ --api-key 填真实 key          │
│                                       │
│  → 不需要（内网）                   │
│     ✅ --api-key 填 EMPTY            │
└─────────────────────────────────────────┘

⚖️ 问：数据集有标准答案吗？

┌─────────────────────────────────────────┐
│  数据集有标准答案吗？                  │
├─────────────────────────────────────────┤
│  → 有（选择题/数学题）               │
│     ✅ 不需要裁判，直接跑             │
│                                       │
│  → 没有（开放式）                    │
│     ✅ 需要配 --judge-model-args     │
└─────────────────────────────────────────┘

9. 评测模型配置指南

🤖 支持的四类模型接入方式

方式一：本地 HuggingFace 模型

model='Qwen/Qwen2-0.5B-Instruct',  # ModelScope_ID 或本地路径
model_args={
    'revision': 'master',
    'device_map': 'auto',
    'torch_dtype': 'auto',
}

方式二：本地 PyTorch 模型

model='/path/to/your/local/model',
model_args={
    'model_type': 'pytorch',
    'tokenizer_path': '/path/to/tokenizer',
}

方式三：API 模型（OpenAI 兼容）

model='gpt-3.5-turbo',
model_args={
    'api': 'openai',
    'api_url': 'https://api.openai.com/v1/chat/completions',
    'api_key': 'your-api-key',
    'temperature': 0.0,  # 评测时建议设为0
}

方式四：vLLM 加速推理（推荐生产环境）

model='Qwen/Qwen2-7B-Instruct',
model_args={
    'backend': 'vllm',  # 使用 vLLM 加速
    'tensor_parallel_size': 2,  # 2卡并行
    'gpu_memory_utilization': 0.9,
}

⚙️ 关键参数详解

参数	默认值	说明	推荐设置
`temperature`	0.0	生成随机性	评测设为0，采样测试可设0.7
`top_p`	1.0	核采样阈值	评测保持1.0
`max_length`	2048	最大生成长度	根据任务调整
`num_fewshot`	0	Few-shot 样本数	知识类5-shot，推理类0-shot
`batch_size`	1	批处理大小	根据显存调整（4/8/16）

10. 常用评测任务实战

📝 任务一：综合知识评测（MMLU + CMMLU）

from evalscope.run import run_task
from evalscope.config import TaskConfig

task_config = TaskConfig(
    model='Qwen/Qwen2-7B-Instruct',
    datasets=['mmlu', 'cmmlu'],
    dataset_args={
        'mmlu': {'num_fewshot': 5},   # 5-shot评测
        'cmmlu': {'num_fewshot': 5},
    },
    work_dir='outputs/knowledge_eval',
    model_args={'device_map': 'auto'},
)

run_task(task_config=task_config)

结果解读：

MMLU 准确率 > 65%：达到英文知识基准线
CMMLU 准确率 > 60%：达到中文知识基准线

🧮 任务二：数学推理评测（GSM8K + MATH）

task_config = TaskConfig(
    model='Qwen/Qwen2-7B-Instruct',
    datasets=['gsm8k', 'math'],
    dataset_args={
        'gsm8k': {'split': 'test'},
        'math': {'level': 'all'},  # 评测所有难度
    },
    work_dir='outputs/math_eval',
    model_args={'temperature': 0.0},
)

关键点：数学推理建议用 0-shot，因为题目包含解答步骤。

💻 任务三：代码生成评测（HumanEval）

task_config = TaskConfig(
    model='Qwen/Qwen2.5-Coder-7B-Instruct',
    datasets=['humaneval'],
    dataset_args={'humaneval': {'pass_at_k': [1, 10]}},  # 计算 Pass@1 和 Pass@10
    work_dir='outputs/code_eval',
)

评估指标：

Pass@1：生成1次代码，通过率
Pass@10：生成10次，至少1次通过率

📊 任务四：自定义数据集评测

# 假设你有一个自定义数据集 my_data.jsonl
task_config = TaskConfig(
    model='your-model',
    datasets=['custom'],
    dataset_args={
        'custom': {
            'path': 'data/my_data.jsonl',
            'format': 'jsonl',  # 支持 jsonl/csv/txt
            'prompt_key': 'question',
            'answer_key': 'answer',
        }
    },
    work_dir='outputs/custom_eval',
)

数据格式示例（JSONL）：

{"question": "法国的首都是哪里？", "answer": "巴黎"}
{"question": "2+2等于几？", "answer": "4"}

11. 高级功能与技巧

🎯 技巧一：并行评测加速

task_config = TaskConfig(
    # ...其他配置...
    eval_args={
        'num_workers': 4,  # 4个进程并行
        'batch_size': 8,   # 每批8个样本
    }
)

📈 技巧二：生成可视化报告

from evalscope.report import Report

# 加载评测结果
report = Report.load('outputs/knowledge_eval/results.json')

# 生成可视化报告
report.visualize(
    output_path='outputs/report.html',
    plot_type='radar',  # 雷达图
    datasets=['mmlu', 'cmmlu', 'gsm8k'],
)

🔍 技巧三：错误分析（找出模型弱点）

from evalscope.analysis import ErrorAnalyzer

analyzer = ErrorAnalyzer('outputs/knowledge_eval/results.json')
analyzer.analyze_by_category()  # 按类别分析错误
analyzer.export_errors('outputs/error_analysis.csv')

输出示例：

类别          样本数    正确数    准确率    主要错误类型
----------------------------------------------
数学推理      1500      850      56.7%    计算错误
历史事件      800       720      90.0%    -
物理常识      600       400      66.7%    概念混淆

🔄 技巧四：Few-shot 效果对比实验

# 自动化对比不同 few-shot 设置的效果
for num_shot in [0, 1, 5, 10]:
    task_config = TaskConfig(
        model='your-model',
        datasets=['cmmlu'],
        dataset_args={'cmmlu': {'num_fewshot': num_shot}},
        work_dir=f'outputs/fewshot_{num_shot}',
    )
    run_task(task_config=task_config)

12. 查看评测结果

📊 方式一：终端查看（评测完成后自动打印）

# 评测完成后，终端会自动打印分数表格

# 示例输出：
# Dataset: gsm8k
# Accuracy: 0.8520
# Total samples: 1319

🌐 方式二：启动可视化服务（Web 界面）

# 1. 安装可视化服务依赖
pip install 'evalscope[service]'

# 2. 启动服务
evalscope service

# 3. 浏览器访问
# http://127.0.0.1:9000

可视化服务功能：

📊 多模型对比
📈 雷达图展示
📝 详细报告导出
🔍 样本级结果查看

💡 WPS AI QA 推荐起点

1. 先用 openai_api 方式评测内部 API
2. 选 gsm8k + mmlu_pro + chinese_simpleqa 三个有标准答案的数据集
3. --limit 10 先跑通
4. 再逐步扩大样本量

快速开始命令：

evalscope eval \
  --model wps-ai-v1 \
  --api-url http://10.x.x.x:8000/v1 \
  --api-key EMPTY \
  --eval-type openai_api \
  --datasets gsm8k mmlu_pro chinese_simpleqa \
  --limit 10 \
  --generation-config '{"temperature": 0.0, "max_tokens": 512}' \
  --output-dir ./eval-results

13. 常见问题与解决方案

❌ 问题一：CUDA 显存不足

错误信息：

OutOfMemoryError: CUDA out of memory

解决方案：

# 方案1：减小批处理大小
model_args={'device_map': 'auto', 'batch_size': 1}

# 方案2：使用量化（8-bit/4-bit）
model_args={'load_in_8bit': True}  # 或 load_in_4bit=True

# 方案3：使用 vLLM 高效推理
model_args={'backend': 'vllm', 'gpu_memory_utilization': 0.8}

❌ 问题二：评测速度太慢

原因分析：

模型过大，推理效率低
未启用批处理
数据集样本过多

解决方案：

# 启用 vLLM 加速
model_args={'backend': 'vllm', 'tensor_parallel_size': 2}

# 增加批处理大小
eval_args={'batch_size': 16, 'num_workers': 4}

# 使用数据集子集快速验证
dataset_args={'cmmlu': {'num_samples': 500}}  # 先测500个样本

❌ 问题三：评测结果与论文不一致

可能原因：

Few-shot 设置不同：检查 num_fewshot 参数
评测集中有测试集泄漏：确认使用官方划分
分词器差异：确保使用官方分词器
生成参数不同：固定 temperature=0.0, top_p=1.0

调试方法：

# 输出模型的原始预测，人工检查
task_config = TaskConfig(
    # ...其他配置...
    eval_args={'save_predictions': True},  # 保存预测结果
)

14. 最佳实践与优化建议

🏆 实践一：评测三部曲（推荐流程）

第一步：快速验证（小样本）
   ↓
第二步：全量评测（标准配置）
   ↓
第三步：错误分析（针对性优化）

具体操作：

# 第一步：用100个样本快速验证
dataset_args={'cmmlu': {'num_samples': 100}}
# 预期时间：< 5分钟

# 第二步：全量评测
dataset_args={'cmmlu': {'num_samples': None}}  # 全部样本
# 预期时间：根据模型大小，0.5~2小时

# 第三步：分析错误
from evalscope.analysis import ErrorAnalyzer
ErrorAnalyzer('results.json').export_errors('errors.csv')

📊 实践二：建立评测基准线

建议评测组合（根据模型类型选择）：

模型类型	推荐数据集组合	预期基准线
通用对话模型	MMLU + CMMLU + GSM8K + C-Eval	综合准确率 > 60%
代码模型	HumanEval + MBPP + CodeContests	Pass@1 > 40%
数学模型	GSM8K + MATH + MathQA	准确率 > 70%
垂类模型	领域数据集 + 通用数据集	领域 > 80%, 通用 > 50%

🔧 实践三：持续监控模型性能

# 建议：将评测集成到 CI/CD 流程
# 每次模型更新后自动运行基准评测

import subprocess
from evalscope.run import run_task

def auto_eval_on_update(model_path):
    """模型更新后自动评测"""
    config = TaskConfig(
        model=model_path,
        datasets=['mmlu', 'cmmlu'],  # 快速基准
        work_dir='outputs/auto_eval',
    )
    results = run_task(config)
    
    # 检查是否低于基准线
    if results['mmlu']['accuracy'] < 0.60:
        print("⚠️ 警告：MMLU 准确率低于基准线 60%！")
        # 发送通知（邮件/钉钉/Slack）

📦 实践四：结果对比与存档

# 将多次评测结果对比，追踪模型迭代效果

import json
import pandas as pd

def compare_runs(run_dirs):
    """对比多次评测结果"""
    records = []
    for run_dir in run_dirs:
        with open(f'{run_dir}/results.json') as f:
            data = json.load(f)
        records.append({
            'run': run_dir,
            'MMLU': data['mmlu']['accuracy'],
            'CMMLU': data['cmmlu']['accuracy'],
            'GSM8K': data['gsm8k']['accuracy'],
        })
    
    df = pd.DataFrame(records)
    df.to_csv('outputs/model_comparison.csv', index=False)
    return df

# 使用示例
df = compare_runs(['run1', 'run2', 'run3'])
print(df)

🎓 延伸学习资源

资源	链接	说明
官方文档	https://github.com/modelscope/EvalScope	最新文档与教程
数据集列表	https://github.com/modelscope/EvalScope/tree/master/evalscope/datasets	支持的所有数据集
示例笔记本	https://github.com/modelscope/EvalScope/tree/master/examples	Jupyter 实战案例
论文	arXiv:2402.OPT2024	EvalScope 技术报告

💡 总结：新手入门三步走

1️⃣ 安装 + 跑通示例 → 理解基本流程（30分钟）
   ↓
2️⃣ 尝试不同数据集   → 熟悉评测维度（1小时）
   ↓
3️⃣ 评测自己的模型   → 实际应用（2小时）

关键记住：

✅ 评测时用 temperature=0.0 保 reproducibility
✅ 知识类任务用 5-shot，推理类用 0-shot
✅ 先小样本验证，再全量评测
✅ 保存预测结果，便于错误分析

openEuler 社区

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目，面向数字基础设施四大核心场景（服务器、云计算、边缘计算、嵌入式），全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐

深入剖析 Linux 线程机制与分页式存储管理

openEuler 社区

鸽姆智库·真理映射型AI（TMAI）全球首发路演——从创始人投影到真理映射：一场文明级的范式革命

openEuler 社区

超级计算机操作系统：架构、服务与实践

openEuler 社区

所有评论(0)

查看更多评论

FunTester

@wanglin_lin

已为社区贡献1条内容