| Name | lighteval JSON |
| Version |
0.3.0
JSON |
| download |
| home_page | None |
| Summary | A lightweight and configurable evaluation package |
| upload_time | 2024-03-29 16:52:04 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.10 |
| license | MIT License |
| keywords |
evaluation
nlp
llm
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# LightEval 🌤️
A lightweight framework for LLM evaluation
## Context
LightEval is a lightweight LLM evaluation suite that Hugging Face has been using internally with the recently released LLM data processing library [datatrove](https://github.com/huggingface/datatrove) and LLM training library [nanotron](https://github.com/huggingface/nanotron).
We're releasing it with the community in the spirit of building in the open.
Note that it is still very much early so don't expect 100% stability ^^'
In case of problems or question, feel free to open an issue!
## News
- **Feb 08, 2024**: Release of `lighteval`
## Installation
Clone the repo:
```bash
git clone https://github.com/huggingface/lighteval.git
cd lighteval
```
Create a virtual environment using virtualenv or conda depending on your preferences. We require Python 3.10 or above:
```bash
conda create -n lighteval python=3.10 && conda activate lighteval
```
Install the dependencies. For the default installation, you just need:
```bash
pip install .
```
If you want to evaluate models with frameworks like `accelerate` or `peft`, you will need to specify the optional dependencies group that fits your use case (`accelerate`,`tgi`,`optimum`,`quantization`,`adapters`,`nanotron`):
```bash
pip install '.[optional1,optional2]'
```
The setup tested most is:
```bash
pip install '.[accelerate,quantization,adapters]'
```
If you want to push your results to the Hugging Face Hub, don't forget to add your access token to the environment variable `HUGGING_FACE_HUB_TOKEN`. You can do this by running:
```shell
huggingface-cli login
```
and pasting your access token.
### Optional steps
- to load and push big models/datasets, your machine likely needs Git LFS. You can install it with `sudo apt-get install git-lfs`
- If you want to run bigbench evaluations, install bigbench `pip install "bigbench@https://storage.googleapis.com/public_research_data/bigbench/bigbench-0.0.1.tar.gz"`
Lastly, if you intend to push to the code base, you'll need to install the precommit hook for styling tests:
```bash
pip install .[dev]
pre-commit install
```
## Usage
We provide two main entry points to evaluate models:
* `run_evals_accelerate.py`: evaluate models on CPU or one or more GPUs using [🤗 Accelerate](https://github.com/huggingface/accelerate).
* `run_evals_nanotron.py`: evaluate models in distributed settings using [⚡️ Nanotron](https://github.com/huggingface/nanotron).
For most users, we recommend using the 🤗 Accelerate backend - see below for specific commands.
### Evaluate a model on one or more GPUs (recommended)
To evaluate a model on one or more GPUs, first create a `multi-gpu` config by running:
```shell
accelerate config
```
You can then evaluate a model using data parallelism as follows:
```shell
accelerate launch --multi_gpu --num_processes=<num_gpus> run_evals_accelerate.py \
--model_args="pretrained=<path to model on the hub>" \
--tasks <task parameters> \
--output_dir output_dir
```
Here, `--tasks` refers to either a _comma-separated_ list of supported tasks from the [metadata table](src/lighteval/tasks/tasks_table.jsonl) in the format:
```
suite|task|num_few_shot|{0 or 1 to automatically reduce `num_few_shot` if prompt is too long}
```
or a file path like [`tasks_examples/recommended_set.txt`](./tasks_examples/recommended_set.txt) which specifies multiple task configurations. For example, to evaluate GPT-2 on the Truthful QA benchmark run:
```shell
accelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py \
--model_args "pretrained=gpt2" \
--tasks "lighteval|truthfulqa:mc|0|0" \
--override_batch_size 1 \
--output_dir="./evals/"
```
Here, `--override_batch_size` defines the _batch size per device_, so the effective batch size will be `override_batch_size x num_gpus`. To evaluate on multiple benchmarks, separate each task configuration with a comma, e.g.
```shell
accelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py \
--model_args "pretrained=gpt2" \
--tasks "leaderboard|truthfulqa:mc|0|0,leaderboard|gsm8k|0|0" \
--override_batch_size 1 \
--output_dir="./evals/"
```
See the [`tasks_examples/recommended_set.txt`](./tasks_examples/recommended_set.txt) file for a list of recommended task configurations.
### Evaluating a large model with pipeline parallelism
To evaluate models larger that ~40B parameters in 16-bit precision, you will need to shard the model across multiple GPUs to fit it in VRAM. You can do this by passing `model_parallel=True` and adapting `--num_processes` to be the number of processes to use for data parallel. For example, on a single node of 8 GPUs, you can run:
```shell
# PP=2, DP=4 - good for models < 70B params
accelerate launch --multi_gpu --num_processes=4 run_evals_accelerate.py \
--model_args="pretrained=<path to model on the hub>" \
--model_parallel \
--tasks <task parameters> \
--output_dir output_dir
# PP=4, DP=2 - good for huge models >= 70B params
accelerate launch --multi_gpu --num_processes=2 run_evals_accelerate.py \
--model_args="pretrained=<path to model on the hub>" \
--model_parallel \
--tasks <task parameters> \
--output_dir output_dir
```
### Evaluate a model on the Open LLM Leaderboard benchmarks
To evaluate a model on all the benchmarks of the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard) using a single node of 8 GPUs, run:
```shell
accelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py \
--model_args "pretrained=<model name>" \
--tasks tasks_examples/open_llm_leaderboard_tasks.txt \
--override_batch_size 1 \
--output_dir="./evals/"
```
### Evaluate a model on CPU
You can also use `lighteval` to evaluate models on CPU, although note this will typically be very slow for large models. To do so, run:
```shell
python run_evals_accelerate.py \
--model_args="pretrained=<path to model on the hub>"\
--tasks <task parameters> \
--output_dir output_dir
```
### Evaluate a model on extended, community, or custom tasks.
Independently of the default tasks provided in `lighteval` that you will find in the `tasks_table.jsonl` file, you can use `lighteval` to evaluate models on tasks that require special processing (or have been added by the community). These tasks have their own evaluation suites and are defined as follows:
* `extended`: tasks which have complex pre- or post-processing and are added by the `lighteval` maintainers. See the [`extended_tasks`](./src/lighteval/tasks/extended_tasks) folder for examples.
* `community`: tasks which have been added by the community. See the [`community_tasks`](./community_tasks) folder for examples.
* `custom`: tasks which are defined locally and not present in the core library. Use this suite if you want to experiment with designing a special metric or task.
For example, to run an extended task like ifeval, you can run:
```shell
python run_evals_accelerate.py \
--model_args "pretrained=HuggingFaceH4/zephyr-7b-beta" \
--use_chat_template \ # optional, if you want to run the evaluation with the chat template
--tasks "extended|ifeval|0|0" \
--output_dir "./evals"
```
To run a community or custom task, you can use (note the custom_tasks flag):
```shell
python run_evals_accelerate.py \
--model_args="pretrained=<path to model on the hub>"\
--tasks <task parameters> \
--custom_tasks <path to your custom or community task> \
--output_dir output_dir
```
For example, to launch `lighteval` on `arabic_mmlu:abstract_algebra` for `HuggingFaceH4/zephyr-7b-beta`, run:
```shell
python run_evals_accelerate.py \
--model_args "pretrained=HuggingFaceH4/zephyr-7b-beta" \
--use_chat_template \ # optional, if you want to run the evaluation with the chat template
--tasks "community|arabic_mmlu:abstract_algebra|5|1" \
--custom_tasks "community_tasks/arabic_evals" \
--output_dir "./evals"
```
## Deep thanks
`lighteval` was originally built on top of the great [Eleuther AI Harness](https://github.com/EleutherAI/lm-evaluation-harness) (we use the latter to power the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard)). We also took a lot of inspiration from the amazing [HELM](https://crfm.stanford.edu/helm/latest/), notably for metrics.
Through adding more and more logging functionalities, and making it compatible with increasingly different workflows and model codebases (including 3D parallelism) as well as allowing custom evaluation experiments, metrics and benchmarks, we ended up needing to change the code more and more deeply until `lighteval` became the small standalone library that it is now.
However, we are very grateful to the Harness and HELM teams for their continued work on better evaluations.
## How to navigate this project
`lighteval` is supposed to be used as a standalone evaluation library.
- To run the evaluations, you can use `run_evals_accelerate.py` or `run_evals_nanotron.py`.
- [src/lighteval](https://github.com/huggingface/lighteval/tree/main/src/lighteval) contains the core of the lib itself
- [lighteval](https://github.com/huggingface/lighteval/tree/main/src/lighteval) contains the core of the library, divided in the following section
- [main_accelerate.py](https://github.com/huggingface/lighteval/blob/main/src/lighteval/main_accelerate.py) and [main_nanotron.py](https://github.com/huggingface/lighteval/blob/main/src/lighteval/main_nanotron.py) are our entry points to run evaluation
- [logging](https://github.com/huggingface/lighteval/tree/main/src/lighteval/logging): Our loggers, to display experiment information and push it to the hub after a run
- [metrics](https://github.com/huggingface/lighteval/tree/main/src/lighteval/metrics): All the available metrics you can use. They are described in metrics, and divided between sample metrics (applied at the sample level, such as a prediction accuracy) and corpus metrics (applied over the whole corpus). You'll also find available normalisation functions.
- [models](https://github.com/huggingface/lighteval/tree/main/src/lighteval/models): Possible models to use. We cover transformers (base_model), with adapter or delta weights, as well as TGI models locally deployed (it's likely the code here is out of date though), and brrr/nanotron models.
- [tasks](https://github.com/huggingface/lighteval/tree/main/src/lighteval/tasks): Available tasks. The complete list is in `tasks_table.jsonl`, and you'll find all the prompts in `tasks_prompt_formatting.py`. Popular tasks requiring custom logic are exceptionally added in the [extended tasks](https://github.com/huggingface/lighteval/blob/main/src/lighteval/tasks/extended).
- [tasks_examples](https://github.com/huggingface/lighteval/tree/main/tasks_examples) contains a list of available tasks you can launch. We advise using tasks in the `recommended_set`, as it's possible that some of the other tasks need double checking.
- [tests](https://github.com/huggingface/lighteval/tree/main/tests) contains our test suite, that we run at each PR to prevent regressions in metrics/prompts/tasks, for a subset of important tasks.
## Customisation
If your new task or metric has requirements, add a specific `requirements.txt` file with your evaluation.
### Adding a new task
To add a new task, first either open an issue, to determine whether it will be integrated in the core evaluations of lighteval, in the extended tasks, or in the community tasks, and **add its dataset** on the hub.
- Core evaluations are evaluation which only require standard logic in their metrics and processing, and that we will add to our test suite to ensure non regression through time. They already see a high usage in the community.
- Extended evaluations are evaluations which require custom logic in their metrics (complex normalisation, an LLM as a judge, ...), that we added to facilitate the life of users. They already see a high usage in the community.
- Community evaluations are submissions by the community of new tasks.
A popular community evaluation can move to becoming an extended or core evaluation through time.
#### Core evaluations
Prompt function: **find a suitable prompt function** in `src.lighteval.tasks.task_prompt_formatting.py`, or code your own. This function must output a `Doc` object, which should contain `query`, your prompt, and either `gold`, the gold output, or `choices` and `gold_index`, the list of choices and index or indices of correct answers. If your query contains an instruction which should not be repeated in a few shot setup, add it to an `instruction` field.
Summary: create a **line summary** of your evaluation, in `src/lighteval/tasks/tasks_table.jsonl`. This summary should contain the following fields:
- `name` (str), your evaluation name
- `suite` (list), the suite(s) to which your evaluation should belong. This field allows us to compare different tasks implementation, and is used a task selection to differentiate the versions to launch. At the moment, you'll find the keywords ["helm", "bigbench", "original", "lighteval", "community", "custom"]; for core evals, please choose `lighteval`.
- `prompt_function` (str), the name of the prompt function you defined in the step above
- `hf_repo` (str), the path to your evaluation dataset on the hub
- `hf_subset` (str), the specific subset you want to use for your evaluation (note: when the dataset has no subset, fill this field with `"default"`, not with `None` or `""`)
- `hf_avail_splits` (list), all the splits available for your dataset (train, valid or validation, test, other...)
- `evaluation_splits` (list), the splits you want to use for evaluation
- `few_shots_split` (str, can be `null`), the specific split from which you want to select samples for your few-shot examples. It should be different from the sets included in `evaluation_splits`
- `few_shots_select` (str, can be `null`), the method that you will use to select items for your few-shot examples. Can be `null`, or one of:
- `balanced` selects examples from the `few_shots_split` with balanced labels, to avoid skewing the few shot examples (hence the model generations) towards one specific label
- `random` selects examples at random from the `few_shots_split`
- `random_sampling` selects new examples at random from the `few_shots_split` for every new item, but if a sampled item is equal to the current one, it is removed from the available samples
- `random_sampling_from_train` selects new examples at random from the `few_shots_split` for every new item, but if a sampled item is equal to the current one, it is kept! Only use this if you know what you are doing.
- `sequential` selects the first `n` examples of the `few_shots_split`
- `generation_size` (int), the maximum number of tokens allowed for a generative evaluation. If your evaluation is a log likelihood evaluation (multi-choice), this value should be -1
- `stop_sequence` (list), a list of strings acting as end of sentence tokens for your generation
- `metric` (list), the metrics you want to use for your evaluation (see next section for a detailed explanation)
- `output_regex` (str), A regex string that will be used to filter your generation. (Genrative metrics will only select tokens that are between the first and the second sequence matched by the regex. For example, for a regex matching `\n` and a generation `\nModel generation output\nSome other text` the metric will only be fed with `Model generation output`)
- `frozen` (bool), for now is set to False, but we will steadily pass all stable tasks to True.
- `trust_dataset` (bool), set to True if you trust the dataset.
Make sure you can launch your model with your new task using `--tasks lighteval|yournewtask|2|0`.
#### Community evaluations
Copy the `community_tasks/_template.yml` to `community_tasks/yourevalname.py` and edit it to add your custom tasks (the parameters you can use are explained above). It contains an interesting mechanism if the dataset you are adding contains a lot of subsets.
Make sure you can launch your model with your new task using `--tasks community|yournewtask|2|0 --custom_tasks community_tasks/yourevalname.py`.
### Adding a new metric
First check if you can use one of the parametrized functions in `src.lighteval.metrics.metrics_corpus` or `src.lighteval.metrics.metrics_sample`.
If not, you can use the custom_task system to register your new metric:
- create a new python file which should contain the full logic of your metric.
- the file also needs to start with these imports
```python
from aenum import extend_enum
from lighteval.metrics import Metrics
# And any other class you might need to redefine your specific metric, depending on whether it's a sample or corpus metric.
```
- and to end with the following, so that it adds your metric to our metrics list when loaded as a module.
```python
# Adds the metric to the metric list!
extend_enum(Metrics, "metric_name", metric_function)
if __name__ == "__main__":
print("Imported metric")
```
You can then give your custom metric to lighteval by using `--custom-tasks path_to_your_file` when launching it.
To see an example of a custom metric added along with a custom task, look at `tasks_examples/custom_tasks_with_custom_metrics/ifeval/ifeval.py`.
## Available metrics
### Metrics for multiple choice tasks
These metrics use log-likelihood of the different possible targets.
- `loglikelihood_acc` (Harness): Fraction of instances where the choice with the best logprob was correct - also exists in a faster version for tasks where the possible choices include only one token (`loglikelihood_acc_single_token`)
- `loglikelihood_acc_norm` (Harness): Fraction of instances where the choice with the best logprob, normalized by sequence length, was correct - also exists in a faster version for tasks where the possible choices include only one token (`loglikelihood_acc_norm_single_token`)
- `loglikelihood_acc_norm_nospace` (Harness): Fraction of instances where the choice with the best logprob, normalized by sequence length, was correct, with the first space ignored
- `loglikelihood_f1` (Harness): Corpus level F1 score of the multichoice selection - also exists in a faster version for tasks where the possible choices include only one token (`loglikelihood_f1_single_token`)
- `mcc` (Harness): Matthew's correlation coefficient (measure of agreement between statistical distributions),
- `recall_at_1` (Harness): Fraction of instances where the choice with the best logprob was correct - also exists in a faster version for tasks where the possible choices include only one token per choice (`recall_at_1_single_token`)
- `recall_at_2` (Harness): Fraction of instances where the choice with the 2nd best logprob or better was correct - also exists in a faster version for tasks where the possible choices include only one token per choice (`recall_at_2_single_token`)
- `mrr` (Harness): Mean reciprocal rank, measure of the quality of a ranking of choices ordered by correctness/relevance - also exists in a faster version for tasks where the possible choices include only one token (`mrr_single_token`)
- `target_perplexity` (Harness): Perplexity of the different choices available.
- `acc_golds_likelihood`: (Harness): A bit different, it actually checks if the average logprob of a single target is above or below 0.5
- `multi_f1_numeric`: Loglikelihood F1 score for multiple gold targets
All these metrics also exist in a "single token" version (`loglikelihood_acc_single_token`, `loglikelihood_acc_norm_single_token`, `loglikelihood_f1_single_token`, `mcc_single_token`, `recall@2_single_token` and `mrr_single_token`). When the multichoice option compare only one token (ex: "A" vs "B" vs "C" vs "D", or "yes" vs "no"), using these metrics in the single token version will divide the time spent by the number of choices. Single token evals also include:
- `multi_f1_numeric` (Harness, for CB): computes the f1 score of all possible choices and averages it.
### Metrics for perplexity and language modeling
These metrics use log-likelihood of prompt.
- `word_perplexity` (Harness): Perplexity (log probability of the input) weighted by the number of words of the sequence.
- `byte_perplexity` (Harness): Perplexity (log probability of the input) weighted by the number of bytes of the sequence.
- `bits_per_byte` (HELM): Average number of bits per byte according to model probabilities.
- `log_prob` (HELM): Predicted output's average log probability (input's log prob for language modeling).
### Metrics for generative tasks
These metrics need the model to generate an output. They are therefore slower.
- Base:
- `perfect_exact_match` (Harness): Fraction of instances where the prediction matches the gold exactly.
- `exact_match` (HELM): Fraction of instances where the prediction matches the gold at the exception of the border whitespaces (= after a `strip` has been applied to both).
- `quasi_exact_match` (HELM): Fraction of instances where the normalized prediction matches the normalized gold (normalization done on whitespace, articles, capitalization, ...). Other variations exist, with other normalizers, such as `quasi_exact_match_triviaqa`, which only normalizes the predictions after applying a strip to all sentences.
- `prefix_exact_match` (HELM): Fraction of instances where the beginning of the prediction matches the gold at the exception of the border whitespaces (= after a `strip` has been applied to both).
- `prefix_quasi_exact_match` (HELM): Fraction of instances where the normalized beginning of the prediction matches the normalized gold (normalization done on whitespace, articles, capitalization, ...)
- `exact_match_indicator`: Exact match with some preceding context (before an indicator) removed
- `f1_score_quasi` (HELM): Average F1 score in terms of word overlap between the model output and gold, with both being normalized first
- `f1_score`: Average F1 score in terms of word overlap between the model output and gold without normalisation
- `f1_score_macro`: Corpus level macro F1 score
- `f1_score_macro`: Corpus level micro F1 score
- Summarization:
- `rouge` (Harness): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/)
- `rouge1` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on 1-gram overlap.
- `rouge2` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on 2-gram overlap.
- `rougeL` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on longest common subsequence overlap.
- `rougeLsum` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on longest common subsequence overlap.
- `rouge_t5` (BigBench): Corpus level ROUGE score for all available ROUGE metrics
- `faithfulness` (HELM): Faithfulness scores based on the SummaC method of [Laban et al. (2022)](https://aclanthology.org/2022.tacl-1.10/).
- `extractiveness` (HELM): Reports, based on [(Grusky et al., 2018)](https://aclanthology.org/N18-1065/)
- `summarization_coverage`: Extent to which the model-generated summaries are extractive fragments from the source document,
- `summarization_density`: Extent to which the model-generated summaries are extractive summaries based on the source document,
- `summarization_compression`: Extent to which the model-generated summaries are compressed relative to the source document.
- `bert_score` (HELM): Reports the average BERTScore precision, recall, and f1 score [(Zhang et al., 2020)](https://openreview.net/pdf?id=SkeHuCVFDr) between model generation and gold summary.
- Translation
- `bleu`: Corpus level BLEU score [(Papineni et al., 2002)](https://aclanthology.org/P02-1040/) - uses the sacrebleu implementation.
- `bleu_1` (HELM): Average sample BLEU score [(Papineni et al., 2002)](https://aclanthology.org/P02-1040/) based on 1-gram overlap - uses the nltk implementation.
- `bleu_4` (HELM): Average sample BLEU score [(Papineni et al., 2002)](https://aclanthology.org/P02-1040/) based on 4-gram overlap - uses the nltk implementation.
- `chrf` (Harness): Character n-gram matches f-score.
- `ter` (Harness): Translation edit/error rate.
- Copyright
- `copyright` (HELM): Reports:
- `longest_common_prefix_length`: average length of longest common prefix between model generation and reference,
- `edit_distance`: average Levenshtein edit distance between model generation and reference,
- `edit_similarity`: average Levenshtein edit similarity (normalized by length of longer sequence) between model generation and reference.
- Math:
- `quasi_exact_match_math` (HELM): Fraction of instances where the normalized prediction matches the normalized gold (normalization done for math, where latex symbols, units, etc are removed)
- `quasi_exact_match_gsm8k` (Harness): Fraction of instances where the normalized prediction matches the normalized gold (normalization done for gsm8k, where latex symbols, units, etc are removed)
### Metrics for specific tasks
To keep compatibility with the Harness for some specific tasks, we ported their evaluations more or less as such. They include `drop` (for the DROP dataset) and `truthfulqa_mc_metrics` (for TruthfulQA). In general, except for tasks where the dataset has a very different formatting than usual (an other language, programming language, math, ...), we want to use standard implementations of the above metrics. It makes little sense to have 10 different versions of an exact match depending on the task. However, most of the above metrics are parametrizable so that you can change the normalization applied easily for experimental purposes.
### Not working yet
These metrics need both the generation and its logprob. They are not working at the moment, as this fn is not in the AI Harness.
- `prediction_perplexity` (HELM): Measure of the logprob of a given input.
## Examples of scripts to launch lighteval on the cluster
### Evaluate a whole suite on one node, 8 GPUs
1) Create a config file for accelerate
```yaml
compute_environment: LOCAL_MACHINE
distributed_type: MULTI_GPU
downcast_bf16: 'no'
gpu_ids: all
machine_rank: 0
main_training_function: main
mixed_precision: 'no'
num_machines: 1
num_processes: 8
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false
```
2) Create a slurm file
```bash
#!/bin/bash
#SBATCH --job-name=kirby-one-node
#SBATCH --nodes=1
#SBATCH --exclusive
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=24
#SBATCH --gres=gpu:8
#SBATCH --mem-per-cpu=11G # This is essentially 1.1T / 96
#SBATCH --partition=production-cluster
#SBATCH --mail-type=ALL
#SBATCH --mail-user=clementine@huggingface.co
set -x -e
export TMPDIR=/scratch
echo "START TIME: $(date)"
# Activate your relevant virtualenv
source <path_to_your_venv>/activate #or conda activate yourenv
cd <path_to_your_lighteval>/lighteval
export CUDA_LAUNCH_BLOCKING=1
srun accelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py --model_args "pretrained=your model name" --tasks tasks_examples/open_llm_leaderboard_tasks.txt --override_batch_size 1 --save_details --output_dir=your output dir
```
## Releases
### Building the package
```bash
pip install build
python3 -m build .
```
Raw data
{
"_id": null,
"home_page": null,
"name": "lighteval",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": "Cl\u00e9mentine Fourrier <clementine@huggingface.com>, Nathan Habib <nathan.habib@huggingface.com>",
"keywords": "evaluation, nlp, llm",
"author": null,
"author_email": "Cl\u00e9mentine Fourrier <clementine@huggingface.com>, Nathan Habib <nathan.habib@huggingface.com>, Thomas Wolf <thom@huggingface.com>",
"download_url": "https://files.pythonhosted.org/packages/02/d7/8c52ae664c106385547c5e895b8614b58eb97e1a721ccee0e278739bd0ff/lighteval-0.3.0.tar.gz",
"platform": null,
"description": "# LightEval \ud83c\udf24\ufe0f\n\nA lightweight framework for LLM evaluation\n\n## Context\nLightEval is a lightweight LLM evaluation suite that Hugging Face has been using internally with the recently released LLM data processing library [datatrove](https://github.com/huggingface/datatrove) and LLM training library [nanotron](https://github.com/huggingface/nanotron).\n\nWe're releasing it with the community in the spirit of building in the open.\n\nNote that it is still very much early so don't expect 100% stability ^^'\nIn case of problems or question, feel free to open an issue!\n\n## News\n- **Feb 08, 2024**: Release of `lighteval`\n\n## Installation\n\nClone the repo:\n\n```bash\ngit clone https://github.com/huggingface/lighteval.git\ncd lighteval\n```\n\nCreate a virtual environment using virtualenv or conda depending on your preferences. We require Python 3.10 or above:\n\n```bash\nconda create -n lighteval python=3.10 && conda activate lighteval\n```\n\nInstall the dependencies. For the default installation, you just need:\n\n```bash\npip install .\n```\n\nIf you want to evaluate models with frameworks like `accelerate` or `peft`, you will need to specify the optional dependencies group that fits your use case (`accelerate`,`tgi`,`optimum`,`quantization`,`adapters`,`nanotron`):\n\n```bash\npip install '.[optional1,optional2]'\n```\n\nThe setup tested most is:\n\n```bash\npip install '.[accelerate,quantization,adapters]'\n```\n\nIf you want to push your results to the Hugging Face Hub, don't forget to add your access token to the environment variable `HUGGING_FACE_HUB_TOKEN`. You can do this by running:\n\n```shell\nhuggingface-cli login\n```\n\nand pasting your access token.\n\n### Optional steps\n\n- to load and push big models/datasets, your machine likely needs Git LFS. You can install it with `sudo apt-get install git-lfs`\n- If you want to run bigbench evaluations, install bigbench `pip install \"bigbench@https://storage.googleapis.com/public_research_data/bigbench/bigbench-0.0.1.tar.gz\"`\n\nLastly, if you intend to push to the code base, you'll need to install the precommit hook for styling tests:\n\n```bash\npip install .[dev]\npre-commit install\n```\n\n## Usage\n\nWe provide two main entry points to evaluate models:\n\n* `run_evals_accelerate.py`: evaluate models on CPU or one or more GPUs using [\ud83e\udd17 Accelerate](https://github.com/huggingface/accelerate).\n* `run_evals_nanotron.py`: evaluate models in distributed settings using [\u26a1\ufe0f Nanotron](https://github.com/huggingface/nanotron).\n\nFor most users, we recommend using the \ud83e\udd17 Accelerate backend - see below for specific commands.\n\n### Evaluate a model on one or more GPUs (recommended)\n\nTo evaluate a model on one or more GPUs, first create a `multi-gpu` config by running:\n\n```shell\naccelerate config\n```\n\nYou can then evaluate a model using data parallelism as follows:\n\n```shell\naccelerate launch --multi_gpu --num_processes=<num_gpus> run_evals_accelerate.py \\\n --model_args=\"pretrained=<path to model on the hub>\" \\\n --tasks <task parameters> \\\n --output_dir output_dir\n```\n\nHere, `--tasks` refers to either a _comma-separated_ list of supported tasks from the [metadata table](src/lighteval/tasks/tasks_table.jsonl) in the format:\n\n```\nsuite|task|num_few_shot|{0 or 1 to automatically reduce `num_few_shot` if prompt is too long}\n```\n\nor a file path like [`tasks_examples/recommended_set.txt`](./tasks_examples/recommended_set.txt) which specifies multiple task configurations. For example, to evaluate GPT-2 on the Truthful QA benchmark run:\n\n```shell\naccelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py \\\n --model_args \"pretrained=gpt2\" \\\n --tasks \"lighteval|truthfulqa:mc|0|0\" \\\n --override_batch_size 1 \\\n --output_dir=\"./evals/\"\n```\n\nHere, `--override_batch_size` defines the _batch size per device_, so the effective batch size will be `override_batch_size x num_gpus`. To evaluate on multiple benchmarks, separate each task configuration with a comma, e.g.\n\n```shell\naccelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py \\\n --model_args \"pretrained=gpt2\" \\\n --tasks \"leaderboard|truthfulqa:mc|0|0,leaderboard|gsm8k|0|0\" \\\n --override_batch_size 1 \\\n --output_dir=\"./evals/\"\n```\n\nSee the [`tasks_examples/recommended_set.txt`](./tasks_examples/recommended_set.txt) file for a list of recommended task configurations.\n\n### Evaluating a large model with pipeline parallelism\n\nTo evaluate models larger that ~40B parameters in 16-bit precision, you will need to shard the model across multiple GPUs to fit it in VRAM. You can do this by passing `model_parallel=True` and adapting `--num_processes` to be the number of processes to use for data parallel. For example, on a single node of 8 GPUs, you can run:\n\n```shell\n# PP=2, DP=4 - good for models < 70B params\naccelerate launch --multi_gpu --num_processes=4 run_evals_accelerate.py \\\n --model_args=\"pretrained=<path to model on the hub>\" \\\n --model_parallel \\\n --tasks <task parameters> \\\n --output_dir output_dir\n\n# PP=4, DP=2 - good for huge models >= 70B params\naccelerate launch --multi_gpu --num_processes=2 run_evals_accelerate.py \\\n --model_args=\"pretrained=<path to model on the hub>\" \\\n --model_parallel \\\n --tasks <task parameters> \\\n --output_dir output_dir\n```\n\n### Evaluate a model on the Open LLM Leaderboard benchmarks\n\nTo evaluate a model on all the benchmarks of the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard) using a single node of 8 GPUs, run:\n\n```shell\naccelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py \\\n --model_args \"pretrained=<model name>\" \\\n --tasks tasks_examples/open_llm_leaderboard_tasks.txt \\\n --override_batch_size 1 \\\n --output_dir=\"./evals/\"\n```\n\n### Evaluate a model on CPU\n\nYou can also use `lighteval` to evaluate models on CPU, although note this will typically be very slow for large models. To do so, run:\n\n```shell\npython run_evals_accelerate.py \\\n --model_args=\"pretrained=<path to model on the hub>\"\\\n --tasks <task parameters> \\\n --output_dir output_dir\n```\n\n### Evaluate a model on extended, community, or custom tasks.\n\nIndependently of the default tasks provided in `lighteval` that you will find in the `tasks_table.jsonl` file, you can use `lighteval` to evaluate models on tasks that require special processing (or have been added by the community). These tasks have their own evaluation suites and are defined as follows:\n\n* `extended`: tasks which have complex pre- or post-processing and are added by the `lighteval` maintainers. See the [`extended_tasks`](./src/lighteval/tasks/extended_tasks) folder for examples.\n* `community`: tasks which have been added by the community. See the [`community_tasks`](./community_tasks) folder for examples.\n* `custom`: tasks which are defined locally and not present in the core library. Use this suite if you want to experiment with designing a special metric or task.\n\n\nFor example, to run an extended task like ifeval, you can run:\n```shell\npython run_evals_accelerate.py \\\n --model_args \"pretrained=HuggingFaceH4/zephyr-7b-beta\" \\\n --use_chat_template \\ # optional, if you want to run the evaluation with the chat template\n --tasks \"extended|ifeval|0|0\" \\\n --output_dir \"./evals\"\n```\n\nTo run a community or custom task, you can use (note the custom_tasks flag):\n\n```shell\npython run_evals_accelerate.py \\\n --model_args=\"pretrained=<path to model on the hub>\"\\\n --tasks <task parameters> \\\n --custom_tasks <path to your custom or community task> \\\n --output_dir output_dir\n```\n\nFor example, to launch `lighteval` on `arabic_mmlu:abstract_algebra` for `HuggingFaceH4/zephyr-7b-beta`, run:\n\n```shell\npython run_evals_accelerate.py \\\n --model_args \"pretrained=HuggingFaceH4/zephyr-7b-beta\" \\\n --use_chat_template \\ # optional, if you want to run the evaluation with the chat template\n --tasks \"community|arabic_mmlu:abstract_algebra|5|1\" \\\n --custom_tasks \"community_tasks/arabic_evals\" \\\n --output_dir \"./evals\"\n```\n\n\n## Deep thanks\n`lighteval` was originally built on top of the great [Eleuther AI Harness](https://github.com/EleutherAI/lm-evaluation-harness) (we use the latter to power the [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard)). We also took a lot of inspiration from the amazing [HELM](https://crfm.stanford.edu/helm/latest/), notably for metrics.\n\nThrough adding more and more logging functionalities, and making it compatible with increasingly different workflows and model codebases (including 3D parallelism) as well as allowing custom evaluation experiments, metrics and benchmarks, we ended up needing to change the code more and more deeply until `lighteval` became the small standalone library that it is now.\n\nHowever, we are very grateful to the Harness and HELM teams for their continued work on better evaluations.\n\n## How to navigate this project\n`lighteval` is supposed to be used as a standalone evaluation library.\n- To run the evaluations, you can use `run_evals_accelerate.py` or `run_evals_nanotron.py`.\n- [src/lighteval](https://github.com/huggingface/lighteval/tree/main/src/lighteval) contains the core of the lib itself\n - [lighteval](https://github.com/huggingface/lighteval/tree/main/src/lighteval) contains the core of the library, divided in the following section\n - [main_accelerate.py](https://github.com/huggingface/lighteval/blob/main/src/lighteval/main_accelerate.py) and [main_nanotron.py](https://github.com/huggingface/lighteval/blob/main/src/lighteval/main_nanotron.py) are our entry points to run evaluation\n - [logging](https://github.com/huggingface/lighteval/tree/main/src/lighteval/logging): Our loggers, to display experiment information and push it to the hub after a run\n - [metrics](https://github.com/huggingface/lighteval/tree/main/src/lighteval/metrics): All the available metrics you can use. They are described in metrics, and divided between sample metrics (applied at the sample level, such as a prediction accuracy) and corpus metrics (applied over the whole corpus). You'll also find available normalisation functions.\n - [models](https://github.com/huggingface/lighteval/tree/main/src/lighteval/models): Possible models to use. We cover transformers (base_model), with adapter or delta weights, as well as TGI models locally deployed (it's likely the code here is out of date though), and brrr/nanotron models.\n - [tasks](https://github.com/huggingface/lighteval/tree/main/src/lighteval/tasks): Available tasks. The complete list is in `tasks_table.jsonl`, and you'll find all the prompts in `tasks_prompt_formatting.py`. Popular tasks requiring custom logic are exceptionally added in the [extended tasks](https://github.com/huggingface/lighteval/blob/main/src/lighteval/tasks/extended).\n- [tasks_examples](https://github.com/huggingface/lighteval/tree/main/tasks_examples) contains a list of available tasks you can launch. We advise using tasks in the `recommended_set`, as it's possible that some of the other tasks need double checking.\n- [tests](https://github.com/huggingface/lighteval/tree/main/tests) contains our test suite, that we run at each PR to prevent regressions in metrics/prompts/tasks, for a subset of important tasks.\n\n## Customisation\nIf your new task or metric has requirements, add a specific `requirements.txt` file with your evaluation.\n\n### Adding a new task\nTo add a new task, first either open an issue, to determine whether it will be integrated in the core evaluations of lighteval, in the extended tasks, or in the community tasks, and **add its dataset** on the hub.\n\n- Core evaluations are evaluation which only require standard logic in their metrics and processing, and that we will add to our test suite to ensure non regression through time. They already see a high usage in the community.\n- Extended evaluations are evaluations which require custom logic in their metrics (complex normalisation, an LLM as a judge, ...), that we added to facilitate the life of users. They already see a high usage in the community.\n- Community evaluations are submissions by the community of new tasks.\n\nA popular community evaluation can move to becoming an extended or core evaluation through time.\n\n#### Core evaluations\nPrompt function: **find a suitable prompt function** in `src.lighteval.tasks.task_prompt_formatting.py`, or code your own. This function must output a `Doc` object, which should contain `query`, your prompt, and either `gold`, the gold output, or `choices` and `gold_index`, the list of choices and index or indices of correct answers. If your query contains an instruction which should not be repeated in a few shot setup, add it to an `instruction` field.\n\nSummary: create a **line summary** of your evaluation, in `src/lighteval/tasks/tasks_table.jsonl`. This summary should contain the following fields:\n- `name` (str), your evaluation name\n- `suite` (list), the suite(s) to which your evaluation should belong. This field allows us to compare different tasks implementation, and is used a task selection to differentiate the versions to launch. At the moment, you'll find the keywords [\"helm\", \"bigbench\", \"original\", \"lighteval\", \"community\", \"custom\"]; for core evals, please choose `lighteval`.\n- `prompt_function` (str), the name of the prompt function you defined in the step above\n- `hf_repo` (str), the path to your evaluation dataset on the hub\n- `hf_subset` (str), the specific subset you want to use for your evaluation (note: when the dataset has no subset, fill this field with `\"default\"`, not with `None` or `\"\"`)\n- `hf_avail_splits` (list), all the splits available for your dataset (train, valid or validation, test, other...)\n- `evaluation_splits` (list), the splits you want to use for evaluation\n- `few_shots_split` (str, can be `null`), the specific split from which you want to select samples for your few-shot examples. It should be different from the sets included in `evaluation_splits`\n- `few_shots_select` (str, can be `null`), the method that you will use to select items for your few-shot examples. Can be `null`, or one of:\n - `balanced` selects examples from the `few_shots_split` with balanced labels, to avoid skewing the few shot examples (hence the model generations) towards one specific label\n - `random` selects examples at random from the `few_shots_split`\n - `random_sampling` selects new examples at random from the `few_shots_split` for every new item, but if a sampled item is equal to the current one, it is removed from the available samples\n - `random_sampling_from_train` selects new examples at random from the `few_shots_split` for every new item, but if a sampled item is equal to the current one, it is kept! Only use this if you know what you are doing.\n - `sequential` selects the first `n` examples of the `few_shots_split`\n- `generation_size` (int), the maximum number of tokens allowed for a generative evaluation. If your evaluation is a log likelihood evaluation (multi-choice), this value should be -1\n- `stop_sequence` (list), a list of strings acting as end of sentence tokens for your generation\n- `metric` (list), the metrics you want to use for your evaluation (see next section for a detailed explanation)\n- `output_regex` (str), A regex string that will be used to filter your generation. (Genrative metrics will only select tokens that are between the first and the second sequence matched by the regex. For example, for a regex matching `\\n` and a generation `\\nModel generation output\\nSome other text` the metric will only be fed with `Model generation output`)\n- `frozen` (bool), for now is set to False, but we will steadily pass all stable tasks to True.\n- `trust_dataset` (bool), set to True if you trust the dataset.\n\nMake sure you can launch your model with your new task using `--tasks lighteval|yournewtask|2|0`.\n\n#### Community evaluations\nCopy the `community_tasks/_template.yml` to `community_tasks/yourevalname.py` and edit it to add your custom tasks (the parameters you can use are explained above). It contains an interesting mechanism if the dataset you are adding contains a lot of subsets.\n\nMake sure you can launch your model with your new task using `--tasks community|yournewtask|2|0 --custom_tasks community_tasks/yourevalname.py`.\n\n### Adding a new metric\nFirst check if you can use one of the parametrized functions in `src.lighteval.metrics.metrics_corpus` or `src.lighteval.metrics.metrics_sample`.\n\nIf not, you can use the custom_task system to register your new metric:\n- create a new python file which should contain the full logic of your metric.\n- the file also needs to start with these imports\n```python\nfrom aenum import extend_enum\nfrom lighteval.metrics import Metrics\n\n# And any other class you might need to redefine your specific metric, depending on whether it's a sample or corpus metric.\n```\n\n- and to end with the following, so that it adds your metric to our metrics list when loaded as a module.\n\n```python\n# Adds the metric to the metric list!\nextend_enum(Metrics, \"metric_name\", metric_function)\nif __name__ == \"__main__\":\n print(\"Imported metric\")\n```\n\nYou can then give your custom metric to lighteval by using `--custom-tasks path_to_your_file` when launching it.\n\nTo see an example of a custom metric added along with a custom task, look at `tasks_examples/custom_tasks_with_custom_metrics/ifeval/ifeval.py`.\n\n## Available metrics\n### Metrics for multiple choice tasks\nThese metrics use log-likelihood of the different possible targets.\n- `loglikelihood_acc` (Harness): Fraction of instances where the choice with the best logprob was correct - also exists in a faster version for tasks where the possible choices include only one token (`loglikelihood_acc_single_token`)\n- `loglikelihood_acc_norm` (Harness): Fraction of instances where the choice with the best logprob, normalized by sequence length, was correct - also exists in a faster version for tasks where the possible choices include only one token (`loglikelihood_acc_norm_single_token`)\n- `loglikelihood_acc_norm_nospace` (Harness): Fraction of instances where the choice with the best logprob, normalized by sequence length, was correct, with the first space ignored\n- `loglikelihood_f1` (Harness): Corpus level F1 score of the multichoice selection - also exists in a faster version for tasks where the possible choices include only one token (`loglikelihood_f1_single_token`)\n- `mcc` (Harness): Matthew's correlation coefficient (measure of agreement between statistical distributions),\n- `recall_at_1` (Harness): Fraction of instances where the choice with the best logprob was correct - also exists in a faster version for tasks where the possible choices include only one token per choice (`recall_at_1_single_token`)\n- `recall_at_2` (Harness): Fraction of instances where the choice with the 2nd best logprob or better was correct - also exists in a faster version for tasks where the possible choices include only one token per choice (`recall_at_2_single_token`)\n- `mrr` (Harness): Mean reciprocal rank, measure of the quality of a ranking of choices ordered by correctness/relevance - also exists in a faster version for tasks where the possible choices include only one token (`mrr_single_token`)\n- `target_perplexity` (Harness): Perplexity of the different choices available.\n- `acc_golds_likelihood`: (Harness): A bit different, it actually checks if the average logprob of a single target is above or below 0.5\n- `multi_f1_numeric`: Loglikelihood F1 score for multiple gold targets\n\nAll these metrics also exist in a \"single token\" version (`loglikelihood_acc_single_token`, `loglikelihood_acc_norm_single_token`, `loglikelihood_f1_single_token`, `mcc_single_token`, `recall@2_single_token` and `mrr_single_token`). When the multichoice option compare only one token (ex: \"A\" vs \"B\" vs \"C\" vs \"D\", or \"yes\" vs \"no\"), using these metrics in the single token version will divide the time spent by the number of choices. Single token evals also include:\n- `multi_f1_numeric` (Harness, for CB): computes the f1 score of all possible choices and averages it.\n\n### Metrics for perplexity and language modeling\nThese metrics use log-likelihood of prompt.\n- `word_perplexity` (Harness): Perplexity (log probability of the input) weighted by the number of words of the sequence.\n- `byte_perplexity` (Harness): Perplexity (log probability of the input) weighted by the number of bytes of the sequence.\n- `bits_per_byte` (HELM): Average number of bits per byte according to model probabilities.\n- `log_prob` (HELM): Predicted output's average log probability (input's log prob for language modeling).\n\n### Metrics for generative tasks\nThese metrics need the model to generate an output. They are therefore slower.\n- Base:\n - `perfect_exact_match` (Harness): Fraction of instances where the prediction matches the gold exactly.\n - `exact_match` (HELM): Fraction of instances where the prediction matches the gold at the exception of the border whitespaces (= after a `strip` has been applied to both).\n - `quasi_exact_match` (HELM): Fraction of instances where the normalized prediction matches the normalized gold (normalization done on whitespace, articles, capitalization, ...). Other variations exist, with other normalizers, such as `quasi_exact_match_triviaqa`, which only normalizes the predictions after applying a strip to all sentences.\n - `prefix_exact_match` (HELM): Fraction of instances where the beginning of the prediction matches the gold at the exception of the border whitespaces (= after a `strip` has been applied to both).\n - `prefix_quasi_exact_match` (HELM): Fraction of instances where the normalized beginning of the prediction matches the normalized gold (normalization done on whitespace, articles, capitalization, ...)\n - `exact_match_indicator`: Exact match with some preceding context (before an indicator) removed\n - `f1_score_quasi` (HELM): Average F1 score in terms of word overlap between the model output and gold, with both being normalized first\n - `f1_score`: Average F1 score in terms of word overlap between the model output and gold without normalisation\n - `f1_score_macro`: Corpus level macro F1 score\n - `f1_score_macro`: Corpus level micro F1 score\n- Summarization:\n - `rouge` (Harness): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/)\n - `rouge1` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on 1-gram overlap.\n - `rouge2` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on 2-gram overlap.\n - `rougeL` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on longest common subsequence overlap.\n - `rougeLsum` (HELM): Average ROUGE score [(Lin, 2004)](https://aclanthology.org/W04-1013/) based on longest common subsequence overlap.\n - `rouge_t5` (BigBench): Corpus level ROUGE score for all available ROUGE metrics\n - `faithfulness` (HELM): Faithfulness scores based on the SummaC method of [Laban et al. (2022)](https://aclanthology.org/2022.tacl-1.10/).\n - `extractiveness` (HELM): Reports, based on [(Grusky et al., 2018)](https://aclanthology.org/N18-1065/)\n - `summarization_coverage`: Extent to which the model-generated summaries are extractive fragments from the source document,\n - `summarization_density`: Extent to which the model-generated summaries are extractive summaries based on the source document,\n - `summarization_compression`: Extent to which the model-generated summaries are compressed relative to the source document.\n - `bert_score` (HELM): Reports the average BERTScore precision, recall, and f1 score [(Zhang et al., 2020)](https://openreview.net/pdf?id=SkeHuCVFDr) between model generation and gold summary.\n- Translation\n - `bleu`: Corpus level BLEU score [(Papineni et al., 2002)](https://aclanthology.org/P02-1040/) - uses the sacrebleu implementation.\n - `bleu_1` (HELM): Average sample BLEU score [(Papineni et al., 2002)](https://aclanthology.org/P02-1040/) based on 1-gram overlap - uses the nltk implementation.\n - `bleu_4` (HELM): Average sample BLEU score [(Papineni et al., 2002)](https://aclanthology.org/P02-1040/) based on 4-gram overlap - uses the nltk implementation.\n - `chrf` (Harness): Character n-gram matches f-score.\n - `ter` (Harness): Translation edit/error rate.\n- Copyright\n - `copyright` (HELM): Reports:\n - `longest_common_prefix_length`: average length of longest common prefix between model generation and reference,\n - `edit_distance`: average Levenshtein edit distance between model generation and reference,\n - `edit_similarity`: average Levenshtein edit similarity (normalized by length of longer sequence) between model generation and reference.\n- Math:\n - `quasi_exact_match_math` (HELM): Fraction of instances where the normalized prediction matches the normalized gold (normalization done for math, where latex symbols, units, etc are removed)\n - `quasi_exact_match_gsm8k` (Harness): Fraction of instances where the normalized prediction matches the normalized gold (normalization done for gsm8k, where latex symbols, units, etc are removed)\n\n### Metrics for specific tasks\nTo keep compatibility with the Harness for some specific tasks, we ported their evaluations more or less as such. They include `drop` (for the DROP dataset) and `truthfulqa_mc_metrics` (for TruthfulQA). In general, except for tasks where the dataset has a very different formatting than usual (an other language, programming language, math, ...), we want to use standard implementations of the above metrics. It makes little sense to have 10 different versions of an exact match depending on the task. However, most of the above metrics are parametrizable so that you can change the normalization applied easily for experimental purposes.\n\n### Not working yet\nThese metrics need both the generation and its logprob. They are not working at the moment, as this fn is not in the AI Harness.\n- `prediction_perplexity` (HELM): Measure of the logprob of a given input.\n\n## Examples of scripts to launch lighteval on the cluster\n### Evaluate a whole suite on one node, 8 GPUs\n1) Create a config file for accelerate\n\n```yaml\ncompute_environment: LOCAL_MACHINE\ndistributed_type: MULTI_GPU\ndowncast_bf16: 'no'\ngpu_ids: all\nmachine_rank: 0\nmain_training_function: main\nmixed_precision: 'no'\nnum_machines: 1\nnum_processes: 8\nrdzv_backend: static\nsame_network: true\ntpu_env: []\ntpu_use_cluster: false\ntpu_use_sudo: false\nuse_cpu: false\n```\n\n2) Create a slurm file\n\n```bash\n#!/bin/bash\n#SBATCH --job-name=kirby-one-node\n#SBATCH --nodes=1\n#SBATCH --exclusive\n#SBATCH --ntasks-per-node=1\n#SBATCH --cpus-per-task=24\n#SBATCH --gres=gpu:8\n#SBATCH --mem-per-cpu=11G # This is essentially 1.1T / 96\n#SBATCH --partition=production-cluster\n#SBATCH --mail-type=ALL\n#SBATCH --mail-user=clementine@huggingface.co\n\nset -x -e\nexport TMPDIR=/scratch\n\necho \"START TIME: $(date)\"\n\n# Activate your relevant virtualenv\nsource <path_to_your_venv>/activate #or conda activate yourenv\n\ncd <path_to_your_lighteval>/lighteval\n\nexport CUDA_LAUNCH_BLOCKING=1\nsrun accelerate launch --multi_gpu --num_processes=8 run_evals_accelerate.py --model_args \"pretrained=your model name\" --tasks tasks_examples/open_llm_leaderboard_tasks.txt --override_batch_size 1 --save_details --output_dir=your output dir\n```\n\n## Releases\n\n### Building the package\n```bash\npip install build\npython3 -m build .\n```\n",
"bugtrack_url": null,
"license": "MIT License",
"summary": "A lightweight and configurable evaluation package",
"version": "0.3.0",
"project_urls": {
"Homepage": "https://github.com/huggingface/lighteval",
"Issues": "https://github.com/huggingface/lighteval/issues"
},
"split_keywords": [
"evaluation",
" nlp",
" llm"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "f5e733f933d80fe537dacdf2677df18437ba8b90e6228936564dd246c295809a",
"md5": "bcce1e59b3249d2cd8906eedae1fd2da",
"sha256": "634f85aaface0bba969ee7105098838dc93bed9eca0ad45f88812ccf17779999"
},
"downloads": -1,
"filename": "lighteval-0.3.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "bcce1e59b3249d2cd8906eedae1fd2da",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 227379,
"upload_time": "2024-03-29T16:52:00",
"upload_time_iso_8601": "2024-03-29T16:52:00.662486Z",
"url": "https://files.pythonhosted.org/packages/f5/e7/33f933d80fe537dacdf2677df18437ba8b90e6228936564dd246c295809a/lighteval-0.3.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "02d78c52ae664c106385547c5e895b8614b58eb97e1a721ccee0e278739bd0ff",
"md5": "997366c82e63abd230e0bc613face69f",
"sha256": "30d05265a5dc4fa5a8397a83aa28b13a0f75cf551d365bf754a982cb25639109"
},
"downloads": -1,
"filename": "lighteval-0.3.0.tar.gz",
"has_sig": false,
"md5_digest": "997366c82e63abd230e0bc613face69f",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 200003,
"upload_time": "2024-03-29T16:52:04",
"upload_time_iso_8601": "2024-03-29T16:52:04.461962Z",
"url": "https://files.pythonhosted.org/packages/02/d7/8c52ae664c106385547c5e895b8614b58eb97e1a721ccee0e278739bd0ff/lighteval-0.3.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-03-29 16:52:04",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "huggingface",
"github_project": "lighteval",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"lcname": "lighteval"
}
