lm evaluation harness
v0.4.5
Últimas noticias
hf-multimodal y vllm-vlm y la tarea mmmu como característica de prototipo . Invitamos a los usuarios a que prueben esta característica en progreso y la prueben ellos mismos, y les sugerimos que revisen lmms-eval , un proyecto maravilloso que originalmente surgió de lm-evaluación-arnés, para una gama más amplia de tareas multimodales. modelos y características.local-completions para evaluar el modelo.¡Está disponible una nueva versión v0.4.0 de lm-evaluación-arnés !
Las nuevas actualizaciones y características incluyen:
Consulte nuestras páginas de documentación actualizada en docs/ para obtener más detalles.
El desarrollo continuará en la rama main , y lo alentamos a que nos brinde comentarios sobre qué funciones desea y cómo mejorar aún más la biblioteca, o que haga preguntas, ya sea en problemas o relaciones públicas en GitHub, o en el discordia de EleutherAI.
Este proyecto proporciona un marco unificado para probar modelos de lenguaje generativo en una gran cantidad de tareas de evaluación diferentes.
Características:
El arnés de evaluación del modelo de lenguaje es el backend para ? La popular tabla de clasificación Open LLM de Hugging Face se ha utilizado en cientos de artículos y es utilizada internamente por docenas de organizaciones, incluidas NVIDIA, Cohere, BigScience, BigCode, Nous Research y Mosaic ML.
Para instalar el paquete lm-eval desde el repositorio de github, ejecute:
git clone --depth 1 https://github.com/EleutherAI/lm-evaluation-harness
cd lm-evaluation-harness
pip install -e .También proporcionamos una serie de dependencias opcionales para una funcionalidad ampliada. Una tabla detallada está disponible al final de este documento.
Aquí se proporciona una guía del usuario que detalla la lista completa de argumentos admitidos y en el terminal llamando lm_eval -h . Alternativamente, puedes usar lm-eval en lugar de lm_eval .
Se puede ver una lista de tareas admitidas (o agrupaciones de tareas) con lm-eval --tasks list . Aquí se proporcionan descripciones de las tareas y enlaces a las subcarpetas correspondientes.
transformers de cara abrazada Para evaluar un modelo alojado en HuggingFace Hub (por ejemplo, GPT-J-6B) en hellaswag puede usar el siguiente comando (esto supone que está usando una GPU compatible con CUDA):
lm_eval --model hf
--model_args pretrained=EleutherAI/gpt-j-6B
--tasks hellaswag
--device cuda:0
--batch_size 8 Se pueden proporcionar argumentos adicionales al constructor del modelo utilizando el indicador --model_args . En particular, esto respalda la práctica común de usar la función revisions en el Hub para almacenar puntos de control parcialmente entrenados o para especificar el tipo de datos para ejecutar un modelo:
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size 8 Se admiten los modelos que se cargan a través de transformers.AutoModelForCausalLM (modelos de estilo GPT autorregresivos, solo decodificador) y transformers.AutoModelForSeq2SeqLM (como modelos de codificador-decodificador como T5) en Huggingface.
La selección del tamaño del lote se puede automatizar configurando el indicador --batch_size en auto . Esto realizará la detección automática del tamaño de lote más grande que cabe en su dispositivo. En tareas en las que hay una gran diferencia entre el ejemplo más largo y el más corto, puede resultar útil volver a calcular periódicamente el tamaño de lote más grande para ganar mayor velocidad. Para hacer esto, agregue :N al indicador anterior para volver a calcular automáticamente el tamaño de lote más grande N veces. Por ejemplo, para volver a calcular el tamaño del lote 4 veces, el comando sería:
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size auto:4Nota
Así como puede proporcionar una ruta local a transformers.AutoModel , también puede proporcionar una ruta local a lm_eval a través de --model_args pretrained=/path/to/model
accelerate Hugging FaceAdmitimos tres formas principales de utilizar la biblioteca acelerada de Hugging Face para la evaluación de múltiples GPU.
Para realizar una evaluación de datos en paralelo (donde cada GPU carga una copia completa separada del modelo), aprovechamos el iniciador accelerate de la siguiente manera:
accelerate launch -m lm_eval --model hf
--tasks lambada_openai,arc_easy
--batch_size 16
(o mediante accelerate launch --no-python lm_eval ).
Para los casos en los que su modelo puede caber en una sola GPU, esto le permite evaluar en K GPU K veces más rápido que en una sola.
ADVERTENCIA : Esta configuración no funciona con la fragmentación del modelo FSDP, por lo que en accelerate config se debe desactivar FSDP o se debe usar la opción NO_SHARD FSDP.
La segunda forma de utilizar accelerate para la evaluación de múltiples GPU es cuando su modelo es demasiado grande para caber en una sola GPU.
En esta configuración, ejecute la biblioteca fuera del iniciador accelerate , pero pasando parallelize=True a --model_args de la siguiente manera:
lm_eval --model hf
--tasks lambada_openai,arc_easy
--model_args parallelize=True
--batch_size 16
Esto significa que los pesos de su modelo se dividirán entre todas las GPU disponibles.
Para usuarios más avanzados o incluso modelos más grandes, también permitimos los siguientes argumentos cuando parallelize=True :
device_map_option : Cómo dividir los pesos del modelo entre las GPU disponibles. El valor predeterminado es "automático".max_memory_per_gpu : la memoria máxima de GPU que se usará por GPU al cargar el modelo.max_cpu_memory : la cantidad máxima de memoria de la CPU que se usará al descargar los pesos del modelo a la RAM.offload_folder : una carpeta donde los pesos de los modelos se descargarán al disco si es necesario.La tercera opción es utilizar ambos al mismo tiempo. Esto le permitirá aprovechar tanto el paralelismo de datos como la fragmentación de modelos, y es especialmente útil para modelos que son demasiado grandes para caber en una sola 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
Para obtener más información sobre el paralelismo de modelos y cómo usarlo con la biblioteca accelerate , consulte la documentación de aceleración.
Advertencia: ¡No admitimos de forma nativa la evaluación de múltiples nodos utilizando el tipo de modelo hf ! Consulte nuestra integración de la biblioteca GPT-NeoX para ver un ejemplo de código en el que se escribe un script de evaluación personalizado para varias máquinas.
Nota: actualmente no admitimos evaluaciones de múltiples nodos de forma nativa y recomendamos utilizar un servidor alojado externamente para ejecutar solicitudes de inferencia o crear una integración personalizada con su marco distribuido como se hace para la biblioteca GPT-NeoX.
nemoNVIDIA NeMo Framework es un marco de IA generativa creado para investigadores y desarrolladores de pytorch que trabajan en modelos de lenguaje.
Para evaluar un modelo nemo , comience instalando NeMo siguiendo la documentación. Recomendamos encarecidamente utilizar el contenedor NVIDIA PyTorch o NeMo, especialmente si tiene problemas para instalar Apex o cualquier otra dependencia (consulte los contenedores más recientes lanzados). Instale también la biblioteca de arnés de evaluación de películas siguiendo las instrucciones de la sección Instalación.
Los modelos NeMo se pueden obtener a través del catálogo NGC de NVIDIA o en la página Hugging Face de NVIDIA. En NVIDIA NeMo Framework hay scripts de conversión para convertir los puntos de control hf de modelos populares como llama, falcon, mixtral o mpt a nemo .
Ejecute un modelo nemo en una GPU:
lm_eval --model nemo_lm
--model_args path= < path_to_nemo_model >
--tasks hellaswag
--batch_size 32 Se recomienda desembalar el modelo nemo para evitar que se descomprima dentro del contenedor acoplable, ya que puede desbordar el espacio en el disco. Para eso puedes ejecutar:
mkdir MY_MODEL
tar -xvf MY_MODEL.nemo -c MY_MODEL
nemoDe forma predeterminada, sólo se utiliza una GPU. Pero admitimos la replicación de datos o el paralelismo tensor/canalización durante la evaluación, en un nodo.
model_args de devices en la cantidad de réplicas de datos que se ejecutarán. Por ejemplo, el comando para ejecutar 8 réplicas de datos en 8 GPU es: 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 y/o pipeline_model_parallel_size . Además, también debe configurar devices para que sean iguales al producto de tensor_model_parallel_size y/o pipeline_model_parallel_size . Por ejemplo, el comando para usar un nodo de 4 GPU con paralelismo tensorial de 2 y paralelismo de canalización de 2 es: 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 Tenga en cuenta que se recomienda sustituir el comando python por torchrun --nproc-per-node=<number of devices> --no-python para facilitar la carga del modelo en las GPU. Esto es especialmente importante para puntos de control grandes cargados en varias GPU.
Aún no compatible: evaluación de múltiples nodos y combinaciones de replicación de datos con tensor o paralelismo de canalización.
vLLMTambién admitimos vLLM para una inferencia más rápida sobre los tipos de modelos admitidos, especialmente más rápido al dividir un modelo en varias GPU. Para GPU única o GPU múltiple (tensor paralelo, datos paralelos o una combinación de ambos), inferencia, por ejemplo:
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 Para usar vllm, haga pip install lm_eval[vllm] . Para obtener una lista completa de las configuraciones de vLLM compatibles, consulte nuestra integración de vLLM y la documentación de vLLM.
vLLM ocasionalmente difiere en el resultado de Huggingface. Tratamos a Huggingface como la implementación de referencia y proporcionamos un script para verificar la validez de los resultados de vllm frente a HF.
Consejo
Para obtener un rendimiento más rápido, recomendamos utilizar --batch_size auto para vLLM siempre que sea posible, para aprovechar su funcionalidad de procesamiento por lotes continuo.
Consejo
Pasar max_model_len=4096 o algún otro valor predeterminado razonable a vLLM a través de los argumentos del modelo puede provocar aceleraciones o evitar errores de falta de memoria al intentar utilizar el tamaño de lote automático, como en el caso de Mistral-7B-v0.1, que por defecto tiene una longitud máxima de 32k.
Nuestra biblioteca también admite la evaluación de modelos servidos a través de varias API comerciales, y esperamos implementar soporte para los servidores de inferencia locales/autohospedados de alto rendimiento más utilizados.
Para llamar a un modelo alojado, utilice:
export OPENAI_API_KEY=YOUR_KEY_HERE
lm_eval --model openai-completions
--model_args model=davinci
--tasks lambada_openai,hellaswagTambién admitimos el uso de su propio servidor de inferencia local con servidores que reflejan las API OpenAI Completions y 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 Tenga en cuenta que para los modelos alojados externamente, configuraciones como --device que se relacionan con dónde colocar un modelo local no deben usarse y no funcionan. Así como puedes usar --model_args para pasar argumentos arbitrarios al constructor del modelo para modelos locales, puedes usarlo para pasar argumentos arbitrarios a la API del modelo para modelos alojados. Consulte la documentación del servicio de alojamiento para obtener información sobre los argumentos que respaldan.
| API o servidor de inferencia | ¿Implementado? | --model <xxx> nombre | Modelos soportados: | Tipos de solicitud: |
|---|---|---|---|---|
| Finalizaciones de OpenAI | ✔️ | openai-completions , local-completions | Todos los modelos de API de terminaciones de OpenAI | generate_until , loglikelihood , loglikelihood_rolling |
| Finalizaciones de OpenAI Chat | ✔️ | openai-chat-completions , local-chat-completions | Todos los modelos API de ChatCompletions | generate_until (sin problemas de registro) |
| antrópico | ✔️ | anthropic | Motores antrópicos compatibles | generate_until (sin problemas de registro) |
| Chat antrópico | ✔️ | anthropic-chat , anthropic-chat-completions | Motores antrópicos compatibles | generate_until (sin problemas de registro) |
| sintetizador de texto | ✔️ | textsynth | Todos los motores compatibles | generate_until , loglikelihood , loglikelihood_rolling |
| Adherirse | ⌛ - bloqueado por error de API de Cohere | N / A | Todos los motores cohere.generate() | generate_until , loglikelihood , loglikelihood_rolling |
| Llama.cpp (a través de llama-cpp-python) | ✔️ | gguf , ggml | Todos los modelos soportados por llama.cpp | generate_until , loglikelihood , (evaluación de perplejidad aún no implementada) |
| vllm | ✔️ | vllm | La mayoría de los modelos de lenguaje causal de HF | generate_until , loglikelihood , loglikelihood_rolling |
| Tipo de serpiente venenosa | ✔️ | mamba_ssm | Modelos de lenguaje de arquitectura Mamba a través del paquete mamba_ssm | generate_until , loglikelihood , loglikelihood_rolling |
| Huggingface Optimum (LM causales) | ✔️ | openvino | Cualquier AutoModelForCausalLM solo decodificador convertido con Huggingface Optimum al formato de representación intermedia (IR) OpenVINO™ | generate_until , loglikelihood , loglikelihood_rolling |
| Neurona a través de AWS Inf2 (LM causales) | ✔️ | neuronx | Cualquier AutoModelForCausalLM solo decodificador compatible para ejecutarse en la imagen huggingface-ami para inferentia2 | generate_until , loglikelihood , loglikelihood_rolling |
| Magia neuronal profunda y escasa | ✔️ | deepsparse | Cualquier LM de SparseZoo o en HF Hub con la etiqueta "deepsparse" | generate_until , loglikelihood |
| Magia neuronal SparseML | ✔️ | sparseml | Cualquier AutoModelForCausalLM solo decodificador de SparseZoo o en HF Hub. Especialmente útil para modelos con cuantificación como zoo:llama2-7b-gsm8k_llama2_pretrain-pruned60_quantized | generate_until , loglikelihood , loglikelihood_rolling |
| ¡Tu servidor de inferencia local! | ✔️ | local-completions o local-chat-completions | Soporte para servidores compatibles con API OpenAI, con fácil personalización para otras API. | generate_until , loglikelihood , loglikelihood_rolling |
Los modelos que no proporcionan logits o logprobs se pueden usar con tareas de tipo generate_until únicamente, mientras que los modelos locales, o API que proporcionan logprobs/logits de sus mensajes, se pueden ejecutar en todos los tipos de tareas: generate_until , loglikelihood , loglikelihood_rolling y multiple_choice .
Para obtener más información sobre los diferentes output_types de tareas y tipos de solicitudes de modelo, consulte nuestra documentación.
Nota
Para obtener el mejor rendimiento con API de modelo de chat cerrado, como Anthropic Claude 3 y GPT-4, recomendamos observar detenidamente algunos resultados de muestra usando --limit 10 primero para confirmar que la extracción de respuestas y la puntuación en las tareas generativas funcionan como se esperaba. Puede ser útil proporcionar system="<some system prompt here>" dentro de --model_args para completar el chat antrópico, para indicarle al modelo en qué formato responder.
Varias otras bibliotecas contienen scripts para llamar al arnés de evaluación a través de su biblioteca. Estos incluyen GPT-NeoX, Megatron-DeepSpeed y mesh-transformer-jax.
Para crear su propia integración personalizada, puede seguir las instrucciones de este tutorial.
Nota
Para tareas que no son aptas para una evaluación directa (ya sea debido a los riesgos asociados con la ejecución de código que no es confiable o complejidades en el proceso de evaluación), el indicador --predict_only está disponible para obtener generaciones decodificadas para una evaluación post-hoc.
Si tiene una Mac compatible con Metal, puede ejecutar el arnés de evaluación usando el back-end de MPS reemplazando --device cuda:0 con --device mps (requiere PyTorch versión 2.1 o superior). Tenga en cuenta que el backend de PyTorch MPS aún se encuentra en las primeras etapas de desarrollo, por lo que pueden existir problemas de corrección u operaciones no compatibles. Si observa rarezas en el rendimiento del modelo en el back-end de MPS, le recomendamos verificar primero que un pase directo de su modelo en --device cpu y --device mps coincida.
Nota
Puede inspeccionar cómo se ven las entradas LM ejecutando el siguiente comando:
python write_out.py
--tasks < task1,task2,... >
--num_fewshot 5
--num_examples 10
--output_base_path /path/to/output/folderEsto escribirá un archivo de texto para cada tarea.
Para verificar la integridad de los datos de las tareas que estás realizando, además de ejecutar las tareas mismas, puedes usar el indicador --check_integrity :
lm_eval --model openai
--model_args engine=davinci
--tasks lambada_openai,hellaswag
--check_integrity Para los modelos cargados con la biblioteca transformers HuggingFace, cualquier argumento proporcionado a través de --model_args se pasa directamente al constructor correspondiente. Esto significa que cualquier cosa que puedas hacer con AutoModel puedes hacerlo con nuestra biblioteca. Por ejemplo, puede pasar una ruta local a través de pretrained= o usar modelos ajustados con PEFT tomando la llamada que ejecutaría para evaluar el modelo base y agregar ,peft=PATH al argumento 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:0Los modelos proporcionados como pesos delta se pueden cargar fácilmente utilizando la biblioteca de transformadores Hugging Face. Dentro de --model_args, establezca el argumento delta para especificar los pesos delta y use el argumento previamente entrenado para designar el modelo base relativo al que se aplicarán:
lm_eval --model hf
--model_args pretrained=Ejafa/llama_7B,delta=lmsys/vicuna-7b-delta-v1.1
--tasks hellaswagLos modelos cuantificados GPTQ se pueden cargar usando GPTQModel (más rápido) o AutoGPTQ
GPTQModel: agregar ,gptqmodel=True a model_args
lm_eval --model hf
--model_args pretrained=model-name-or-path,gptqmodel=True
--tasks hellaswag AutoGPTQ: agregue ,autogptq=True a model_args :
lm_eval --model hf
--model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True
--tasks hellaswag Admitimos comodines en los nombres de las tareas; por ejemplo, puede ejecutar todas las tareas lambada traducidas automáticamente a través de --task lambada_openai_mt_* .
Para guardar los resultados de la evaluación, proporcione un --output_path . También admitimos el registro de respuestas del modelo con el indicador --log_samples para análisis post-hoc.
Además, se puede proporcionar un directorio con --use_cache para almacenar en caché los resultados de ejecuciones anteriores. Esto le permite evitar la ejecución repetida de los mismos pares (modelo, tarea) para volver a puntuar.
Para enviar resultados y muestras a Hugging Face Hub, primero asegúrese de que haya un token de acceso con acceso de escritura configurado en la variable de entorno HF_TOKEN . Luego, use el indicador --hf_hub_log_args para especificar la organización, el nombre del repositorio, la visibilidad del repositorio y si se deben enviar resultados y muestras al Hub (conjunto de datos de ejemplo en HF Hub). Por ejemplo:
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 Esto le permite descargar fácilmente los resultados y muestras del Hub, usando:
from datasets import load_dataset
load_dataset ( "EleutherAI/lm-eval-results-private" , "hellaswag" , "latest" )Para obtener una lista completa de los argumentos admitidos, consulte la guía de interfaz en nuestra documentación.
Puede visualizar y analizar sin problemas los resultados de sus carreras de evaluación con el arnés utilizando Weights & Biases (W&B) y Zeno.
Puede utilizar Zeno para visualizar los resultados de sus ejecuciones de evaluación.
Primero, diríjase a hub.zenoml.com para crear una cuenta y obtener una clave API en la página de su cuenta. Agregue esta clave como variable de entorno:
export ZENO_API_KEY=[your api key] También necesitarás instalar el paquete adicional lm_eval[zeno] .
Para visualizar los resultados, ejecute el arnés de evaluación con los indicadores log_samples y output_path . Esperamos que output_path contenga varias carpetas que representen nombres de modelos individuales. De este modo, puede ejecutar su evaluación en cualquier cantidad de tareas y modelos y cargar todos los resultados como proyectos en 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 Luego, puedes cargar los datos resultantes usando el script zeno_visualize :
python scripts/zeno_visualize.py
--data_path output
--project_name " Eleuther Project " Esto utilizará todas las subcarpetas en data_path como modelos diferentes y cargará todas las tareas dentro de estas carpetas de modelos en Zeno. Si ejecuta el arnés de evaluación en varias tareas, el project_name se utilizará como prefijo y se creará un proyecto por tarea.
Puede encontrar un ejemplo de este flujo de trabajo en ejemplos/visualize-zeno.ipynb.
Con la integración de Ponderaciones y sesgos, ahora puede dedicar más tiempo a extraer información más profunda sobre los resultados de su evaluación. La integración está diseñada para agilizar el proceso de registro y visualización de resultados de experimentos utilizando la plataforma Weights & Biases (W&B).
La integración proporciona funcionalidades.
results.json como un artefacto para el control de versiones,<task_name>_eval_samples.json si las muestras están registradas, Primero necesitarás instalar el paquete adicional lm_eval[wandb]. Haga pip install lm_eval[wandb] .
Autentique su máquina con su token exclusivo de W&B. Visite https://wandb.ai/authorize para obtener uno. Inicie wandb login en su terminal de línea de comando.
Ejecute eval Harness como de costumbre con una bandera wandb_args . Utilice este indicador para proporcionar argumentos para inicializar una ejecución de wandb (wandb.init) como argumentos de cadena separados por comas.
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_samplesEn la salida estándar, encontrará el enlace a la página de ejecución de W&B, así como el enlace al informe generado. Puede encontrar un ejemplo de este flujo de trabajo en ejemplos/visualize-wandb.ipynb y un ejemplo de cómo integrarlo más allá de la CLI.
Para obtener más información sobre la biblioteca y cómo encaja todo, consulte todas nuestras páginas de documentación. Planeamos publicar pronto una hoja de ruta más amplia de las mejoras deseadas y planificadas de la biblioteca, con más información sobre cómo los contribuyentes pueden ayudar.
Para implementar una nueva tarea en el arnés de evaluación, consulte esta guía.
En general, seguimos esta lista de prioridades para abordar inquietudes sobre indicaciones y otros detalles de evaluación:
Estas son pautas y no reglas, y pueden anularse en circunstancias especiales.
Intentamos priorizar el acuerdo con los procedimientos utilizados por otros grupos para disminuir el daño cuando las personas inevitablemente comparan diferentes artículos a pesar de que desaconsejamos la práctica. Históricamente, también priorizamos la implementación de Language Models are Few Shot Learners, ya que nuestro objetivo original era específicamente comparar los resultados con ese documento.
La mejor manera de obtener soporte es abrir un problema en este repositorio o unirse al servidor EleutherAI Discord. El canal #lm-thunderdome está dedicado a desarrollar este proyecto y el canal #release-discussion es para recibir apoyo para nuestros lanzamientos. Si ha utilizado la biblioteca y ha tenido una experiencia positiva (o negativa), ¡nos encantaría saber de usted!
Las dependencias adicionales se pueden instalar mediante pip install -e ".[NAME]"
| Nombre | Usar |
|---|---|
| API | Para usar modelos API (Anthropic, OpenAI API) |
| profundo y disperso | Para ejecutar modelos DeepSparse de NM |
| desarrollador | Para eliminar relaciones públicas y contribuciones |
| gptq | Para cargar modelos con GPTQ |
| hf_transferencia | Para acelerar las descargas de archivos HF Hub |
| ifeval | Para ejecutar la tarea IFEval |
| neurona | Para ejecutar en instancias de AWS inf2 |
| tipo de serpiente venenosa | Para cargar modelos Mamba SSM |
| matemáticas | Para ejecutar la verificación de respuestas de tareas matemáticas |
| plurilingüe | Para tokenizadores multilingües |
| óptimo | Para ejecutar modelos Intel OpenVINO |
| fuente inmediata | Para utilizar indicaciones de PromptSource |
| frase | Para usar el tokenizador de oraciones |
| escaso | Para usar los modelos SparseML de NM |
| pruebas | Para ejecutar el conjunto de pruebas de la biblioteca |
| vllm | Para cargar modelos con vLLM |
| zenón | Para visualizar resultados con Zeno |
| --------------- | --------------------------------------- |
| todo | Carga todos los extras (no recomendado) |
@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}
}
