lm evaluation harness
v0.4.5
Últimas Notícias
hf-multimodal e vllm-vlm e a tarefa mmmu como um recurso de protótipo . Convidamos os usuários a experimentar esse recurso em andamento e testá-lo por si mesmos, e sugerimos que verifiquem lmms-eval , um projeto maravilhoso originalmente derivado do chicote de avaliação lm, para uma gama mais ampla de tarefas multimodais, modelos e recursos.local-completions para avaliar o modelo.Uma nova versão v0.4.0 do lm-evaluation-harness está disponível !
Novas atualizações e recursos incluem:
Consulte nossas páginas de documentação atualizadas em docs/ para obter mais detalhes.
O desenvolvimento continuará no branch main , e encorajamos você a nos dar feedback sobre quais recursos são desejados e como melhorar ainda mais a biblioteca, ou fazer perguntas, seja em problemas ou PRs no GitHub, ou na discórdia EleutherAI!
Este projeto fornece uma estrutura unificada para testar modelos de linguagem generativos em um grande número de tarefas de avaliação diferentes.
Características:
O equipamento de avaliação de modelo de linguagem é o back-end para? O popular Open LLM Leaderboard da Hugging Face tem sido usado em centenas de artigos e é usado internamente por dezenas de organizações, incluindo NVIDIA, Cohere, BigScience, BigCode, Nous Research e Mosaic ML.
Para instalar o pacote lm-eval do repositório github, execute:
git clone --depth 1 https://github.com/EleutherAI/lm-evaluation-harness
cd lm-evaluation-harness
pip install -e .Também fornecemos uma série de dependências opcionais para funcionalidade estendida. Uma tabela detalhada está disponível no final deste documento.
Um guia do usuário detalhando a lista completa de argumentos suportados é fornecido aqui e no terminal chamando lm_eval -h . Alternativamente, você pode usar lm-eval em vez de lm_eval .
Uma lista de tarefas suportadas (ou agrupamentos de tarefas) pode ser visualizada com lm-eval --tasks list . Descrições de tarefas e links para subpastas correspondentes são fornecidos aqui.
transformers de rosto Para avaliar um modelo hospedado no HuggingFace Hub (por exemplo, GPT-J-6B) no hellaswag você pode usar o seguinte comando (isso pressupõe que você esteja usando uma GPU compatível com CUDA):
lm_eval --model hf
--model_args pretrained=EleutherAI/gpt-j-6B
--tasks hellaswag
--device cuda:0
--batch_size 8 Argumentos adicionais podem ser fornecidos ao construtor do modelo usando o sinalizador --model_args . Mais notavelmente, isso apoia a prática comum de usar o recurso revisions no Hub para armazenar pontos de verificação parcialmente treinados ou para especificar o tipo de dados para executar um 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 Modelos carregados por meio de transformers.AutoModelForCausalLM (modelos de estilo GPT autoregressivos e somente decodificador) e transformers.AutoModelForSeq2SeqLM (como modelos de codificador-decodificador como T5) em Huggingface são suportados.
A seleção do tamanho do lote pode ser automatizada definindo o sinalizador --batch_size como auto . Isso realizará a detecção automática do maior tamanho de lote que caberá no seu dispositivo. Em tarefas onde há uma grande diferença entre o exemplo mais longo e o mais curto, pode ser útil recalcular periodicamente o maior tamanho de lote, para ganhar ainda mais velocidade. Para fazer isso, anexe :N ao sinalizador acima para recalcular automaticamente o maior tamanho de lote N vezes. Por exemplo, para recalcular o tamanho do lote 4 vezes, o comando seria:
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size auto:4Observação
Assim como você pode fornecer um caminho local para transformers.AutoModel , você também pode fornecer um caminho local para lm_eval via --model_args pretrained=/path/to/model
accelerate Hugging FaceOferecemos suporte a três maneiras principais de usar a biblioteca acelerada do Hugging Face para avaliação multi-GPU.
Para realizar a avaliação paralela de dados (onde cada GPU carrega uma cópia completa separada do modelo), aproveitamos o iniciador accelerate da seguinte forma:
accelerate launch -m lm_eval --model hf
--tasks lambada_openai,arc_easy
--batch_size 16
(ou via accelerate launch --no-python lm_eval ).
Para casos em que seu modelo cabe em uma única GPU, isso permite avaliar em K GPUs K vezes mais rápido do que em uma.
AVISO : Esta configuração não funciona com fragmentação de modelo FSDP, portanto, na accelerate config , o FSDP deve ser desabilitado ou a opção NO_SHARD FSDP deve ser usada.
A segunda maneira de usar accelerate para avaliação multi-GPU é quando seu modelo é muito grande para caber em uma única GPU.
Nesta configuração, execute a biblioteca fora do accelerate launcher , mas passando parallelize=True para --model_args da seguinte forma:
lm_eval --model hf
--tasks lambada_openai,arc_easy
--model_args parallelize=True
--batch_size 16
Isso significa que os pesos do seu modelo serão divididos entre todas as GPUs disponíveis.
Para usuários mais avançados ou modelos ainda maiores, também permitimos os seguintes argumentos quando parallelize=True :
device_map_option : como dividir os pesos do modelo entre GPUs disponíveis. o padrão é "automático".max_memory_per_gpu : a memória máxima da GPU a ser usada por GPU no carregamento do modelo.max_cpu_memory : a quantidade máxima de memória da CPU a ser usada ao descarregar os pesos do modelo para a RAM.offload_folder : uma pasta onde os pesos do modelo serão descarregados para o disco, se necessário.A terceira opção é usar os dois ao mesmo tempo. Isso permitirá que você aproveite o paralelismo de dados e a fragmentação de modelo e é especialmente útil para modelos que são grandes demais para caber em uma única 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 saber mais sobre o paralelismo de modelos e como usá-lo com a biblioteca accelerate , consulte a documentação do acelerador.
Aviso: não oferecemos suporte nativo à avaliação de vários nós usando o tipo de modelo hf ! Consulte nossa integração da biblioteca GPT-NeoX para obter um exemplo de código no qual um script de avaliação personalizado de várias máquinas é escrito.
Observação: atualmente não oferecemos suporte nativo a avaliações de vários nós e recomendamos o uso de um servidor hospedado externamente para executar solicitações de inferência ou a criação de uma integração personalizada com sua estrutura distribuída, como é feito para a biblioteca GPT-NeoX.
nemoNVIDIA NeMo Framework é uma estrutura de IA generativa desenvolvida para pesquisadores e desenvolvedores de pytorch que trabalham em modelos de linguagem.
Para avaliar um modelo nemo , comece instalando o NeMo seguindo a documentação. É altamente recomendável usar o contêiner NVIDIA PyTorch ou NeMo, especialmente se tiver problemas para instalar o Apex ou qualquer outra dependência (consulte os contêineres lançados mais recentemente). Instale também a biblioteca de chicote de avaliação lm seguindo as instruções na seção Instalação.
Os modelos NeMo podem ser obtidos através do Catálogo NVIDIA NGC ou na página Hugging Face da NVIDIA. No NVIDIA NeMo Framework existem scripts de conversão para converter os pontos de verificação hf de modelos populares como lhama, falcon, mixtral ou mpt para nemo .
Execute um modelo nemo em uma GPU:
lm_eval --model nemo_lm
--model_args path= < path_to_nemo_model >
--tasks hellaswag
--batch_size 32 Recomenda-se descompactar o modelo nemo para evitar descompactá-lo dentro do contêiner docker - pode estourar o espaço em disco. Para isso você pode executar:
mkdir MY_MODEL
tar -xvf MY_MODEL.nemo -c MY_MODEL
nemoPor padrão, apenas uma GPU é usada. Mas oferecemos suporte à replicação de dados ou ao paralelismo de tensor/pipeline durante a avaliação, em um nó.
model_args de devices como o número de réplicas de dados a serem executadas. Por exemplo, o comando para executar 8 réplicas de dados em 8 GPUs é: 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 e/ou pipeline_model_parallel_size . Além disso, você também deve configurar devices para serem iguais ao produto de tensor_model_parallel_size e/ou pipeline_model_parallel_size . Por exemplo, o comando para usar um nó de 4 GPUs com paralelismo de tensor de 2 e paralelismo de pipeline de 2 é: 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 Observe que é recomendado substituir o comando python por torchrun --nproc-per-node=<number of devices> --no-python para facilitar o carregamento do modelo nas GPUs. Isto é especialmente importante para grandes pontos de verificação carregados em múltiplas GPUs.
Ainda não suportado: avaliação de vários nós e combinações de replicação de dados com paralelismo de tensor ou pipeline.
vLLMTambém oferecemos suporte a vLLM para inferência mais rápida em tipos de modelos suportados, especialmente mais rápido ao dividir um modelo em várias GPUs. Para GPU única ou multi-GPU — paralelo de tensor, paralelo de dados ou uma combinação de ambos — inferência, por exemplo:
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, faça pip install lm_eval[vllm] . Para obter uma lista completa de configurações de vLLM suportadas, consulte nossa integração de vLLM e a documentação do vLLM.
O vLLM ocasionalmente difere na saída do Huggingface. Tratamos Huggingface como implementação de referência e fornecemos um script para verificar a validade dos resultados do vllm em relação ao HF.
Dica
Para um desempenho mais rápido, recomendamos usar --batch_size auto para vLLM sempre que possível, para aproveitar sua funcionalidade de lote contínuo!
Dica
Passar max_model_len=4096 ou algum outro padrão razoável para vLLM por meio de argumentos de modelo pode causar acelerações ou evitar erros de falta de memória ao tentar usar o tamanho automático do lote, como para Mistral-7B-v0.1, cujo padrão é um comprimento máximo de 32k.
Nossa biblioteca também oferece suporte à avaliação de modelos servidos por meio de diversas APIs comerciais, e esperamos implementar suporte para os servidores de inferência locais/auto-hospedados de desempenho mais comumente usados.
Para chamar um modelo hospedado, use:
export OPENAI_API_KEY=YOUR_KEY_HERE
lm_eval --model openai-completions
--model_args model=davinci
--tasks lambada_openai,hellaswagTambém oferecemos suporte ao uso de seu próprio servidor de inferência local com servidores que espelham as APIs OpenAI Completions e 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 Observe que para modelos hospedados externamente, configurações como --device relacionadas a onde colocar um modelo local não devem ser usadas e não funcionam. Assim como você pode usar --model_args para passar argumentos arbitrários para o construtor do modelo para modelos locais, você pode usá-lo para passar argumentos arbitrários para a API do modelo para modelos hospedados. Consulte a documentação do serviço de hospedagem para obter informações sobre quais argumentos eles suportam.
| API ou servidor de inferência | Implementado? | --model <xxx> nome | Modelos suportados: | Tipos de solicitação: |
|---|---|---|---|---|
| Conclusões OpenAI | ✔️ | openai-completions , local-completions | Todos os modelos de API de conclusão OpenAI | generate_until , loglikelihood , loglikelihood_rolling |
| Conclusões do OpenAI Chat | ✔️ | openai-chat-completions , local-chat-completions | Todos os modelos da API ChatCompletions | generate_until (sem logprobs) |
| Antrópico | ✔️ | anthropic | Motores Antrópicos Suportados | generate_until (sem logprobs) |
| Bate-papo Antrópico | ✔️ | anthropic-chat , anthropic-chat-completions | Motores Antrópicos Suportados | generate_until (sem logprobs) |
| Sintetizador de texto | ✔️ | textsynth | Todos os motores suportados | generate_until , loglikelihood , loglikelihood_rolling |
| Coerente | ⌛ - bloqueado no bug da API Cohere | N / D | Todos os motores cohere.generate() | generate_until , loglikelihood , loglikelihood_rolling |
| Lhama.cpp (via lhama-cpp-python) | ✔️ | gguf , ggml | Todos os modelos suportados por llama.cpp | generate_until , loglikelihood , (avaliação de perplexidade ainda não implementada) |
| vLLM | ✔️ | vllm | A maioria dos modelos de linguagem causal HF | generate_until , loglikelihood , loglikelihood_rolling |
| Mamba | ✔️ | mamba_ssm | Modelos de linguagem da arquitetura Mamba por meio do pacote mamba_ssm | generate_until , loglikelihood , loglikelihood_rolling |
| Huggingface ideal (LMs causais) | ✔️ | openvino | Qualquer AutoModelForCausalLM somente decodificador convertido com Huggingface Optimum no formato OpenVINO™ Intermediate Representation (IR) | generate_until , loglikelihood , loglikelihood_rolling |
| Neurônio via AWS Inf2 (LMs causais) | ✔️ | neuronx | Qualquer AutoModelForCausalLM somente decodificador com suporte para execução na imagem huggingface-ami para inferentia2 | generate_until , loglikelihood , loglikelihood_rolling |
| Neural Magic DeepSparse | ✔️ | deepsparse | Qualquer LM do SparseZoo ou no HF Hub com a tag "deepsparse" | generate_until , loglikelihood |
| Neural Magic SparseML | ✔️ | sparseml | Qualquer AutoModelForCausalLM somente decodificador do SparseZoo ou no HF Hub. Especialmente útil para modelos com quantização como zoo:llama2-7b-gsm8k_llama2_pretrain-pruned60_quantized | generate_until , loglikelihood , loglikelihood_rolling |
| Seu servidor de inferência local! | ✔️ | local-completions ou local-chat-completions | Suporte para servidores compatíveis com OpenAI API, com fácil customização para outras APIs. | generate_until , loglikelihood , loglikelihood_rolling |
Modelos que não fornecem logits ou logprobs podem ser usados apenas com tarefas do tipo generate_until , enquanto modelos locais, ou APIs que fornecem logprobs/logits de seus prompts, podem ser executados em todos os tipos de tarefas: generate_until , loglikelihood , loglikelihood_rolling e multiple_choice .
Para obter mais informações sobre os diferentes output_types de tarefas e tipos de solicitação de modelo, consulte nossa documentação.
Observação
Para obter melhor desempenho com APIs de modelo de chat fechado, como Anthropic Claude 3 e GPT-4, recomendamos observar cuidadosamente alguns resultados de amostra usando --limit 10 primeiro para confirmar que a extração de respostas e a pontuação em tarefas generativas estão funcionando conforme o esperado. fornecer system="<some system prompt here>" dentro de --model_args para anthropic-chat-completions, para instruir o modelo em qual formato responder, pode ser útil.
Várias outras bibliotecas contêm scripts para chamar o equipamento de avaliação por meio de sua biblioteca. Isso inclui GPT-NeoX, Megatron-DeepSpeed e mesh-transformer-jax.
Para criar sua própria integração personalizada, você pode seguir as instruções deste tutorial.
Observação
Para tarefas inadequadas para avaliação direta - devido aos riscos associados à execução de código não confiável ou complexidades no processo de avaliação - o sinalizador --predict_only está disponível para obter gerações decodificadas para avaliação post-hoc.
Se você tiver um Mac compatível com Metal, poderá executar o chicote de avaliação usando o back-end do MPS, substituindo --device cuda:0 por --device mps (requer PyTorch versão 2.1 ou superior). Observe que o backend PyTorch MPS ainda está em estágios iniciais de desenvolvimento, portanto, podem existir problemas de correção ou operações não suportadas. Se você observar estranhezas no desempenho do modelo no back-end do MPS, recomendamos primeiro verificar se uma passagem direta do seu modelo em --device cpu e --device mps corresponde.
Observação
Você pode inspecionar a aparência das entradas LM executando o seguinte comando:
python write_out.py
--tasks < task1,task2,... >
--num_fewshot 5
--num_examples 10
--output_base_path /path/to/output/folderIsso gravará um arquivo de texto para cada tarefa.
Para verificar a integridade dos dados das tarefas que você está executando, além de executar as próprias tarefas, você pode usar o sinalizador --check_integrity :
lm_eval --model openai
--model_args engine=davinci
--tasks lambada_openai,hellaswag
--check_integrity Para modelos carregados com a biblioteca transformers HuggingFace, quaisquer argumentos fornecidos via --model_args são passados diretamente para o construtor relevante. Isso significa que tudo o que você pode fazer com AutoModel pode ser feito com nossa biblioteca. Por exemplo, você pode passar um caminho local via pretrained= ou usar modelos ajustados com PEFT fazendo a chamada que você executaria para avaliar o modelo base e adicionar ,peft=PATH ao 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:0Os modelos fornecidos como pesos delta podem ser facilmente carregados usando a biblioteca de transformadores Hugging Face. Dentro de --model_args, defina o argumento delta para especificar os pesos delta e use o argumento pré-treinado para designar o modelo base relativo ao qual eles serão aplicados:
lm_eval --model hf
--model_args pretrained=Ejafa/llama_7B,delta=lmsys/vicuna-7b-delta-v1.1
--tasks hellaswagOs modelos quantizados GPTQ podem ser carregados usando GPTQModel (mais rápido) ou AutoGPTQ
GPTQModel: adicione ,gptqmodel=True a model_args
lm_eval --model hf
--model_args pretrained=model-name-or-path,gptqmodel=True
--tasks hellaswag AutoGPTQ: adicione ,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 Oferecemos suporte a curingas em nomes de tarefas, por exemplo, você pode executar todas as tarefas lambada traduzidas automaticamente por meio de --task lambada_openai_mt_* .
Para salvar os resultados da avaliação, forneça um --output_path . Também oferecemos suporte ao registro de respostas do modelo com o sinalizador --log_samples para análise post-hoc.
Além disso, pode-se fornecer um diretório com --use_cache para armazenar em cache os resultados de execuções anteriores. Isso permite evitar a execução repetida dos mesmos pares (modelo, tarefa) para nova pontuação.
Para enviar resultados e amostras para o Hugging Face Hub, primeiro certifique-se de que um token de acesso com acesso de gravação esteja definido na variável de ambiente HF_TOKEN . Em seguida, use o sinalizador --hf_hub_log_args para especificar a organização, o nome do repositório, a visibilidade do repositório e se deseja enviar resultados e amostras para o conjunto de dados de exemplo do Hub no HF Hub. Por exemplo:
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 Isso permite que você baixe facilmente os resultados e amostras do Hub, usando:
from datasets import load_dataset
load_dataset ( "EleutherAI/lm-eval-results-private" , "hellaswag" , "latest" )Para uma lista completa de argumentos suportados, confira o guia de interface em nossa documentação!
Você pode visualizar e analisar perfeitamente os resultados de suas execuções de avaliação usando Pesos e preconceitos (W&B) e Zeno.
Você pode usar o Zeno para visualizar os resultados de suas execuções de avaliação.
Primeiro, acesse hub.zenoml.com para criar uma conta e obter uma chave API na página da sua conta. Adicione esta chave como uma variável de ambiente:
export ZENO_API_KEY=[your api key] Você também precisará instalar o pacote lm_eval[zeno] extra.
Para visualizar os resultados, execute o chicote de avaliação com os sinalizadores log_samples e output_path . Esperamos que output_path contenha várias pastas que representam nomes de modelos individuais. Assim, você pode executar sua avaliação em qualquer número de tarefas e modelos e carregar todos os resultados como projetos no 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 Então, você pode fazer upload dos dados resultantes usando o script zeno_visualize :
python scripts/zeno_visualize.py
--data_path output
--project_name " Eleuther Project " Isso usará todas as subpastas em data_path como modelos diferentes e fará upload de todas as tarefas dentro dessas pastas de modelos para o Zeno. Se você executar o equipamento de avaliação em várias tarefas, o project_name será usado como prefixo e um projeto será criado por tarefa.
Você pode encontrar um exemplo desse fluxo de trabalho em exemplos/visualize-zeno.ipynb.
Com a integração de pesos e preconceitos, agora você pode gastar mais tempo extraindo insights mais profundos sobre os resultados de sua avaliação. A integração foi projetada para agilizar o processo de registro e visualização de resultados de experimentos usando a plataforma Weights & Biases (W&B).
A integração fornece funcionalidades
results.json como um artefato para controle de versão,<task_name>_eval_samples.json se as amostras forem registradas, Primeiro você precisará instalar o pacote extra lm_eval[wandb]. Faça pip install lm_eval[wandb] .
Autentique sua máquina com um token W&B exclusivo. Visite https://wandb.ai/authorize para obter um. Faça wandb login em seu terminal de linha de comando.
Execute eval chicote normalmente com um sinalizador wandb_args . Use este sinalizador para fornecer argumentos para inicializar uma execução wandb (wandb.init) como argumentos de string separados por vírgula.
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_samplesNo stdout, você encontrará o link para a página de execução do W&B, bem como o link para o relatório gerado. Você pode encontrar um exemplo desse fluxo de trabalho em exemplos/visualize-wandb.ipynb e um exemplo de como integrá-lo além da CLI.
Para mais informações sobre a biblioteca e como tudo se encaixa, confira todas as nossas páginas de documentação! Planejamos publicar em breve um roteiro maior de melhorias desejadas e planejadas na biblioteca, com mais informações sobre como os contribuidores podem ajudar.
Para implementar uma nova tarefa no equipamento de avaliação, consulte este guia.
Em geral, seguimos esta lista de prioridades para abordar preocupações sobre solicitações e outros detalhes de avaliação:
Estas são diretrizes e não regras, e podem ser anuladas em circunstâncias especiais.
Tentamos priorizar a concordância com os procedimentos utilizados por outros grupos para diminuir os danos quando as pessoas inevitavelmente comparam execuções em diferentes artigos, apesar do nosso desencorajamento da prática. Historicamente, também priorizamos a implementação de Language Models are Few Shot Learners, pois nosso objetivo original era especificamente comparar os resultados com aquele artigo.
A melhor maneira de obter suporte é abrir um problema neste repositório ou ingressar no servidor EleutherAI Discord. O canal #lm-thunderdome é dedicado ao desenvolvimento deste projeto e o canal #release-discussion é para receber suporte para nossos lançamentos. Se você usou a biblioteca e teve uma experiência positiva (ou negativa), adoraríamos ouvir sua opinião!
Dependências extras podem ser instaladas via pip install -e ".[NAME]"
| Nome | Usar |
|---|---|
| API | Para usar modelos de API (Anthropic, OpenAI API) |
| profundo e esparso | Para executar modelos DeepSparse do NM |
| desenvolvedor | Para linting PRs e contribuições |
| gptq | Para carregar modelos com GPTQ |
| hf_transfer | Para acelerar downloads de arquivos HF Hub |
| ifeval | Para executar a tarefa IFEval |
| neuronx | Para execução em instâncias AWS inf2 |
| mamba | Para carregar modelos Mamba SSM |
| matemática | Para executar a verificação de respostas de tarefas matemáticas |
| multilíngue | Para tokenizadores multilíngues |
| ótimo | Para executar modelos Intel OpenVINO |
| fonte imediata | Para usar prompts do PromptSource |
| frase | Para usar o tokenizer de frase |
| esparso | Para usar modelos SparseML do NM |
| testando | Para executar o conjunto de testes da biblioteca |
| vllm | Para carregar modelos com vLLM |
| Zenão | Para visualizar resultados com Zeno |
| --------------- | --------------------------------------- |
| todos | Carrega todos os extras (não 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}
}
