Сравните большие языковые модели с помощью lm-evaluation-harness

Как применить

Используйте lm-evaluation-harness для тестирования моделей в академических статьях, сравнения качества моделей по стандартным задачам или отслеживания прогресса обучения.

Этот инструмент также подходит, когда нужно получить воспроизводимые результаты оценки и отчеты со стандартизированными метриками, так как все используют одинаковые запросы.

Для более широкой оценки справедливости, эффективности и калибровки подойдет HELM (Стэнфорд); для проверки умения следовать инструкциям с участием моделей-судей — AlpacaEval; для оценки многоэтапных диалогов — MT-Bench; для задач конкретной области — собственные скрипты.

Аппаратные требования: поддерживается GPU NVIDIA (CUDA 11.8+); процессор тоже подходит, но работает очень медленно.

Объем видеопамяти зависит от модели: для модели на 7 миллиардов параметров требуется 16 ГБ в формате bf16 или 8 ГБ при использовании 8-битной квантизации; для модели на 13 миллиардов параметров — 28 ГБ в bf16 или 14 ГБ при 8-битной квантизации; модель на 70 миллиардов параметров требует нескольких GPU или квантизации.

Примерное время оценки модели на 7 миллиардов параметров на одном GPU типа A100: HellaSwag — около 10 минут, GSM8K — около 5 минут, полный набор тестов MMLU — около 2 часов, HumanEval — около 20 минут.

Для частой оценки в процессе обучения выбирайте быстрые тесты: HellaSwag занимает около 10 минут на 1 GPU, GSM8K — около 5 минут, PIQA — около 2 минут.

Избегайте использования MMLU (около 2 часов на 57 тестов) и HumanEval (требует выполнения кода) для частой оценки, так как они слишком медленные.

Вы можете автоматизировать процесс оценки, интегрировав его в скрипт обучения, или воспользоваться коллбэками PyTorch Lightning.

Используйте lm-evaluation-harness для тестирования моделей в академических статьях, сравнения качества моделей по стандартным задачам или отслеживания прогресса обучения.

Этот инструмент также подходит, когда нужно получить воспроизводимые результаты оценки и отчеты со стандартизированными метриками, так как все используют одинаковые запросы.

Для более широкой оценки справедливости, эффективности и калибровки подойдет HELM (Стэнфорд); для проверки умения следовать инструкциям с участием моделей-судей — AlpacaEval; для оценки многоэтапных диалогов — MT-Bench; для задач конкретной области — собственные скрипты.

Аппаратные требования: поддерживается GPU NVIDIA (CUDA 11.8+); процессор тоже подходит, но работает очень медленно.

Объем видеопамяти зависит от модели: для модели на 7 миллиардов параметров требуется 16 ГБ в формате bf16 или 8 ГБ при использовании 8-битной квантизации; для модели на 13 миллиардов параметров — 28 ГБ в bf16 или 14 ГБ при 8-битной квантизации; модель на 70 миллиардов параметров требует нескольких GPU или квантизации.

Примерное время оценки модели на 7 миллиардов параметров на одном GPU типа A100: HellaSwag — около 10 минут, GSM8K — около 5 минут, полный набор тестов MMLU — около 2 часов, HumanEval — около 20 минут.

Для частой оценки в процессе обучения выбирайте быстрые тесты: HellaSwag занимает около 10 минут на 1 GPU, GSM8K — около 5 минут, PIQA — около 2 минут.

Избегайте использования MMLU (около 2 часов на 57 тестов) и HumanEval (требует выполнения кода) для частой оценки, так как они слишком медленные.

Вы можете автоматизировать процесс оценки, интегрировав его в скрипт обучения, или воспользоваться коллбэками PyTorch Lightning.

Вы можете автоматизировать процесс оценки, интегрировав его в скрипт обучения, или воспользоваться коллбэками PyTorch Lightning.

Быстрый старт: установите инструмент.

Установите его через pip: pip install lm-eval.

pip install lm-eval

Чтобы оценить любую модель из HuggingFace, запустите lm_eval с указанием бэкенда hf, имени предобученной модели, задач вроде mmlu, gsm8k, hellaswag, устройства и размера пакета.

lm_eval --model hf \
  --model_args pretrained=meta-llama/Llama-2-7b-hf \
  --tasks mmlu,gsm8k,hellaswag \
  --device cuda:0 \
  --batch_size 8

Чтобы увидеть доступные задачи, выполните команду lm-eval ls tasks.

lm-eval ls tasks

Рабочий процесс 1: стандартная оценка по тестам — проверка модели на основных наборах тестов (MMLU, GSM8K, HumanEval).

