EleutherAI/lm-evaluation-harness
GitHub: EleutherAI/lm-evaluation-harness
一个统一的语言模型少样本评估框架，提供 60 多个标准学术基准任务，支持多种推理后端和 API，用于系统化、可复现地衡量生成式语言模型能力。
Stars: 12841 | Forks: 3324
# 语言模型评估测试框架
[](https://doi.org/10.5281/zenodo.10256836)
## 最新消息 📣
- [2025/12] **CLI 重构**：引入了子命令（`run`、`ls`、`validate`），并通过 `--config` 支持 YAML 配置文件。请参阅 [CLI 参考](./docs/interface.md)和[配置指南](./docs/config_files.md)。
- [2025/12] **更轻量的安装**：基础包不再包含 `transformers`/`torch`。请单独安装模型后端：`pip install lm_eval[hf]`、`lm_eval[vllm]` 等。
- [2025/07] 为 `hf`（token/str）、`vllm` 和 `sglang`（str）添加了 `think_end_token` 参数，用于从支持 CoT 推理的模型中去掉推理轨迹。
- [2025/03] 新增了对 HF 模型进行引导的支持！
- [2025/02] 新增了 [SGLang](https://docs.sglang.ai/) 支持！
- [2024/09] 我们正在尝试让 LM Evaluation Harness 的用户能够创建并评估文本+图像多模态输入、文本输出任务，并且刚刚添加了 `hf-multimodal` 和 `vllm-vlm` 模型类型以及 `mmmu` 任务作为原型功能。我们欢迎用户试用这项正在开发中的功能，并对其进行压力测试，同时建议他们关注 [`lmms-eval`](https://github.com/EvolvingLMMs-Lab/lmms-eval)，这是一个最初从 lm-evaluation-harness 分支出来的优秀项目，提供了更广泛的多模态任务、模型和功能。
- [2024/07] [API 模型](docs/API_guide.md)支持已更新并重构，引入了对批量化和异步请求的支持，并大幅提升了自定义和使用的便捷性。**要运行 Llama 405B，我们建议使用 VLLM 的 OpenAI 兼容 API 来托管模型，并使用 `local-completions` 模型类型来评估模型。**
- [2024/07] 新增了 Open LLM Leaderboard 任务！您可以在 [leaderboard](lm_eval/tasks/leaderboard/README.md) 任务组下找到它们。
## 公告
**lm-evaluation-harness 的新版本 v0.4.0 已发布**！
新的更新和功能包括：
- **新增了 Open LLM Leaderboard 任务！您可以在 [leaderboard](lm_eval/tasks/leaderboard/README.md) 任务组下找到它们。**
- 内部重构
- 基于配置的任务创建和设置
- 更轻松地导入和共享外部定义的任务配置 YAML
- 支持 Jinja2 提示词设计，轻松修改提示词 + 从 Promptsource 导入提示词
- 更高级的配置选项，包括输出后处理、答案提取、每个文档生成多次 LM 结果、可配置的 fewshot 设置等
- 速度提升和支持新的建模库，包括：更快的数据并行 HF 模型使用、vLLM 支持、HuggingFace 的 MPS 支持等
- 日志记录和可用性变更
- 新增任务，包括 CoT BIG-Bench-Hard、Belebele、用户自定义任务分组等
详情请参阅 `docs/` 中我们更新后的文档页面。
开发将在 `main` 分支上继续进行，我们欢迎您通过 GitHub 上的 issue 或 PR，或在 [EleutherAI discord](https://discord.gg/eleutherai) 中向我们提供关于所需功能以及如何进一步改进该库的反馈或提问！
## 概述
本项目提供了一个统一的框架，用于在大量不同的评估任务上测试生成式语言模型。
**功能：**
- 适用于 LLM 的 60 多个标准学术基准测试，实现了数百个子任务和变体。
- 支持通过 [transformers](https://github.com/huggingface/transformers/)（包括通过 [GPTQModel](https://github.com/ModelCloud/GPTQModel) 和 [AutoGPTQ](https://github.com/PanQiWei/AutoGPTQ) 进行量化）、[GPT-NeoX](https://github.com/EleutherAI/gpt-neox) 和 [Megatron-DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed/) 加载的模型，并具有灵活的与 tokenization 无关的接口。
- 支持使用 [vLLM](https://github.com/vllm-project/vllm) 进行快速且内存高效的推理。
- 支持商业 API，包括 [OpenAI](https://openai.com) 和 [TextSynth](https://textsynth.com/)。
- 支持评估 [HuggingFace 的 PEFT 库](https://github.com/huggingface/peft)支持的适配器（例如 LoRA）。
- 支持本地模型和基准测试。
- 使用公开可用的提示词进行评估，确保了论文之间的可重复性和可比性。
- 轻松支持自定义提示词和评估指标。
语言模型评估测试框架是 🤗 Hugging Face 广受欢迎的 [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard) 的后端，已在[数百篇论文](https://scholar.google.com/scholar?oi=bibs&hl=en&authuser=2&cites=15052937328817631261,4097184744846514103,1520777361382155671,17476825572045927382,18443729326628441434,14801318227356878622,7890865700763267262,12854182577605049984,15641002901115500560,5104500764547628290)中被使用，并被包括 NVIDIA、Cohere、BigScience、BigCode、Nous Research 和 Mosaic ML 在内的数十个组织内部使用。
## 安装
要从 GitHub 仓库安装 `lm-eval` 包，请运行：
```
git clone --depth 1 https://github.com/EleutherAI/lm-evaluation-harness
cd lm-evaluation-harness
pip install -e .
```
### 安装模型后端
基础安装提供了核心评估框架。**模型后端必须单独安装**，请使用可选扩展项：
对于 HuggingFace transformers 模型：
```
pip install "lm_eval[hf]"
```
对于 vLLM 推理：
```
pip install "lm_eval[vllm]"
```
对于基于 API 的模型（OpenAI、Anthropic 等）：
```
pip install "lm_eval[api]"
```
可以同时安装多个后端：
```
pip install "lm_eval[hf,vllm,api]"
```
本文档末尾提供了所有可选扩展项的详细表格。
## 基本用法
### 文档
| 指南 | 描述 |
|-------|-------------|
| [CLI 参考](./docs/interface.md) | 命令行参数和子命令 |
| [配置指南](./docs/config_files.md) | YAML 配置文件格式和示例 |
| [Python API](./docs/python-api.md) | 使用 `simple_evaluate()` 的编程式用法 |
| [任务指南](./lm_eval/tasks/README.md) | 可用任务及任务配置 |
使用 `lm-eval -h` 查看可用选项，或使用 `lm-eval run -h` 查看评估选项。
使用以下命令列出可用任务：
```
lm-eval ls tasks
```
### Hugging Face `transformers`
要评估托管在 [HuggingFace Hub](https://huggingface.co/models) 上的模型（例如 GPT-J-6B）在 `hellaswag` 上的表现，您可以使用以下命令（假设您使用的是兼容 CUDA 的 GPU）：
```
lm_eval --model hf \
--model_args pretrained=EleutherAI/gpt-j-6B \
--tasks hellaswag \
--device cuda:0 \
--batch_size 8
```
可以使用 `--model_args` 标志向模型构造函数提供额外的参数。最值得注意的是，它支持在 Hub 上使用 `revisions` 功能来存储部分训练的检查点，或者指定用于运行模型的数据类型等常见做法：
```
lm_eval --model hf \
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype="float" \
--tasks lambada_openai,hellaswag \
--device cuda:0 \
--batch_size 8
```
支持通过 Huggingface 中的 `transformers.AutoModelForCausalLM`（自回归、仅解码器的 GPT 风格模型）和 `transformers.AutoModelForSeq2SeqLM`（如 T5 等编码器-解码器模型）加载的模型。
通过将 ```--batch_size``` 标志设置为 ```auto```，可以自动选择批处理大小。这将自动检测适合您设备的最大批处理大小。在最长和最短示例之间差异较大的任务上，定期重新计算最大批处理大小有助于进一步提高速度。为此，请在上述标志后附加 ```:N```，以自动重新计算最大批处理大小 ```N``` 次。例如，要重新计算批处理大小 4 次，命令为：
```
lm_eval --model hf \
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype="float" \
--tasks lambada_openai,hellaswag \
--device cuda:0 \
--batch_size auto:4
```
#### 评估 GGUF 模型
`lm-eval` 支持使用 Hugging Face（`hf`）后端评估 GGUF 格式的模型。这允许您使用与 `transformers`、`AutoModel` 和 llama.cpp 转换兼容的量化模型。
要评估 GGUF 模型，请使用 `--model_args` 标志传递包含模型权重的目录路径、`gguf_file`，以及可选的单独 `tokenizer` 路径。
**🚨 重要提示：**
如果未提供单独的 tokenizer，Hugging Face 将尝试从 GGUF 文件重建 tokenizer——这可能需要**数小时**，甚至无限期挂起。提供单独的 tokenizer 可以避免此问题，并可将 tokenizer 的加载时间从数小时缩短至数秒。
**✅ 推荐用法：**
```
lm_eval --model hf \
--model_args pretrained=/path/to/gguf_folder,gguf_file=model-name.gguf,tokenizer=/path/to/tokenizer \
--tasks hellaswag \
--device cuda:0 \
--batch_size 8
```
#### 使用 Hugging Face `accelerate` 进行多 GPU 评估
我们支持三种使用 Hugging Face [accelerate 🚀](https://github.com/huggingface/accelerate) 库进行多 GPU 评估的主要方式。
要执行*数据并行评估*（其中每个 GPU 加载一个**独立的完整模型副本**），我们按如下方式使用 `accelerate` 启动器：
```
accelerate launch -m lm_eval --model hf \
--tasks lambada_openai,arc_easy \
--batch_size 16
```
（或通过 `accelerate launch --no-python lm_eval`）。
如果您的模型可以装载在单个 GPU 上，这种方式允许您在 K 个 GPU 上的评估速度比在一个 GPU 上快 K 倍。
**警告**：此设置不适用于 FSDP 模型分片，因此在 `accelerate config` 中必须禁用 FSDP，或者必须使用 NO_SHARD FSDP 选项。
使用 `accelerate` 进行多 GPU 评估的第二种方式是当您的模型*太大而无法装载在单个 GPU 上*时。
在这种情况下，在*不使用 `accelerate` 启动器*的情况下运行该库，而是向 `--model_args` 传递 `parallelize=True`，如下所示：
```
lm_eval --model hf \
--tasks lambada_openai,arc_easy \
--model_args parallelize=True \
--batch_size 16
```
这意味着您的模型权重将分配到所有可用的 GPU 上。
对于更高级的用户或更大的模型，当 `parallelize=True` 时，我们还允许使用以下参数：
- `device_map_option`：如何在可用 GPU 之间分配模型权重。默认为“auto”。
- `max_memory_per_gpu`：加载模型时每个 GPU 使用的最大 GPU 内存。
- `max_cpu_memory`：将模型权重卸载到 RAM 时使用的最大 CPU 内存量。
- `offload_folder`：在需要时将模型权重卸载到磁盘的文件夹。
第三种选择是同时使用两者。这将允许您同时利用数据并行和模型分片，对于无法装载在单个 GPU 上的模型特别有用。
```
accelerate launch --multi_gpu --num_processes {nb_of_copies_of_your_model} \
-m lm_eval --model hf \
--tasks lambada_openai,arc_easy \
--model_args parallelize=True \
--batch_size 16
```
要了解更多关于模型并行性以及如何将其与 `accelerate` 库结合使用的信息，请参阅 [accelerate 文档](https://huggingface.co/docs/transformers/v4.15.0/en/parallelism)
**警告：我们原生不支持使用 `hf` 模型类型进行多节点评估！请参考[我们的 GPT-NeoX 库集成](https://github.com/EleutherAI/gpt-neox/blob/main/eval.py)，作为编写自定义多机评估脚本代码的示例。**
**注意：我们目前原生不支持多节点评估，建议使用外部托管的服务器来运行推理请求，或者创建与您的分布式框架的自定义集成，[就像为 GPT-NeoX 库所做的那样](https://github.com/EleutherAI/gpt-neox/blob/main/eval_tasks/eval_adapter.py)。**
#### 张量并行（原生 PyTorch）
对于支持 PyTorch 原生张量并行性（通过 DTensor）的模型，您可以在 `--model_args` 中传入 `tp_plan=auto`，从而在不使用 `accelerate` 的 device-map 的情况下跨 GPU 分配模型权重。使用 `torchrun` 或 `accelerate launch` 启动：
```
torchrun --nproc-per-node=4 -m lm_eval \
--model hf \
--model_args pretrained=google/gemma-4-31B-it,tp_plan=auto \
--tasks lambada_openai,arc_easy \
--batch_size 16
```
**限制：**
- `tp_plan` 和 `parallelize=True` 是互斥的——只能选择其一。
- 模型中的 key-value heads 数量必须能被 `--nproc-per-node`（TP 度）整除。
- 需要 PyTorch >= 2.4 以及为模型暴露 TP 计划的 `transformers` 版本（v4.47+）。
### 引导式 Hugging Face `transformers` 模型
要评估应用了引导向量的 Hugging Face `transformers` 模型，请将模型类型指定为 `steered`，并提供包含预定义引导向量的 PyTorch 文件路径，或者指定如何从预训练的 `sparsify` 或 `sae_lens` 模型派生引导向量的 CSV 文件路径（您需要为此方法安装相应的可选依赖项）。
指定预定义的引导向量：
```
import torch
steer_config = {
"layers.3": {
"steering_vector": torch.randn(1, 768),
"bias": torch.randn(1, 768),
"steering_coefficient": 1,
"action": "add"
},
}
torch.save(steer_config, "steer_config.pt")
```
指定派生的引导向量：
```
import pandas as pd
pd.DataFrame({
"loader": ["sparsify"],
"action": ["add"],
"sparse_model": ["EleutherAI/sae-pythia-70m-32k"],
"hookpoint": ["layers.3"],
"feature_index": [30],
"steering_coefficient": [10.0],
}).to_csv("steer_config.csv", index=False)
```
运行应用了引导向量的评估框架：
```
lm_eval --model steered \
--model_args pretrained=EleutherAI/pythia-160m,steer_path=steer_config.pt \
--tasks lambada_openai,hellaswag \
--device cuda:0 \
--batch_size 8
```
### NVIDIA `nemo` 模型
[NVIDIA NeMo Framework](https://github.com/NVIDIA/NeMo) 是一个为从事语言模型研究的 pytorch 开发人员构建的生成式 AI 框架。
要评估 `nemo` 模型，首先请按照[文档](https://github.com/NVIDIA/NeMo?tab=readme-ov-file#installation)安装 NeMo。我们强烈建议使用 NVIDIA PyTorch 或 NeMo 容器，特别是在安装 Apex 或任何其他依赖项遇到问题时（请参阅[最新发布的容器](https://github.com/NVIDIA/NeMo/releases)）。还请按照[安装部分](https://github.com/EleutherAI/lm-evaluation-harness/tree/main?tab=readme-ov-file#install)中的说明安装 lm evaluation harness 库。
可以通过 [NVIDIA NGC 目录](https://catalog.ngc.nvidia.com/models)或 [NVIDIA 的 Hugging Face 页面](https://huggingface.co/nvidia)获取 NeMo 模型。在 [NVIDIA NeMo Framework](https://github.com/NVIDIA/NeMo/tree/main/scripts/nlp_language_modeling) 中有脚本，可以将 llama、falcon、mixtral 或 mpt 等流行模型的 `hf` 检查点转换为 `nemo`。
在单个 GPU 上运行 `nemo` 模型：
```
lm_eval --model nemo_lm \
--model_args path= \
--tasks hellaswag \
--batch_size 32
```
建议解压 `nemo` 模型以避免在 docker 容器内解压——这可能会导致磁盘空间溢出。为此您可以运行：
```
mkdir MY_MODEL
tar -xvf MY_MODEL.nemo -c MY_MODEL
```
#### 使用 NVIDIA `nemo` 模型进行多 GPU 评估
默认情况下，仅使用一个 GPU。但我们确实支持在单个节点上在评估期间进行数据复制或张量/流水线并行。
1. 要启用数据复制，请将 `model_args` 中的 `devices` 设置为要运行的数据副本数。例如，在 8 个 GPU 上运行 8 个数据副本的命令是：
```
torchrun --nproc-per-node=8 --no-python lm_eval \
--model nemo_lm \
--model_args path=,devices=8 \
--tasks hellaswag \
--batch_size 32
```
1. 要启用张量和/或流水线并行，请设置 `model_args` 中的 `tensor_model_parallel_size` 和/或 `pipeline_model_parallel_size`。此外，您还必须将 `devices` 设置为 `tensor_model_parallel_size` 和/或 `pipeline_model_parallel_size` 的乘积。例如，使用具有张量并行度为 2 和流水线并行度为 2 的 4 个 GPU 节点的命令是：
```
torchrun --nproc-per-node=4 --no-python lm_eval \
--model nemo_lm \
--model_args path=,devices=4,tensor_model_parallel_size=2,pipeline_model_parallel_size=2 \
--tasks hellaswag \
--batch_size 32
```
请注意，建议将 `python` 命令替换为 `torchrun --nproc-per-node=<设备数量> --no-python`，以便于将模型加载到 GPU 中。这对于加载到多个 GPU 的大型检查点尤为重要。
尚不支持：多节点评估以及数据复制与张量或流水线并行的组合。
### Megatron-LM 模型
[Megatron-LM](https://github.com/NVIDIA/Megatron-LM) 是 NVIDIA 的大规模 transformer 训练框架。此后端允许直接评估 Megatron-LM 检查点而无需转换。
**要求：**
- 必须安装 Megatron-LM 或可通过 `MEGATRON_PATH` 环境变量访问
- 带有 CUDA 支持的 PyTorch
**设置：**
```
# 设置指向 Megatron-LM 安装路径的环境变量
export MEGATRON_PATH=/path/to/Megatron-LM
```
**基本用法（单 GPU）：**
```
lm_eval --model megatron_lm \
--model_args load=/path/to/checkpoint,tokenizer_type=HuggingFaceTokenizer,tokenizer_model=/path/to/tokenizer \
--tasks hellaswag \
--batch_size 1
```
**支持的检查点格式：**
- 标准 Megatron 检查点（`model_optim_rng.pt`）
- 分布式检查点（`.distcp` 格式，自动检测）
#### 并行模式
Megatron-LM 后端支持以下并行模式：
| 模式 | 配置 | 描述 |
|------|---------------|-------------|
| 单 GPU | `devices=1`（默认） | 标准单 GPU 评估 |
| 数据并行 | `devices>1, TP=1` | 每个 GPU 拥有完整的模型副本，数据被分配 |
| 张量并行 | `TP == devices` | 模型层被分配到多个 GPU 上 |
| 专家并行 | `EP == devices, TP=1` | 对于 MoE 模型，专家分布在多个 GPU 上 |
**数据并行（4 个 GPU，每个都有完整的模型副本）：**
```
torchrun --nproc-per-node=4 -m lm_eval --model megatron_lm \
--model_args load=/path/to/checkpoint,tokenizer_model=/path/to/tokenizer,devices=4 \
--tasks hellaswag
```
**张量并行（TP=2）：**
```
torchrun --nproc-per-node=2 -m lm_eval --model megatron_lm \
--model_args load=/path/to/checkpoint,tokenizer_model=/path/to/tokenizer,devices=2,tensor_model_parallel_size=2 \
--tasks hellaswag
```
**MoE 模型的专家并行（EP=4）：**
```
torchrun --nproc-per-node=4 -m lm_eval --model megatron_lm \
--model_args load=/path/to/moe_checkpoint,tokenizer_model=/path/to/tokenizer,devices=4,expert_model_parallel_size=4 \
--tasks hellaswag
```
**使用 extra_args 添加额外的 Megatron 选项：**
```
lm_eval --model megatron_lm \
--model_args load=/path/to/checkpoint,tokenizer_model=/path/to/tokenizer,extra_args="--no-rope-fusion --trust-remote-code" \
--tasks hellaswag
```
#### 使用 OpenVINO 模型进行多 GPU 评估
在使用 OpenVINO 模型进行评估时支持流水线并行。
要启用流水线并行，请设置 `model_args` 中的 `pipeline_parallel`。此外，您还必须将 `device` 设置为 `HETERO:,`（例如 `HETERO:GPU.1,GPU.0`）。例如，使用流水线并行度为 2 的命令是：
```
lm_eval --model openvino \
--tasks wikitext \
--model_args pretrained=,pipeline_parallel=True \
--device HETERO:GPU.1,GPU.0
```
### 使用 `vLLM` 进行张量+数据并行及优化推理
我们还支持使用 vLLM 在[支持的模型类型](https://docs.vllm.ai/en/latest/models/supported_models.html)上进行更快的推理，特别是在跨多个 GPU 分配模型时速度更快。适用于单 GPU 或多 GPU —— 张量并行、数据并行或两者结合 —— 的推理，例如：
```
lm_eval --model vllm \
--model_args pretrained={model_name},tensor_parallel_size={GPUs_per_model},dtype=auto,gpu_memory_utilization=0.8,data_parallel_size={model_replicas} \
--tasks lambada_openai \
--batch_size auto
```
要使用 vllm，请执行 `pip install "lm_eval[vllm]"`。有关支持的 vLLM 配置的完整列表，请参考我们的 [vLLM 集成](https://github.com/EleutherAI/lm-evaluation-harness/blob/e74ec966556253fbe3d8ecba9de675c77c075bce/lm_eval/models/vllm_causallms.py)和 vLLM 文档。
vLLM 的输出偶尔会与 Huggingface 不同。我们将 Huggingface 视为参考实现，并提供了一个[脚本](./scripts/model_comparator.py)用于根据 HF 检查 vllm 结果的有效性。
### 使用 `SGLang` 进行张量+数据并行及快速离线批处理推理
我们支持使用 SGLang 进行高效的离线批处理推理。其 **[快速后端运行时](https://docs.sglang.ai/index.html)** 通过优化的内存管理和并行处理技术提供了高性能。主要功能包括张量并行、连续批处理以及对各种量化方法（FP8/INT4/AWQ/GPTQ）的支持。
要将 SGLang 用作评估后端，请事先通过 SGLang 文档[在此处](https://docs.sglang.io/get_started/install.html#install-sglang)进行**安装**。
SGLang 的服务器参数与其他后端略有不同，请参见[此处](https://docs.sglang.io/advanced_features/server_arguments.html)了解更多信息。我们在此提供了一个使用示例：
```
lm_eval --model sglang \
--model_args pretrained={model_name},dp_size={data_parallel_size},tp_size={tensor_parallel_size},dtype=auto \
--tasks gsm8k_cot \
--batch_size auto
```
### Windows ML
我们支持 **Windows ML**，用于在 Windows 平台上进行硬件加速推理。这允许在 CPU、GPU 和 **NPU（神经网络处理单元）** 设备上进行评估。
什么是 Windows ML？
https://learn.microsoft.com/en-us/windows/ai/new-windows-ml/overview
要使用 Windows ML，请安装所需的依赖项：
```
pip install wasdk-Microsoft.Windows.AI.MachineLearning[all] wasdk-Microsoft.Windows.ApplicationModel.DynamicDependency.Bootstrap onnxruntime-windowsml onnxruntime-genai-winml
```
在 Windows 上评估 NPU/GPU/CPU 上的 ONNX Runtime GenAI LLM：
```
lm_eval --model winml \
--model_args pretrained=/path/to/onnx/model \
--tasks mmlu \
--batch_size 1
```
### 模型 API 和推理服务器
我们的库还支持通过多个商业 API 提供的模型评估，并希望实现对最常用的高性能本地/自托管推理服务器的支持。
要调用托管模型，请使用：
```
export OPENAI_API_KEY=YOUR_KEY_HERE
lm_eval --model openai-completions \
--model_args model=davinci-002 \
--tasks lambada_openai,hellaswag
```
我们还支持使用您自己的本地推理服务器，只要它们镜像了 OpenAI Completions 和 ChatCompletions API 即可。
```
lm_eval --model local-completions --tasks gsm8k --model_args model=facebook/opt-125m,base_url=http://{yourip}:8000/v1/completions,num_concurrent=1,max_retries=3,tokenized_requests=False,batch_size=16
```
请注意，对于外部托管的模型，不应使用诸如 `--device` 等与放置本地模型位置相关的配置，这些配置将不起作用。就像您可以使用 `--model_args` 为本地模型向模型构造函数传递任意参数一样，您也可以使用它为托管模型向模型 API 传递任意参数。请参阅托管服务的文档，了解它们支持的参数信息。
| API 或推理服务器 | 是否已实现？ | `--model ` 名称 | 支持的模型： | 请求类型： |
|---------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------|-------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------|
| OpenAI Completions | :heavy_check_mark: | `openai-completions`, `local-completions` | 所有 OpenAI Completions API 模型 | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| OpenAI ChatCompletions | :heavy_check_mark: | `openai-chat-completions`, `local-chat-completions` | [所有 ChatCompletions API 模型](https://platform.openai.com/docs/guides/gpt) | `generate_until`（无 logprobs） |
| Anthropic | :heavy_check_mark: | `anthropic` | [支持的 Anthropic 引擎](https://docs.anthropic.com/claude/reference/selecting-a-model) | `generate_until`（无 logprobs） |
| Anthropic Chat | :heavy_check_mark: | `anthropic-chat`, `anthropic-chat-completions` | [支持的 Anthropic 引擎](https://docs.anthropic.com/claude/docs/models-overview) | `generate_until`（无 logprobs） |
| [LiteLLM](https://github.com/BerriAI/litellm)（通往 100 多个提供商的网关） | :heavy_check_mark: | `litellm`, `litellm-chat`, `litellm-chat-completions` | [所有 LiteLLM 支持的提供商](https://docs.litellm.ai/docs/providers) | `generate_until`（无 logprobs） |
| Textsynth | :heavy_check_mark: | `textsynth` | [所有支持的引擎](https://textsynth.com/documentation.html#engines) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| Cohere | [:hourglass: - 受阻于 Cohere API 错误](https://github.com/EleutherAI/lm-evaluation-harness/pull/395) | N/A | [所有 `cohere.generate()` 引擎](https://docs.cohere.com/docs/models) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| [Llama.cpp](https://github.com/ggerganov/llama.cpp)（通过 [llama-cpp-python](https://github.com/abetlen/llama-cpp-python)) | :heavy_check_mark: | `gguf`, `ggml` | [所有 llama.cpp 支持的模型](https://github.com/ggerganov/llama.cpp) | `generate_until`, `loglikelihood`,（尚未实现困惑度评估） |
| vLLM | :heavy_check_mark: | `vllm` | [大多数 HF Causal Language Models](https://docs.vllm.ai/en/latest/models/supported_models.html) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| Mamba | :heavy_check_mark: | `mamba_ssm` | [通过 `mamba_ssm` 包的 Mamba 架构语言模型](https://huggingface.co/state-spaces) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| Huggingface Optimum (Causal LMs) | :heavy_check_mark: | `openvino` | 使用 Huggingface Optimum 转换为 OpenVINO™ 中间表示（IR）格式的任何仅解码器 AutoModelForCausalLM | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| Huggingface Optimum-intel IPEX (Causal LMs) | :heavy_check_mark: | `ipex` | 任何仅解码器 AutoModelForCausalLM | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| Huggingface Optimum-habana (Causal LMs) | :heavy_check_mark: | `habana` | 任何仅解码器 AutoModelForCausalLM | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| 通过 AWS Inf2 的 Neuron (Causal LMs) | :heavy_check_mark: | `neuronx` | 任何支持在 [inferentia2 的 huggingface-ami 镜像](https://aws.amazon.com/marketplace/pp/prodview-gr3e6yiscria2)上运行的仅解码器 AutoModelForCausalLM | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| NVIDIA NeMo | :heavy_check_mark: | `nemo_lm` | [所有支持的模型](https://docs.nvidia.com/nemo-framework/user-guide/24.09/nemotoolkit/core/core.html#nemo-models) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| NVIDIA Megatron-LM | :heavy_check_mark: | `megatron_lm` | [Megatron-LM GPT 模型](https://github.com/NVIDIA/Megatron-LM)（标准和分布式检查点） | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| Watsonx.ai | :heavy_check_mark: | `watsonx_llm` | [支持的 Watsonx.ai 引擎](https://dataplatform.cloud.ibm.com/docs/content/wsj/analyze-data/fm-models.html?context=wx) | `generate_until` `loglikelihood` |
| Windows ML | :heavy_check_mark: | `winml` | [GenAI 格式的 ONNX 模型](https://code.visualstudio.com/docs/intelligentapps/modelconversion) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
| [您的本地推理服务器！](docs/API_guide.md) | :heavy_check_mark: | `local-completions` 或 `local-chat-completions` | 支持与 OpenAI API 兼容的服务器，并支持轻松自定义以适配其他 API。 | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
不提供 logits 或 logprobs 的模型只能用于 `generate_until` 类型的任务，而本地模型或提供其提示词 logprobs/logits 的 API 可以运行在所有任务类型上：`generate_until`、`loglikelihood`、`loglikelihood_rolling` 和 `multiple_choice`。
有关不同任务 `output_types` 和模型请求类型的更多信息，请参阅[我们的文档](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/model_guide.md#interface)。
### 其他框架
许多其他库都包含通过其库调用评估框架的脚本。这些库包括 [GPT-NeoX](https://github.com/EleutherAI/gpt-neox/blob/main/eval_tasks/eval_adapter.py)、[Megatron-DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed/blob/main/examples/MoE/readme_evalharness.md) 和 [mesh-transformer-j](https://github.com/kingoflolz/mesh-transformer-jax/blob/master/eval_harness.py)。
要创建您自己的自定义集成，您可以按照[本教程](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/interface.md#external-library-usage)中的说明进行操作。
### 附加功能
如果您拥有兼容 Metal 的 Mac，则可以通过将 `--device cuda:0` 替换为 `--device mps` 来使用 MPS 后端运行评估框架（需要 PyTorch 2.1 或更高版本）。**请注意，PyTorch MPS 后端仍处于早期开发阶段，因此可能存在正确性问题或不支持的操作。如果您在 MPS 后端上观察到模型性能的异常情况，我们建议首先检查您的模型在 `--device cpu` 和 `--device mps` 上的前向传递是否匹配。**
要在运行任务本身的同时验证正在执行的任务的数据完整性，您可以使用 `--check_integrity` 标志：
```
lm_eval --model openai \
--model_args engine=davinci-002 \
--tasks lambada_openai,hellaswag \
--check_integrity
```
## 高级用法提示
对于使用 HuggingFace `transformers` 库加载的模型，通过 `--model_args` 提供的任何参数都将直接传递给相关的构造函数。这意味着您可以使用 `AutoModel` 执行的任何操作，都可以使用我们的库来完成。例如，您可以通过 `pretrained=` 传递本地路径，或者通过提取您要运行以评估基础模型的调用，并向 `model_args` 参数添加 `,peft=PATH` 来使用通过 [PEFT](https://github.com/huggingface/peft) 微调的模型：
```
lm_eval --model hf \
--model_args pretrained=EleutherAI/gpt-j-6b,parallelize=True,load_in_4bit=True,peft=nomic-ai/gpt4all-j-lora \
--tasks openbookqa,arc_easy,winogrande,hellaswag,arc_challenge,piqa,boolq \
--device cuda:0
```
作为增量权重提供的模型可以使用 Hugging Face transformers 库轻松加载。在 --model_args 中，设置 delta 参数以指定增量权重，并使用 pretrained 参数指定将要应用它们的相关基础模型：
```
lm_eval --model hf \
--model_args pretrained=Ejafa/llama_7B,delta=lmsys/vicuna-7b-delta-v1.1 \
--tasks hellaswag
```
可以使用 [GPTQModel](https://github.com/ModelCloud/GPTQModel)（更快）或 [AutoGPTQ](https://github.com/PanQiWei/AutoGPTQ) 加载 GPTQ 量化的模型。
GPTQModel：向 `model_args` 添加 `,gptqmodel=True`
```
lm_eval --model hf \
--model_args pretrained=model-name-or-path,gptqmodel=True \
--tasks hellaswag
```
AutoGPTQ：向 `model_args` 添加 `,autogptq=True`：
```
lm_eval --model hf \
--model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True \
--tasks hellaswag
```
我们支持在任务名称中使用通配符，例如您可以通过 `--task lambada_openai_mt_*` 运行所有机器翻译的 lambada 任务。
## 保存和缓存结果
要保存评估结果，请提供 `--output_path`。我们还支持使用 `--log_samples` 标志记录模型响应，以便进行事后分析。
要将结果和样本推送到 Hugging Face Hub，首先请确保在 `HF_TOKEN` 环境变量中设置了具有写入权限的访问令牌。然后，使用 `--hf_hub_log_args` 标志指定组织、仓库名称、仓库可见性，以及是否将结果和样本推送到 Hub —— [HF Hub 上的示例数据集](https://huggingface.co/datasets/KonradSzafer/lm-eval-results-demo)。例如：
```
lm_eval --model hf \
--model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True \
--tasks hellaswag \
--log_samples \
--output_path results \
--hf_hub_log_args hub_results_org=EleutherAI,hub_repo_name=lm-eval-results,push_results_to_hub=True,push_samples_to_hub=True,public_repo=False \
```
这允许您使用以下命令轻松地从 Hub 下载结果和样本：
```
from datasets import load_dataset
load_dataset("EleutherAI/lm-eval-results-private", "hellaswag", "latest")
```
有关受支持参数的完整列表，请查阅我们文档中的[接口](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/interface.md)指南！
## 可视化结果
您可以使用 Weights & Biases (W&B) 和 Zeno 无缝地可视化和分析您的评估框架运行结果。
### Zeno
您可以使用 [Zeno](https://zenoml.com) 来可视化您的评估框架运行结果。
首先，前往 [hub.zenoml.com](https://hub.zenoml.com) 创建一个帐户，并在[您的帐户页面](https://hub.zenoml.com/account)获取 API 密钥。
将此密钥添加为环境变量：
```
export ZENO_API_KEY=[your api key]
```
您还需要安装 `lm_eval[zeno]` 扩展包。
要可视化结果，请使用 `log_samples` 和 `output_path` 标志运行评估框架。
我们期望 `output_path` 包含代表各个模型名称的多个文件夹。
因此，您可以在任意数量的任务和模型上运行评估，并将所有结果作为项目上传到 Zeno。
```
lm_eval \
--model hf \
--model_args pretrained=EleutherAI/gpt-j-6B \
--tasks hellaswag \
--device cuda:0 \
--batch_size 8 \
--log_samples \
--output_path output/gpt-j-6B
```
然后，您可以使用 `zeno_visualize` 脚本上传生成的数据：
```
python scripts/zeno_visualize.py \
--data_path output \
--project_name "Eleuther Project"
```
这将使用 `data_path` 中的所有子文件夹作为不同的模型，并将这些模型文件夹中的所有任务上传到 Zeno。
如果您在多个任务上运行评估框架，`project_name` 将用作前缀，并且每个任务将创建一个项目。
您可以在 [examples/visualize-zeno.ipynb](examples/visualize-zeno.ipynb) 中找到此工作流的示例。
### Weights and Biases
通过 [Weights and Biases](https://wandb.ai/site) 集成，您现在可以花更多时间从评估结果中提取更深入的见解。该集成旨在简化使用 Weights & Biases (W&B) 平台记录和可视化实验结果的过程。
该集成提供的功能：
- 自动记录评估结果，
- 将样本作为 W&B Tables 记录以便于可视化，
- 将 `results.json` 文件作为 artifact 记录以进行版本控制，
- 如果记录了样本，则记录 `_eval_samples.json` 文件，
- 生成包含所有重要指标的全面报告以供分析和可视化，
- 记录任务和 cli 特定的配置，
- 以及更多开箱即用的功能，例如用于运行评估的命令、GPU/CPU 数量、时间戳等。
首先，您需要安装 lm_eval[wandb] 扩展包。执行 `pip install lm_eval[wandb]`。
使用您独特的 W&B 令牌验证您的机器。访问 https://wandb.ai/authorize 获取令牌。在命令行终端中执行 `wandb login`。
像往常一样使用 `wandb_args` 标志运行评估框架。使用此标志以逗号分隔的字符串参数形式提供用于初始化 wandb 运行（[wandb.init](https://docs.wandb.ai/ref/python/init)）的参数。
```
lm_eval \
--model hf \
--model_args pretrained=microsoft/phi-2,trust_remote_code=True \
--tasks hellaswag,mmlu_abstract_algebra \
--device cuda:0 \
--batch_size 8 \
--output_path output/phi-2 \
--limit 10 \
--wandb_args project=lm-eval-harness-integration \
--log_samples
```
在 stdout 中，您将找到指向 W&B 运行页面的链接以及指向生成报告的链接。您可以在 [examples/visualize-wandb.ipynb](examples/visualize-wandb.ipynb) 中找到此工作流的示例，以及如何在 CLI 之外集成它的示例。
## 贡献
查看我们的[待处理问题](https://github.com/EleutherAI/lm-evaluation-harness/issues)，随时欢迎提交拉取请求！
有关该库及其各部分如何组合在一起的更多信息，请参阅我们的[文档页面](https://github.com/EleutherAI/lm-evaluation-harness/tree/main/docs)。
要开始开发，首先克隆仓库并安装开发依赖项：
```
git clone https://github.com/EleutherAI/lm-evaluation-harness
cd lm-evaluation-harness
pip install -e ".[dev,hf]"
```
### 实现新任务
要在评估框架中实现新任务，请参阅[本指南](./docs/new_task_guide.md)。
通常，我们遵循以下优先级列表来解决有关提示和其他评估细节的问题：
1. 如果训练 LLM 的人员之间达成了广泛共识，则使用达成共识的程序。
2. 如果有明确且毫无争议的官方实现，则使用该程序。
3. 如果评估 LLM 的人员之间达成了广泛共识，则使用达成共识的程序。
4. 如果有多种常见的实现方式但没有达成普遍或广泛的共识，则使用我们在常见实现中偏好的选项。与以前一样，优先从 LLM 训练论文中的实现里进行选择。
这些是指导原则而非规则，在特殊情况下可以推翻。
我们优先考虑与其他团队使用的程序保持一致，以减少当人们不可避免地跨不同论文比较运行结果时造成的损害，尽管我们不鼓励这种做法。从历史上看，我们还优先考虑了 [Language Models are Few Shot Learners](https://arxiv.org/abs/2005.14165) 中的实现，因为我们最初的目标专门是与该论文的结果进行比较。
### 支持
获得支持的最佳方法是在本仓库开启一个 issue 或加入 [EleutherAI Discord 服务器](https://discord.gg/eleutherai)。`#lm-thunderdome` 频道专用于开发此项目，`#release-discussion` 频道用于获取有关我们版本的支持。如果您使用了该库并获得积极（或消极）的体验，我们非常希望能收到您的反馈！
## 可选扩展项
可以通过 `pip install -e ".[NAME]"` 安装扩展依赖项
### 模型后端
这些扩展项会安装运行特定模型后端所需的依赖项：
| 名称 | 描述 |
|----------------|--------------------------------------------------|
| hf | HuggingFace Transformers（torch、transformers、accelerate、peft） |
| vllm | vLLM 快速推理 |
| api | API 模型（OpenAI、Anthropic、本地服务器） |
| gptq | AutoGPTQ 量化模型 |
| gptqmodel | GPTQModel 量化模型 |
| ibm_watsonx_ai | IBM watsonx.ai 模型 |
| ipex | Intel IPEX 后端 |
| habana | Intel Gaudi 后端 |
| optimum | Intel OpenVINO 模型 |
| neuronx | AWS Inferentia2 实例 |
| winml | Windows ML（ONNX Runtime GenAI）- CPU/GPU/NPU |
| sparsify | Sparsify 模型引导 |
| sae_lens | SAELens 模型引导 |
### 任务依赖项
这些扩展项会安装特定评估任务所需的依赖项：
| 名称 | 描述 |
|----------------------|--------------------------------|
| tasks | 所有特定任务的依赖项 |
| acpbench | ACP Bench 任务 |
| audiolm_qwen | Qwen2 音频模型 |
| ifeval | IFEval 任务 |
| japanese_leaderboard | 日本语 LLM 任务 |
| longbench | LongBench 任务 |
| math | 数学答案检查 |
| multilingual | 多语种分词器 |
| ruler | RULER 任务 |
### 开发与实用工具
| 名称 | 描述 |
|---------------|--------------------------------|
| dev | 代码检查与贡献 |
| hf_transfer | 加速 HF 下载 |
| sentencepiece | Sentencepiece 分词器 |
| unitxt | Unitxt 任务 |
| wandb | Weights & Biases 日志记录 |
| zeno | Zeno 结果可视化 |
## 引用为
```
@misc{eval-harness,
author = {Gao, Leo and Tow, Jonathan and Abbasi, Baber and Biderman, Stella and Black, Sid and DiPofi, Anthony and Foster, Charles and Golding, Laurence and Hsu, Jeffrey and Le Noac'h, Alain and Li, Haonan and McDonell, Kyle and Muennighoff, Niklas and Ociepa, Chris and Phang, Jason and Reynolds, Laria and Schoelkopf, Hailey and Skowron, Aviya and Sutawika, Lintang and Tang, Eric and Thite, Anish and Wang, Ben and Wang, Kevin and Zou, Andy},
title = {The Language Model Evaluation Harness},
month = 07,
year = 2024,
publisher = {Zenodo},
version = {v0.4.3},
doi = {10.5281/zenodo.12608602},
url = {https://zenodo.org/records/12608602}
}
```
标签：AI模型测试, Apex, API集成, DLL 劫持, DNS解析, Few-Shot, HuggingFace, LLM评估基准, NLP, OpenLLM, Petitpotam, Python, PyTorch, SGLang, VLLM, 任务评测, 凭据扫描, 可观测性, 多模态, 大模型开发工具, 大语言模型, 少样本学习, 开源项目, 无后门, 机器学习, 模型性能基准, 深度学习, 评估框架, 语言模型评估, 逆向工具