lm evaluation harness
v0.4.5
Dernières nouvelles
hf-multimodal et vllm-vlm et la tâche mmmu en tant que fonctionnalité de prototype. . Nous invitons les utilisateurs à essayer cette fonctionnalité en cours et à la tester par eux-mêmes, et leur suggérons de consulter lmms-eval , un merveilleux projet issu à l'origine du lm-evaluation-harnais, pour une gamme plus large de tâches multimodales, modèles et fonctionnalités.local-completions pour évaluer le modèle.Une nouvelle version v0.4.0 de lm-evaluation-harness est disponible !
Les nouvelles mises à jour et fonctionnalités incluent :
Veuillez consulter nos pages de documentation mises à jour dans docs/ pour plus de détails.
Le développement se poursuivra sur la branche main , et nous vous encourageons à nous faire part de vos commentaires sur les fonctionnalités souhaitées et sur la manière d'améliorer davantage la bibliothèque, ou à poser des questions, soit dans les numéros ou les PR sur GitHub, soit dans le discord EleutherAI !
Ce projet fournit un cadre unifié pour tester des modèles de langage génératifs sur un grand nombre de tâches d'évaluation différentes.
Caractéristiques:
Le harnais d'évaluation du modèle linguistique est le backend de ? Le populaire Open LLM Leaderboard de Hugging Face a été utilisé dans des centaines d'articles et est utilisé en interne par des dizaines d'organisations, notamment NVIDIA, Cohere, BigScience, BigCode, Nous Research et Mosaic ML.
Pour installer le package lm-eval à partir du référentiel github, exécutez :
git clone --depth 1 https://github.com/EleutherAI/lm-evaluation-harness
cd lm-evaluation-harness
pip install -e .Nous fournissons également un certain nombre de dépendances facultatives pour des fonctionnalités étendues. Un tableau détaillé est disponible à la fin de ce document.
Un guide de l'utilisateur détaillant la liste complète des arguments pris en charge est fourni ici, et sur le terminal en appelant lm_eval -h . Vous pouvez également utiliser lm-eval au lieu de lm_eval .
Une liste des tâches prises en charge (ou des regroupements de tâches) peut être consultée avec lm-eval --tasks list . Les descriptions des tâches et les liens vers les sous-dossiers correspondants sont fournis ici.
transformers câlins Pour évaluer un modèle hébergé sur le HuggingFace Hub (par exemple GPT-J-6B) sur hellaswag vous pouvez utiliser la commande suivante (cela suppose que vous utilisez un GPU compatible CUDA) :
lm_eval --model hf
--model_args pretrained=EleutherAI/gpt-j-6B
--tasks hellaswag
--device cuda:0
--batch_size 8 Des arguments supplémentaires peuvent être fournis au constructeur du modèle à l'aide de l'indicateur --model_args . Plus particulièrement, cela prend en charge la pratique courante consistant à utiliser la fonctionnalité revisions sur le Hub pour stocker des points de contrôle partiellement formés ou pour spécifier le type de données pour exécuter un modèle :
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size 8 Les modèles chargés via transformers.AutoModelForCausalLM (modèles de style GPT autorégressifs, décodeur uniquement) et transformers.AutoModelForSeq2SeqLM (tels que les modèles d'encodeur-décodeur comme T5) dans Huggingface sont pris en charge.
La sélection de la taille du lot peut être automatisée en définissant l'indicateur --batch_size sur auto . Cela effectuera une détection automatique de la plus grande taille de lot pouvant tenir sur votre appareil. Pour les tâches où il existe une grande différence entre l'exemple le plus long et l'exemple le plus court, il peut être utile de recalculer périodiquement la plus grande taille de lot afin d'obtenir une accélération supplémentaire. Pour ce faire, ajoutez :N à l'indicateur ci-dessus pour recalculer automatiquement N fois la plus grande taille de lot. Par exemple, pour recalculer la taille du lot 4 fois, la commande serait :
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size auto:4Note
Tout comme vous pouvez fournir un chemin local vers transformers.AutoModel , vous pouvez également fournir un chemin local vers lm_eval via --model_args pretrained=/path/to/model
accelerate Hugging FaceNous prenons en charge trois manières principales d'utiliser la bibliothèque d'accélération de Hugging Face pour l'évaluation multi-GPU.
Pour effectuer une évaluation parallèle aux données (où chaque GPU charge une copie complète distincte du modèle), nous exploitons le lanceur accelerate comme suit :
accelerate launch -m lm_eval --model hf
--tasks lambada_openai,arc_easy
--batch_size 16
(ou via accelerate launch --no-python lm_eval ).
Dans les cas où votre modèle peut tenir sur un seul GPU, cela vous permet d'évaluer sur K GPU K fois plus rapidement que sur un seul.
AVERTISSEMENT : cette configuration ne fonctionne pas avec le partitionnement de modèle FSDP, donc dans accelerate config FSDP doit être désactivé, ou l'option NO_SHARD FSDP doit être utilisée.
La deuxième façon d’utiliser accelerate pour l’évaluation multi-GPU est lorsque votre modèle est trop volumineux pour tenir sur un seul GPU.
Dans ce paramètre, exécutez la bibliothèque en dehors du lanceur accelerate , mais en passant parallelize=True à --model_args comme suit :
lm_eval --model hf
--tasks lambada_openai,arc_easy
--model_args parallelize=True
--batch_size 16
Cela signifie que les poids de votre modèle seront répartis sur tous les GPU disponibles.
Pour les utilisateurs plus avancés ou les modèles encore plus grands, nous autorisons également les arguments suivants lorsque parallelize=True :
device_map_option : Comment répartir les poids des modèles entre les GPU disponibles. la valeur par défaut est "auto".max_memory_per_gpu : la mémoire GPU maximale à utiliser par GPU pour charger le modèle.max_cpu_memory : la quantité maximale de mémoire CPU à utiliser lors du déchargement des poids du modèle vers la RAM.offload_folder : un dossier dans lequel les poids du modèle seront déchargés sur le disque si nécessaire.La troisième option consiste à utiliser les deux en même temps. Cela vous permettra de profiter à la fois du parallélisme des données et du partage de modèles, et est particulièrement utile pour les modèles trop volumineux pour tenir sur un seul 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
Pour en savoir plus sur le parallélisme des modèles et comment l'utiliser avec la bibliothèque accelerate , consultez la documentation accélérée.
Attention : nous ne prenons pas en charge nativement l'évaluation multi-nœuds à l'aide du type de modèle hf ! Veuillez vous référer à notre intégration de bibliothèque GPT-NeoX pour un exemple de code dans lequel un script d'évaluation multi-machine personnalisé est écrit.
Remarque : nous ne prenons actuellement pas en charge les évaluations multi-nœuds de manière native et vous conseillons d'utiliser soit un serveur hébergé en externe pour exécuter les requêtes d'inférence, soit de créer une intégration personnalisée avec votre infrastructure distribuée, comme c'est le cas pour la bibliothèque GPT-NeoX.
nemoNVIDIA NeMo Framework est un framework d'IA générative conçu pour les chercheurs et les développeurs pytorch travaillant sur des modèles de langage.
Pour évaluer un modèle nemo , commencez par installer NeMo en suivant la documentation. Nous recommandons fortement d'utiliser le conteneur NVIDIA PyTorch ou NeMo, surtout si vous rencontrez des problèmes pour installer Apex ou toute autre dépendance (voir les derniers conteneurs publiés). Veuillez également installer la bibliothèque de harnais d'évaluation lm en suivant les instructions de la section Installer.
Les modèles NeMo peuvent être obtenus via le catalogue NVIDIA NGC ou sur la page Hugging Face de NVIDIA. Dans NVIDIA NeMo Framework, il existe des scripts de conversion pour convertir les points de contrôle hf de modèles populaires comme lama, falcon, mixtral ou mpt en nemo .
Exécutez un modèle nemo sur un GPU :
lm_eval --model nemo_lm
--model_args path= < path_to_nemo_model >
--tasks hellaswag
--batch_size 32 Il est recommandé de décompresser le modèle nemo pour éviter le déballage à l'intérieur du conteneur Docker - cela pourrait déborder de l'espace disque. Pour cela, vous pouvez exécuter :
mkdir MY_MODEL
tar -xvf MY_MODEL.nemo -c MY_MODEL
nemoPar défaut, un seul GPU est utilisé. Mais nous prenons en charge soit la réplication des données, soit le parallélisme tenseur/pipeline lors de l'évaluation, sur un nœud.
model_args des devices sur le nombre de réplicas de données à exécuter. Par exemple, la commande pour exécuter 8 réplicas de données sur 8 GPU est : torchrun --nproc-per-node=8 --no-python lm_eval
--model nemo_lm
--model_args path= < path_to_nemo_model > ,devices=8
--tasks hellaswag
--batch_size 32model_args de tensor_model_parallel_size et/ou pipeline_model_parallel_size . De plus, vous devez également configurer devices pour qu'ils soient égaux au produit de tensor_model_parallel_size et/ou pipeline_model_parallel_size . Par exemple, la commande pour utiliser un nœud de 4 GPU avec un parallélisme tenseur de 2 et un parallélisme pipeline de 2 est : torchrun --nproc-per-node=4 --no-python lm_eval
--model nemo_lm
--model_args path= < path_to_nemo_model > ,devices=4,tensor_model_parallel_size=2,pipeline_model_parallel_size=2
--tasks hellaswag
--batch_size 32 Notez qu'il est recommandé de remplacer la commande python par torchrun --nproc-per-node=<number of devices> --no-python pour faciliter le chargement du modèle dans les GPU. Ceci est particulièrement important pour les points de contrôle volumineux chargés sur plusieurs GPU.
Pas encore pris en charge : évaluation multi-nœuds et combinaisons de réplication de données avec un parallélisme tenseur ou pipeline.
vLLMNous prenons également en charge vLLM pour une inférence plus rapide sur les types de modèles pris en charge, particulièrement plus rapide lors de la division d'un modèle sur plusieurs GPU. Pour un GPU unique ou multi-GPU – tenseur parallèle, données parallèles ou une combinaison des deux – inférence, par exemple :
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 Pour utiliser vllm, faites pip install lm_eval[vllm] . Pour une liste complète des configurations vLLM prises en charge, veuillez consulter notre intégration vLLM et la documentation vLLM.
vLLM diffère parfois en termes de sortie de Huggingface. Nous traitons Huggingface comme l'implémentation de référence et fournissons un script pour vérifier la validité des résultats vllm par rapport à HF.
Conseil
Pour des performances plus rapides, nous vous recommandons d'utiliser --batch_size auto pour vLLM autant que possible, afin de tirer parti de sa fonctionnalité de traitement par lots continu !
Conseil
Passer max_model_len=4096 ou une autre valeur par défaut raisonnable à vLLM via les arguments du modèle peut entraîner des accélérations ou empêcher des erreurs de mémoire insuffisante lorsque vous essayez d'utiliser la taille de lot automatique, comme pour Mistral-7B-v0.1 qui par défaut est une longueur maximale de 32k.
Notre bibliothèque prend également en charge l'évaluation de modèles servis via plusieurs API commerciales, et nous espérons implémenter la prise en charge des serveurs d'inférence locaux/auto-hébergés performants les plus couramment utilisés.
Pour appeler un modèle hébergé, utilisez :
export OPENAI_API_KEY=YOUR_KEY_HERE
lm_eval --model openai-completions
--model_args model=davinci
--tasks lambada_openai,hellaswagNous prenons également en charge l'utilisation de votre propre serveur d'inférence local avec des serveurs qui reflètent les API OpenAI Completions et ChatCompletions.
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 Notez que pour les modèles hébergés en externe, les configurations telles que --device qui concernent l'endroit où placer un modèle local ne doivent pas être utilisées et ne fonctionnent pas. Tout comme vous pouvez utiliser --model_args pour transmettre des arguments arbitraires au constructeur de modèle pour les modèles locaux, vous pouvez l'utiliser pour transmettre des arguments arbitraires à l'API de modèle pour les modèles hébergés. Consultez la documentation du service d'hébergement pour plus d'informations sur les arguments qu'ils prennent en charge.
| API ou serveur d'inférence | Mis en œuvre ? | --model <xxx> nom | Modèles pris en charge : | Types de demande : |
|---|---|---|---|---|
| Achèvements OpenAI | ✔️ | openai-completions , local-completions | Tous les modèles d'API OpenAI Completions | generate_until , loglikelihood , loglikelihood_rolling |
| Complétions de chat OpenAI | ✔️ | openai-chat-completions , local-chat-completions | Tous les modèles d'API ChatCompletions | generate_until (pas de problèmes de journalisation) |
| Anthropique | ✔️ | anthropic | Moteurs anthropiques pris en charge | generate_until (pas de problèmes de journalisation) |
| Discussion anthropique | ✔️ | anthropic-chat , anthropic-chat-completions | Moteurs anthropiques pris en charge | generate_until (pas de problèmes de journalisation) |
| Synthèse de texte | ✔️ | textsynth | Tous les moteurs pris en charge | generate_until , loglikelihood , loglikelihood_rolling |
| Adhérer | ⌛ - bloqué sur bug de l'API Cohere | N / A | Tous les moteurs cohere.generate() | generate_until , loglikelihood , loglikelihood_rolling |
| Lama.cpp (via lama-cpp-python) | ✔️ | gguf , ggml | Tous les modèles pris en charge par lama.cpp | generate_until , loglikelihood , (évaluation de la perplexité pas encore implémentée) |
| vLLM | ✔️ | vllm | La plupart des modèles de langage causal HF | generate_until , loglikelihood , loglikelihood_rolling |
| Mamba | ✔️ | mamba_ssm | Modèles de langage de l'architecture Mamba via le package mamba_ssm | generate_until , loglikelihood , loglikelihood_rolling |
| Huggingface Optimum (LM causales) | ✔️ | openvino | Tout AutoModelForCausalLM réservé au décodeur converti avec Huggingface Optimum au format de représentation intermédiaire (IR) OpenVINO™ | generate_until , loglikelihood , loglikelihood_rolling |
| Neurone via AWS Inf2 (LM causals) | ✔️ | neuronx | Tout AutoModelForCausalLM uniquement par décodeur pris en charge pour s'exécuter sur l'image huggingface-ami pour inferentia2 | generate_until , loglikelihood , loglikelihood_rolling |
| Magie neuronale DeepSparse | ✔️ | deepsparse | N'importe quel LM de SparseZoo ou sur HF Hub avec la balise "deepsparse" | generate_until , loglikelihood |
| Magie neuronale SparseML | ✔️ | sparseml | Tout AutoModelForCausalLM réservé au décodeur de SparseZoo ou sur HF Hub. Particulièrement utile pour les modèles avec quantification comme zoo:llama2-7b-gsm8k_llama2_pretrain-pruned60_quantized | generate_until , loglikelihood , loglikelihood_rolling |
| Votre serveur d'inférence local ! | ✔️ | local-completions ou local-chat-completions | Prise en charge des serveurs compatibles avec l'API OpenAI, avec personnalisation facile pour d'autres API. | generate_until , loglikelihood , loglikelihood_rolling |
Les modèles qui ne fournissent pas de logits ou de logprobs peuvent être utilisés avec des tâches de type generate_until uniquement, tandis que les modèles locaux, ou les API qui fournissent des logprobs/logits de leurs invites, peuvent être exécutés sur tous les types de tâches : generate_until , loglikelihood , loglikelihood_rolling et multiple_choice .
Pour plus d'informations sur les différents output_types de tâches et types de requêtes de modèle, consultez notre documentation.
Note
Pour de meilleures performances avec les API de modèle de discussion fermé telles qu'Anthropic Claude 3 et GPT-4, nous vous recommandons d'examiner attentivement quelques exemples de sorties en utilisant --limit 10 d'abord pour confirmer que l'extraction des réponses et la notation des tâches génératives fonctionnent comme prévu. fournir system="<some system prompt here>" dans --model_args pour les complétions de chat anthropique, pour indiquer au modèle dans quel format répondre, peut être utile.
Un certain nombre d'autres bibliothèques contiennent des scripts permettant d'appeler le faisceau d'évaluation via leur bibliothèque. Ceux-ci incluent GPT-NeoX, Megatron-DeepSpeed et mesh-transformer-jax.
Pour créer votre propre intégration personnalisée, vous pouvez suivre les instructions de ce didacticiel.
Note
Pour les tâches impropres à une évaluation directe – soit en raison des risques associés à l'exécution de code non fiable ou de la complexité du processus d'évaluation – l'indicateur --predict_only est disponible pour obtenir des générations décodées pour une évaluation post-hoc.
Si vous disposez d'un Mac compatible Metal, vous pouvez exécuter le harnais d'évaluation à l'aide du back-end MPS en remplaçant --device cuda:0 par --device mps (nécessite PyTorch version 2.1 ou supérieure). Notez que le backend PyTorch MPS en est encore aux premiers stades de développement, des problèmes d'exactitude ou des opérations non prises en charge peuvent donc exister. Si vous observez des bizarreries dans les performances du modèle sur le back-end MPS, nous vous recommandons d'abord de vérifier qu'un passage direct de votre modèle sur --device cpu et --device mps correspondent.
Note
Vous pouvez inspecter à quoi ressemblent les entrées LM en exécutant la commande suivante :
python write_out.py
--tasks < task1,task2,... >
--num_fewshot 5
--num_examples 10
--output_base_path /path/to/output/folderCela écrira un fichier texte pour chaque tâche.
Pour vérifier l'intégrité des données des tâches que vous effectuez en plus d'exécuter les tâches elles-mêmes, vous pouvez utiliser l'indicateur --check_integrity :
lm_eval --model openai
--model_args engine=davinci
--tasks lambada_openai,hellaswag
--check_integrity Pour les modèles chargés avec la bibliothèque transformers HuggingFace, tous les arguments fournis via --model_args sont transmis directement au constructeur concerné. Cela signifie que tout ce que vous pouvez faire avec AutoModel peut l’être avec notre bibliothèque. Par exemple, vous pouvez transmettre un chemin local via pretrained= ou utiliser des modèles affinés avec PEFT en prenant l'appel que vous exécuteriez pour évaluer le modèle de base et en ajoutant ,peft=PATH à l'argument model_args :
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:0Les modèles fournis sous forme de poids delta peuvent être facilement chargés à l'aide de la bibliothèque de transformateurs Hugging Face. Dans --model_args, définissez l'argument delta pour spécifier les poids delta et utilisez l'argument pré-entraîné pour désigner le modèle de base relatif auquel ils seront appliqués :
lm_eval --model hf
--model_args pretrained=Ejafa/llama_7B,delta=lmsys/vicuna-7b-delta-v1.1
--tasks hellaswagLes modèles quantifiés GPTQ peuvent être chargés à l'aide de GPTQModel (plus rapide) ou AutoGPTQ
GPTQModel : ajoutez ,gptqmodel=True à model_args
lm_eval --model hf
--model_args pretrained=model-name-or-path,gptqmodel=True
--tasks hellaswag AutoGPTQ : ajoutez ,autogptq=True à model_args :
lm_eval --model hf
--model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True
--tasks hellaswag Nous prenons en charge les caractères génériques dans les noms de tâches, par exemple, vous pouvez exécuter toutes les tâches lambada traduites automatiquement via --task lambada_openai_mt_* .
Pour enregistrer les résultats de l'évaluation, fournissez un --output_path . Nous prenons également en charge les réponses du modèle de journalisation avec l'indicateur --log_samples pour une analyse post-hoc.
De plus, on peut fournir un répertoire avec --use_cache pour mettre en cache les résultats des exécutions précédentes. Cela vous permet d'éviter l'exécution répétée des mêmes paires (modèle, tâche) pour une nouvelle notation.
Pour transmettre les résultats et les échantillons vers Hugging Face Hub, assurez-vous d'abord qu'un jeton d'accès avec accès en écriture est défini dans la variable d'environnement HF_TOKEN . Ensuite, utilisez l'indicateur --hf_hub_log_args pour spécifier l'organisation, le nom du référentiel, la visibilité du référentiel et s'il faut transmettre les résultats et les échantillons vers le Hub - exemple d'ensemble de données sur le HF Hub. Par exemple:
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 Cela vous permet de télécharger facilement les résultats et les échantillons depuis le Hub, en utilisant :
from datasets import load_dataset
load_dataset ( "EleutherAI/lm-eval-results-private" , "hellaswag" , "latest" )Pour une liste complète des arguments pris en charge, consultez le guide de l'interface dans notre documentation !
Vous pouvez visualiser et analyser en toute transparence les résultats de vos exécutions d'évaluation en utilisant à la fois Weights & Biases (W&B) et Zeno.
Vous pouvez utiliser Zeno pour visualiser les résultats de vos courses d'évaluation.
Tout d’abord, rendez-vous sur hub.zenoml.com pour créer un compte et obtenir une clé API sur la page de votre compte. Ajoutez cette clé en tant que variable d'environnement :
export ZENO_API_KEY=[your api key] Vous devrez également installer le package lm_eval[zeno] supplémentaire.
Pour visualiser les résultats, exécutez le harnais eval avec les indicateurs log_samples et output_path . Nous nous attendons à ce que output_path contienne plusieurs dossiers représentant des noms de modèles individuels. Vous pouvez ainsi exécuter votre évaluation sur un nombre illimité de tâches et de modèles et télécharger tous les résultats sous forme de projets sur 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 Ensuite, vous pouvez télécharger les données résultantes à l'aide du script zeno_visualize :
python scripts/zeno_visualize.py
--data_path output
--project_name " Eleuther Project " Cela utilisera tous les sous-dossiers de data_path comme différents modèles et téléchargera toutes les tâches de ces dossiers de modèles vers Zeno. Si vous exécutez le harnais d'évaluation sur plusieurs tâches, le project_name sera utilisé comme préfixe et un projet sera créé par tâche.
Vous pouvez trouver un exemple de ce flux de travail dans examples/visualize-zeno.ipynb.
Grâce à l'intégration des pondérations et des biais, vous pouvez désormais consacrer plus de temps à extraire des informations plus approfondies sur les résultats de votre évaluation. L'intégration est conçue pour rationaliser le processus d'enregistrement et de visualisation des résultats des expériences à l'aide de la plateforme Weights & Biases (W&B).
L'intégration fournit des fonctionnalités
results.json en tant qu'artefact pour le contrôle de version,<task_name>_eval_samples.json si les échantillons sont journalisés, Vous devrez d’abord installer le package lm_eval[wandb] supplémentaire. Faites pip install lm_eval[wandb] .
Authentifiez votre machine avec votre token W&B unique. Visitez https://wandb.ai/authorize pour en obtenir un. wandb login dans votre terminal de ligne de commande.
Exécutez eval Harness comme d'habitude avec un indicateur wandb_args . Utilisez cet indicateur pour fournir des arguments pour initialiser une exécution wandb (wandb.init) sous forme d'arguments de chaîne séparés par des virgules.
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_samplesDans la sortie standard, vous trouverez le lien vers la page d'exécution de W&B ainsi que le lien vers le rapport généré. Vous pouvez trouver un exemple de ce flux de travail dans examples/visualize-wandb.ipynb, ainsi qu'un exemple de la façon de l'intégrer au-delà de la CLI.
Pour plus d'informations sur la bibliothèque et comment tout s'articule, consultez toutes nos pages de documentation ! Nous prévoyons de publier prochainement une feuille de route plus large des améliorations souhaitées et prévues de la bibliothèque, avec plus d'informations sur la manière dont les contributeurs peuvent aider.
Pour implémenter une nouvelle tâche dans le harnais d'évaluation, consultez ce guide.
En général, nous suivons cette liste de priorités pour répondre aux préoccupations concernant les invites et autres détails d'évaluation :
Il s’agit de lignes directrices et non de règles, qui peuvent être annulées dans des circonstances particulières.
Nous essayons de donner la priorité à l'accord avec les procédures utilisées par d'autres groupes afin de réduire les dommages lorsque les gens comparent inévitablement les tirages entre différents journaux, malgré notre découragement de cette pratique. Historiquement, nous avons également donné la priorité à la mise en œuvre des modèles linguistiques pour peu d'apprenants, car notre objectif initial était spécifiquement de comparer les résultats avec cet article.
La meilleure façon d'obtenir de l'aide est d'ouvrir un problème sur ce dépôt ou de rejoindre le serveur EleutherAI Discord. La chaîne #lm-thunderdome est dédiée au développement de ce projet et la chaîne #release-discussion est destinée à recevoir du soutien pour nos versions. Si vous avez utilisé la bibliothèque et avez eu une expérience positive (ou négative), nous serions ravis de vous entendre !
Les dépendances supplémentaires peuvent être installées via pip install -e ".[NAME]"
| Nom | Utiliser |
|---|---|
| API | Pour utiliser des modèles d'API (Anthropic, OpenAI API) |
| profond | Pour exécuter les modèles DeepSparse de NM |
| développeur | Pour le peluchage des PR et des contributions |
| gptq | Pour charger des modèles avec GPTQ |
| hf_transfert | Pour accélérer les téléchargements de fichiers HF Hub |
| événement | Pour exécuter la tâche IFEval |
| neurone | Pour une exécution sur des instances AWS inf2 |
| mamba | Pour charger les modèles Mamba SSM |
| mathématiques | Pour exécuter la vérification des réponses aux tâches mathématiques |
| multilingue | Pour les tokeniseurs multilingues |
| optimum | Pour exécuter les modèles Intel OpenVINO |
| source d'invite | Pour utiliser les invites PromptSource |
| morceau de phrase | Pour utiliser le tokenizer de phrase |
| clairseméml | Pour utiliser les modèles SparseML de NM |
| essai | Pour exécuter la suite de tests de bibliothèque |
| vllm | Pour charger des modèles avec vLLM |
| Zénon | Pour visualiser les résultats avec Zeno |
| --------------- | --------------------------------------- |
| tous | Charge tous les extras (non recommandé) |
@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 = {A framework for few-shot language model evaluation},
month = 07,
year = 2024,
publisher = {Zenodo},
version = {v0.4.3},
doi = {10.5281/zenodo.12608602},
url = {https://zenodo.org/records/12608602}
}