Инструкция: Шаг 1 — выберите набор тестов; Шаг 2 — настройте модель; Шаг 3 — запустите оценку; Шаг 4 — проанализируйте результаты.

Benchmark Evaluation:
- [ ] Step 1: Choose benchmark suite
- [ ] Step 2: Configure model
- [ ] Step 3: Run evaluation
- [ ] Step 4: Analyze results

Шаг 1: выберите набор тестов для оценки.

Для релизов моделей рекомендуемый стандартный набор включает mmlu, gsm8k, hellaswag, truthfulqa и arc_challenge.

--tasks mmlu,gsm8k,hellaswag,truthfulqa,arc_challenge

Шаг 2: настройте модель.

Для модели из HuggingFace запустите lm_eval с использованием бэкенда hf, указав параметры model_args pretrained=meta-llama/Llama-2-7b-hf,dtype=bfloat16, --tasks mmlu, --device cuda:0 и --batch_size auto, чтобы автоматически определить оптимальный размер пакета.

lm_eval --model hf \
  --model_args pretrained=meta-llama/Llama-2-7b-hf,dtype=bfloat16 \
  --tasks mmlu \
  --device cuda:0 \
  --batch_size auto  # Auto-detect optimal batch size

Для квантованной 4-битной/8-битной модели добавьте в model_args параметр load_in_4bit=True.

lm_eval --model hf \
  --model_args pretrained=meta-llama/Llama-2-7b-hf,load_in_4bit=True \
  --tasks mmlu \
  --device cuda:0

Для пользовательской точки восстановления передайте в model_args значения pretrained=/path/to/my-model и tokenizer=/path/to/tokenizer.

lm_eval --model hf \
  --model_args pretrained=/path/to/my-model,tokenizer=/path/to/tokenizer \
  --tasks mmlu \
  --device cuda:0

Шаг 3: запустите оценку. Например, полная проверка MMLU (57 предметов) с параметрами --num_fewshot 5 (стандартное значение), --batch_size 8, --output_path results/ и --log_samples для сохранения индивидуальных прогнозов; также можно одновременно запустить несколько тестов, перечислив их после --tasks.

# Full MMLU evaluation (57 subjects)
lm_eval --model hf \
  --model_args pretrained=meta-llama/Llama-2-7b-hf \
  --tasks mmlu \
  --num_fewshot 5 \  # 5-shot evaluation (standard)
  --batch_size 8 \
  --output_path results/ \
  --log_samples  # Save individual predictions

# Multiple benchmarks at once
lm_eval --model hf \
  --model_args pretrained=meta-llama/Llama-2-7b-hf \
  --tasks mmlu,gsm8k,hellaswag,truthfulqa,arc_challenge \
  --num_fewshot 5 \
  --batch_size 8 \
  --output_path results/llama2-7b-eval.json

Шаг 4: проанализируйте результаты.

Результаты сохраняются в results/llama2-7b-eval.json в формате JSON; в них содержатся метрики точности по каждой задаче, такие как mmlu acc, gsm8k exact_match и hellaswag acc_norm, каждая с показателем stderr, а также информация о конфигурации запуска.

{
  "results": {
    "mmlu": {
      "acc": 0.459,
      "acc_stderr": 0.004
    },
    "gsm8k": {
      "exact_match": 0.142,
      "exact_match_stderr": 0.006
    },
    "hellaswag": {
      "acc_norm": 0.765,
      "acc_norm_stderr": 0.004
    }
  },
  "config": {
    "model": "hf",
    "model_args": "pretrained=meta-llama/Llama-2-7b-hf",
    "num_fewshot": 5
  }
}

Рабочий процесс 2: отслеживание прогресса обучения путем оценки точек восстановления во время обучения.

Training Progress Tracking:
- [ ] Step 1: Set up periodic evaluation
- [ ] Step 2: Choose quick benchmarks
- [ ] Step 3: Automate evaluation
- [ ] Step 4: Plot learning curves

Шаг 1: настройте периодическую оценку. В скрипте типа eval_checkpoint.sh примите в качестве аргументов директорию с точкой восстановления и номер шага, затем запустите lm_eval для checkpoint-$STEP с параметрами tasks gsm8k,hellaswag, --num_fewshot 0 (режим 0-shot для ускорения), --batch_size 16 и --output_path results/step-$STEP.json; оценка выполняется каждые N шагов обучения.

#!/bin/bash
# eval_checkpoint.sh

CHECKPOINT_DIR=$1
STEP=$2

lm_eval --model hf \
  --model_args pretrained=$CHECKPOINT_DIR/checkpoint-$STEP \
  --tasks gsm8k,hellaswag \
  --num_fewshot 0 \  # 0-shot for speed
  --batch_size 16 \
  --output_path results/step-$STEP.json

Шаг 2: выберите быстрые тесты для частой оценки.

Избегайте медленных тестов для частой оценки: MMLU занимает около 2 часов (57 предметов), а HumanEval требует выполнения кода.

Быстрые варианты для частой оценки — HellaSwag (около 10 минут на 1 GPU), GSM8K (около 5 минут) и PIQA (около 2 минут).

Медленные варианты, которых следует избегать при частой оценке: MMLU занимает около 2 часов (57 предметов), а HumanEval требует выполнения кода.

Шаг 3: автоматизируйте процесс оценки.

Интегрируйте это в свой скрипт обучения, сохраняя точку восстановления каждые eval_interval шагов и запуская ./eval_checkpoint.sh checkpoints step-{step}.

# In training loop
if step % eval_interval == 0:
    model.save_pretrained(f"checkpoints/step-{step}")

    # Run evaluation
    os.system(f"./eval_checkpoint.sh checkpoints step-{step}")

В качестве альтернативы можно использовать коллбэки PyTorch Lightning: определите класс EvalHarnessCallback, который при завершении эпохи валидации сохраняет точку восстановления и запускает на ней lm_eval.

from pytorch_lightning import Callback

class EvalHarnessCallback(Callback):
    def on_validation_epoch_end(self, trainer, pl_module):
        step = trainer.global_step
        checkpoint_path = f"checkpoints/step-{step}"

        # Save checkpoint
        trainer.save_checkpoint(checkpoint_path)

        # Run lm-eval
        os.system(f"lm_eval --model hf --model_args pretrained={checkpoint_path} ...")

Шаг 4: постройте графики кривых обучения — загрузите все файлы с результатами, соберите данные о точности MMLU по каждому шагу обучения и постройте график прогресса обучения с помощью matplotlib.

import json
import matplotlib.pyplot as plt

# Load all results
steps = []
mmlu_scores = []

for file in sorted(glob.glob("results/step-*.json")):
    with open(file) as f:
        data = json.load(f)
        step = int(file.split("-")[1].split(".")[0])
        steps.append(step)
        mmlu_scores.append(data["results"]["mmlu"]["acc"])

# Plot
plt.plot(steps, mmlu_scores)
plt.xlabel("Training Step")
plt.ylabel("MMLU Accuracy")
plt.title("Training Progress")
plt.savefig("training_curve.png")

Рабочий процесс 3: сравнение нескольких моделей с использованием набора тестов для сравнения моделей.

Model Comparison:
- [ ] Step 1: Define model list
- [ ] Step 2: Run evaluations
- [ ] Step 3: Generate comparison table

Шаг 1: определите список моделей, например, в файле models.txt, где каждая строка содержит название модели из HuggingFace.

# models.txt
meta-llama/Llama-2-7b-hf
meta-llama/Llama-2-13b-hf
mistralai/Mistral-7B-v0.1
microsoft/phi-2

Шаг 2: запустите оценку с помощью скрипта типа eval_all_models.sh, который читает models.txt, преобразует каждое название модели в безопасное для файлов имя, и запускает lm_eval с параметрами tasks mmlu,gsm8k,hellaswag,truthfulqa, --num_fewshot 5, --batch_size auto и --output_path results/$model_name.json.

#!/bin/bash
# eval_all_models.sh

TASKS="mmlu,gsm8k,hellaswag,truthfulqa"

while read model; do
    echo "Evaluating $model"

    # Extract model name for output file
    model_name=$(echo $model | sed 's/\//-/g')

    lm_eval --model hf \
      --model_args pretrained=$model,dtype=bfloat16 \
      --tasks $TASKS \
      --num_fewshot 5 \
      --batch_size auto \
      --output_path results/$model_name.json

done < models.txt

Шаг 3: сгенерируйте таблицу сравнения — загрузите JSON-файлы с результатами каждой модели, возьмите основную метрику по каждой задаче (acc или exact_match) и сформируйте таблицу DataFrame с помощью библиотеки pandas, отобразив её через to_markdown.

import json
import pandas as pd

models = [
    "meta-llama-Llama-2-7b-hf",
    "meta-llama-Llama-2-13b-hf",
    "mistralai-Mistral-7B-v0.1",
    "microsoft-phi-2"
]

tasks = ["mmlu", "gsm8k", "hellaswag", "truthfulqa"]

results = []
for model in models:
    with open(f"results/{model}.json") as f:
        data = json.load(f)
        row = {"Model": model.replace("-", "/")}
        for task in tasks:
            # Get primary metric for each task
            metrics = data["results"][task]
            if "acc" in metrics:
                row[task.upper()] = f"{metrics['acc']:.3f}"
            elif "exact_match" in metrics:
                row[task.upper()] = f"{metrics['exact_match']:.3f}"
        results.append(row)

df = pd.DataFrame(results)
print(df.to_markdown(index=False))

| Model                  | MMLU  | GSM8K | HELLASWAG | TRUTHFULQA |
|------------------------|-------|-------|-----------|------------|
| meta-llama/Llama-2-7b  | 0.459 | 0.142 | 0.765     | 0.391      |
| meta-llama/Llama-2-13b | 0.549 | 0.287 | 0.801     | 0.430      |
| mistralai/Mistral-7B   | 0.626 | 0.395 | 0.812     | 0.428      |
| microsoft/phi-2        | 0.560 | 0.613 | 0.682     | 0.447      |

Рабочий процесс 4: оценка с использованием vLLM для более быстрого вывода.

vLLM Evaluation:
- [ ] Step 1: Install vLLM
- [ ] Step 2: Configure vLLM backend
- [ ] Step 3: Run evaluation

Шаг 1: установите vLLM командой pip install vllm.

pip install vllm

Шаг 2: настройте бэкенд vLLM — запустите lm_eval с параметром --model vllm и указанием model_args, например pretrained=meta-llama/Llama-2-7b-hf,tensor_parallel_size=1,dtype=auto,gpu_memory_utilization=0.8, плюс --tasks mmlu и --batch_size auto.

lm_eval --model vllm \
  --model_args pretrained=meta-llama/Llama-2-7b-hf,tensor_parallel_size=1,dtype=auto,gpu_memory_utilization=0.8 \
  --tasks mmlu \
  --batch_size auto

Шаг 3: запустите оценку. Для 7-миллиардной модели полная проверка MMLU занимает около 2 часов при использовании стандартного бэкенда HF, но всего 15–20 минут при применении vLLM, например, с параметром tensor_parallel_size=2.

# Standard HF: ~2 hours for MMLU on 7B model
lm_eval --model hf \
  --model_args pretrained=meta-llama/Llama-2-7b-hf \
  --tasks mmlu \
  --batch_size 8

# vLLM: ~15-20 minutes for MMLU on 7B model
lm_eval --model vllm \
  --model_args pretrained=meta-llama/Llama-2-7b-hf,tensor_parallel_size=2 \
  --tasks mmlu \
  --batch_size auto

Для медленных операций оценки используйте бэкенд vLLM.

Используйте бэкенд vLLM: lm_eval --model vllm с параметрами model_args, такими как pretrained=имя-модели, tensor_parallel_size=2.

lm_eval --model vllm \
  --model_args pretrained=model-name,tensor_parallel_size=2

Или уменьшите количество примеров для fewshot, например, используйте --num_fewshot 0 вместо 5.

--num_fewshot 0  # Instead of 5

Или оцените подмножество MMLU, например, используйте --tasks mmlu_stem для предметов STEM.

--tasks mmlu_stem  # Only STEM subjects

При проблемах с нехваткой памяти уменьшите размер пакета, например, установите --batch_size 1 или --batch_size auto.

--batch_size 1  # Or --batch_size auto

Или воспользуйтесь квантованием, добавив в model_args параметр load_in_8bit=True.

--model_args pretrained=model-name,load_in_8bit=True

Или включите выгрузку данных на CPU с помощью параметров model_args, таких как pretrained=имя-модели, device_map=auto, offload_folder=offload.

--model_args pretrained=model-name,device_map=auto,offload_folder=offload

Если результаты неточные, проверьте количество примеров fewshot — в большинстве статей используется режим 5-shot (--num_fewshot 5).

--num_fewshot 5  # Most papers use 5-shot

При ошибках типа "task-not-found" проверьте точное название задачи, например, используйте --tasks mmlu, а не mmlu_direct или mmlu_fewshot.

--tasks mmlu  # Not mmlu_direct or mmlu_fewshot

Убедитесь, что модель и токенизатор совпадают, например, укажите в model_args pretrained=имя-модели, tokenizer=то-же-имя-модели.

--model_args pretrained=model-name,tokenizer=same-model-name

Задачи, требующие выполнения кода (HumanEval, MBPP и др.), запускаются только после явного подтверждения — для их запуска необходимо передать --confirm_run_unsafe_code.

lm_eval --model hf \
  --model_args pretrained=model-name \
  --tasks humaneval \
  --confirm_run_unsafe_code  # Required to run tasks that execute generated code

Без этого флага lm-eval откажется запускать задачу, вместо того чтобы просто пропустить выполнение кода.

Ссылки

• references/benchmark-guide.md
• references/custom-tasks.md
• references/api-evaluation.md
• references/distributed-eval.md