lm evaluation harness
v0.4.5
Neueste Nachrichten
hf-multimodal und vllm-vlm sowie die mmmu Aufgabe als Prototypfunktion hinzugefügt . Wir heißen Benutzer herzlich willkommen, diese laufende Funktion auszuprobieren und selbst einem Stresstest zu unterziehen, und empfehlen ihnen, sich lmms-eval anzuschauen, ein wunderbares Projekt, das ursprünglich aus dem lm-evaluation-Harness hervorgegangen ist, für ein breiteres Spektrum multimodaler Aufgaben. Modelle und Funktionen.local-completions zum Auswerten des Modells.Eine neue Version v0.4.0 von lm-evaluation-harness ist verfügbar !
Zu den neuen Updates und Funktionen gehören:
Weitere Informationen finden Sie auf unseren aktualisierten Dokumentationsseiten in docs/ .
Die Entwicklung des main wird fortgesetzt, und wir ermutigen Sie, uns Feedback zu den gewünschten Funktionen und zur weiteren Verbesserung der Bibliothek zu geben oder Fragen zu stellen, entweder in Issues oder PRs auf GitHub oder im EleutherAI-Discord!
Dieses Projekt bietet einen einheitlichen Rahmen zum Testen generativer Sprachmodelle für eine große Anzahl verschiedener Bewertungsaufgaben.
Merkmale:
Das Language Model Evaluation Harness ist das Backend für ? Das beliebte Open LLM Leaderboard von Hugging Face wurde in Hunderten von Artikeln verwendet und wird intern von Dutzenden von Organisationen verwendet, darunter NVIDIA, Cohere, BigScience, BigCode, Nous Research und Mosaic ML.
Führen Sie Folgendes aus, um das lm-eval Paket aus dem Github-Repository zu installieren:
git clone --depth 1 https://github.com/EleutherAI/lm-evaluation-harness
cd lm-evaluation-harness
pip install -e .Wir bieten außerdem eine Reihe optionaler Abhängigkeiten für erweiterte Funktionen an. Eine detaillierte Tabelle finden Sie am Ende dieses Dokuments.
Ein Benutzerhandbuch mit der vollständigen Liste der unterstützten Argumente finden Sie hier und auf dem Terminal durch Aufrufen von lm_eval -h . Alternativ können Sie lm-eval anstelle von lm_eval verwenden.
Eine Liste der unterstützten Aufgaben (oder Gruppierungen von Aufgaben) kann mit lm-eval --tasks list angezeigt werden. Hier finden Sie Aufgabenbeschreibungen und Links zu entsprechenden Unterordnern.
transformers Um ein Modell zu bewerten, das auf dem HuggingFace Hub (z. B. GPT-J-6B) auf hellaswag gehostet wird, können Sie den folgenden Befehl verwenden (dies setzt voraus, dass Sie eine CUDA-kompatible GPU verwenden):
lm_eval --model hf
--model_args pretrained=EleutherAI/gpt-j-6B
--tasks hellaswag
--device cuda:0
--batch_size 8 Mit dem Flag --model_args können dem Modellkonstruktor zusätzliche Argumente bereitgestellt werden. Dies unterstützt vor allem die gängige Praxis, die revisions auf dem Hub zu verwenden, um teilweise trainierte Prüfpunkte zu speichern oder den Datentyp für die Ausführung eines Modells anzugeben:
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size 8 Modelle, die sowohl über transformers.AutoModelForCausalLM (autoregressive, nur Decoder-Modelle im GPT-Stil) als auch über transformers.AutoModelForSeq2SeqLM (z. B. Encoder-Decoder-Modelle wie T5) in Huggingface geladen werden, werden unterstützt.
Die Auswahl der Stapelgröße kann automatisiert werden, indem das Flag --batch_size auf auto gesetzt wird. Dadurch wird automatisch die größte Stapelgröße ermittelt, die auf Ihr Gerät passt. Bei Aufgaben, bei denen ein großer Unterschied zwischen dem längsten und dem kürzesten Beispiel besteht, kann es hilfreich sein, die größte Stapelgröße regelmäßig neu zu berechnen, um eine weitere Beschleunigung zu erzielen. Hängen Sie dazu :N an das obige Flag an, um die größte Batchgröße N -mal automatisch neu zu berechnen. Um beispielsweise die Stapelgröße viermal neu zu berechnen, würde der Befehl wie folgt lauten:
lm_eval --model hf
--model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype= " float "
--tasks lambada_openai,hellaswag
--device cuda:0
--batch_size auto:4Notiz
Genauso wie Sie einen lokalen Pfad zu transformers.AutoModel bereitstellen können, können Sie über --model_args pretrained=/path/to/model auch einen lokalen Pfad zu lm_eval bereitstellen
accelerateWir unterstützen drei Hauptmethoden zur Verwendung der Beschleunigungsbibliothek von Hugging Face für die Multi-GPU-Bewertung.
Um eine datenparallele Auswertung durchzuführen (wobei jede GPU eine separate vollständige Kopie des Modells lädt), nutzen wir den accelerate Launcher wie folgt:
accelerate launch -m lm_eval --model hf
--tasks lambada_openai,arc_easy
--batch_size 16
(oder über accelerate launch --no-python lm_eval ).
In Fällen, in denen Ihr Modell auf eine einzelne GPU passt, können Sie auf K GPUs K-mal schneller evaluieren als auf einer.
WARNUNG : Dieses Setup funktioniert nicht mit FSDP-Modell-Sharding, daher muss FSDP in accelerate config deaktiviert werden oder die FSDP-Option NO_SHARD verwendet werden.
Die zweite Möglichkeit, accelerate für die Multi-GPU-Bewertung zu verwenden, besteht darin, dass Ihr Modell zu groß ist, um auf eine einzelne GPU zu passen.
Führen Sie in dieser Einstellung die Bibliothek außerhalb des accelerate Launcher aus, aber übergeben Sie parallelize=True wie folgt an --model_args :
lm_eval --model hf
--tasks lambada_openai,arc_easy
--model_args parallelize=True
--batch_size 16
Das bedeutet, dass die Gewichtungen Ihres Modells auf alle verfügbaren GPUs aufgeteilt werden.
Für fortgeschrittenere Benutzer oder sogar größere Modelle erlauben wir auch die folgenden Argumente, wenn parallelize=True :
device_map_option : So teilen Sie Modellgewichtungen auf verfügbare GPUs auf. Der Standardwert ist „automatisch“.max_memory_per_gpu : der maximale GPU-Speicher, der pro GPU beim Laden des Modells verwendet werden soll.max_cpu_memory : Die maximale Menge an CPU-Speicher, die beim Auslagern der Modellgewichte in den RAM verwendet werden soll.offload_folder : ein Ordner, in den Modellgewichte bei Bedarf auf die Festplatte ausgelagert werden.Die dritte Möglichkeit besteht darin, beide gleichzeitig zu verwenden. Dadurch können Sie sowohl Datenparallelität als auch Modell-Sharding nutzen und sind besonders nützlich für Modelle, die zu groß sind, um auf eine einzelne GPU zu passen.
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
Weitere Informationen zur Modellparallelität und deren Verwendung mit der accelerate finden Sie in der Beschleunigungsdokumentation
Warnung: Wir unterstützen die Multi-Node-Auswertung mit dem hf -Modelltyp nicht nativ! Ein Beispielcode, in dem ein benutzerdefiniertes Evaluierungsskript für mehrere Maschinen geschrieben wird, finden Sie in unserer GPT-NeoX-Bibliotheksintegration.
Hinweis: Wir unterstützen derzeit keine nativen Multi-Node-Auswertungen und empfehlen, entweder einen extern gehosteten Server zu verwenden, um Inferenzanfragen auszuführen, oder eine benutzerdefinierte Integration mit Ihrem verteilten Framework zu erstellen, wie dies für die GPT-NeoX-Bibliothek der Fall ist.
nemo -ModelleNVIDIA NeMo Framework ist ein generatives KI-Framework, das für Forscher und Pytorch-Entwickler entwickelt wurde, die an Sprachmodellen arbeiten.
Um ein nemo -Modell zu evaluieren, installieren Sie zunächst NeMo gemäß der Dokumentation. Wir empfehlen dringend, den NVIDIA PyTorch- oder NeMo-Container zu verwenden, insbesondere wenn Probleme bei der Installation von Apex oder anderen Abhängigkeiten auftreten (siehe zuletzt veröffentlichte Container). Bitte installieren Sie auch die LM-Evaluierungskabelbibliothek gemäß den Anweisungen im Abschnitt „Installieren“.
NeMo-Modelle sind über den NVIDIA NGC-Katalog oder auf der Hugging Face-Seite von NVIDIA erhältlich. Im NVIDIA NeMo Framework gibt es Konvertierungsskripte, um die hf Checkpoints beliebter Modelle wie Lama, Falcon, Mixtral oder MPT in nemo zu konvertieren.
Führen Sie ein nemo -Modell auf einer GPU aus:
lm_eval --model nemo_lm
--model_args path= < path_to_nemo_model >
--tasks hellaswag
--batch_size 32 Es wird empfohlen, das nemo -Modell zu entpacken, um zu vermeiden, dass es im Docker-Container entpackt wird, da sonst der Speicherplatz überlaufen könnte. Dazu können Sie Folgendes ausführen:
mkdir MY_MODEL
tar -xvf MY_MODEL.nemo -c MY_MODEL
nemo ModellenStandardmäßig wird nur eine GPU verwendet. Wir unterstützen jedoch entweder die Datenreplikation oder die Tensor-/Pipeline-Parallelität während der Auswertung auf einem Knoten.
model_args der devices auf die Anzahl der auszuführenden Datenreplikate fest. Der Befehl zum Ausführen von 8 Datenreplikaten über 8 GPUs lautet beispielsweise: 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 von tensor_model_parallel_size und/ pipeline_model_parallel_size fest. Darüber hinaus müssen Sie devices so einrichten, dass sie dem Produkt aus tensor_model_parallel_size und/oder pipeline_model_parallel_size entsprechen. Der Befehl zur Verwendung eines Knotens mit 4 GPUs mit einer Tensor-Parallelität von 2 und einer Pipeline-Parallelität von 2 lautet beispielsweise: 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 Beachten Sie, dass empfohlen wird, den python -Befehl durch torchrun --nproc-per-node=<number of devices> --no-python zu ersetzen, um das Laden des Modells in die GPUs zu erleichtern. Dies ist besonders wichtig für große Prüfpunkte, die auf mehrere GPUs geladen werden.
Noch nicht unterstützt: Multi-Node-Auswertung und Kombinationen von Datenreplikation mit Tensor- oder Pipeline-Parallelität.
vLLMWir unterstützen auch vLLM für schnellere Rückschlüsse auf unterstützte Modelltypen, insbesondere schneller, wenn ein Modell auf mehrere GPUs aufgeteilt wird. Für Single-GPU oder Multi-GPU – Tensor-Parallel, Daten-Parallel oder eine Kombination aus beidem – Inferenz, zum Beispiel:
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 Um vllm zu verwenden, führen Sie pip install lm_eval[vllm] aus. Eine vollständige Liste der unterstützten vLLM-Konfigurationen finden Sie in unserer vLLM-Integration und der vLLM-Dokumentation.
vLLM unterscheidet sich gelegentlich in der Ausgabe von Huggingface. Wir betrachten Huggingface als Referenzimplementierung und stellen ein Skript zur Überprüfung der Gültigkeit von vllm-Ergebnissen anhand von HF bereit.
Tipp
Für die schnellste Leistung empfehlen wir, wann immer möglich, --batch_size auto für vLLM zu verwenden, um die kontinuierliche Batch-Funktionalität zu nutzen!
Tipp
Die Übergabe von max_model_len=4096 oder einem anderen sinnvollen Standardwert an vLLM über Modellargumente kann zu Beschleunigungen führen oder Fehler aufgrund von unzureichendem Arbeitsspeicher verhindern, wenn versucht wird, die automatische Stapelgröße zu verwenden, z. B. für Mistral-7B-v0.1, der standardmäßig eine maximale Länge von hat 32k.
Unsere Bibliothek unterstützt auch die Evaluierung von Modellen, die über mehrere kommerzielle APIs bereitgestellt werden, und wir hoffen, die Unterstützung für die am häufigsten verwendeten leistungsstarken lokalen/selbstgehosteten Inferenzserver implementieren zu können.
Um ein gehostetes Modell aufzurufen, verwenden Sie:
export OPENAI_API_KEY=YOUR_KEY_HERE
lm_eval --model openai-completions
--model_args model=davinci
--tasks lambada_openai,hellaswagWir unterstützen auch die Verwendung Ihres eigenen lokalen Inferenzservers mit Servern, die die OpenAI Completions- und ChatCompletions-APIs widerspiegeln.
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 Beachten Sie, dass für extern gehostete Modelle Konfigurationen wie --device , die sich darauf beziehen, wo ein lokales Modell platziert werden soll, nicht verwendet werden sollten und nicht funktionieren. So wie Sie --model_args verwenden können, um beliebige Argumente an den Modellkonstruktor für lokale Modelle zu übergeben, können Sie damit beliebige Argumente an die Modell-API für gehostete Modelle übergeben. Informationen zu den unterstützten Argumenten finden Sie in der Dokumentation des Hosting-Dienstes.
| API oder Inferenzserver | Umgesetzt? | --model <xxx> Name | Unterstützte Modelle: | Anfragetypen: |
|---|---|---|---|---|
| OpenAI-Abschlüsse | ✔️ | openai-completions , local-completions | Alle OpenAI Completions API-Modelle | generate_until , loglikelihood , loglikelihood_rolling |
| OpenAI ChatCompletions | ✔️ | openai-chat-completions , local-chat-completions | Alle ChatCompletions-API-Modelle | generate_until (keine Logprobs) |
| Anthropisch | ✔️ | anthropic | Unterstützte Anthropic Engines | generate_until (keine Logprobs) |
| Anthropischer Chat | ✔️ | anthropic-chat , anthropic-chat-completions | Unterstützte Anthropic Engines | generate_until (keine Logprobs) |
| Textsynth | ✔️ | textsynth | Alle unterstützten Engines | generate_until , loglikelihood , loglikelihood_rolling |
| Zusammenhängen | ⌛ – aufgrund eines Cohere-API-Fehlers blockiert | N / A | Alle cohere.generate() -Engines | generate_until , loglikelihood , loglikelihood_rolling |
| Llama.cpp (über llama-cpp-python) | ✔️ | gguf , ggml | Alle von llama.cpp unterstützten Modelle | generate_until , loglikelihood , (Perplexitätsauswertung noch nicht implementiert) |
| vLLM | ✔️ | vllm | Die meisten kausalen HF-Sprachmodelle | generate_until , loglikelihood , loglikelihood_rolling |
| Mamba | ✔️ | mamba_ssm | Sprachmodelle der Mamba-Architektur über das Paket mamba_ssm | generate_until , loglikelihood , loglikelihood_rolling |
| Huggingface Optimum (kausale LMs) | ✔️ | openvino | Jedes reine Decoder-AutoModelForCausalLM, das mit Huggingface Optimum in das OpenVINO™ Intermediate Representation (IR)-Format konvertiert wurde | generate_until , loglikelihood , loglikelihood_rolling |
| Neuron über AWS Inf2 (kausale LMs) | ✔️ | neuronx | Jedes AutoModelForCausalLM, das nur vom Decoder unterstützt wird, kann auf dem Bild „hugingface-ami“ für inferentia2 ausgeführt werden | generate_until , loglikelihood , loglikelihood_rolling |
| Neuronale Magie DeepSparse | ✔️ | deepsparse | Jeder LM von SparseZoo oder auf HF Hub mit dem Tag „deepsparse“. | generate_until , loglikelihood |
| Neural Magic SparseML | ✔️ | sparseml | Jedes AutoModelForCausalLM nur für Decoder von SparseZoo oder auf HF Hub. Besonders nützlich für Modelle mit Quantisierung wie zoo:llama2-7b-gsm8k_llama2_pretrain-pruned60_quantized | generate_until , loglikelihood , loglikelihood_rolling |
| Ihr lokaler Inferenzserver! | ✔️ | local-completions oder local-chat-completions | Unterstützung für OpenAI-API-kompatible Server mit einfacher Anpassung für andere APIs. | generate_until , loglikelihood , loglikelihood_rolling |
Modelle, die keine Logits oder Logprobs bereitstellen, können nur mit Aufgaben vom Typ generate_until verwendet werden, während lokale Modelle oder APIs, die Logprobs/Logits ihrer Eingabeaufforderungen bereitstellen, auf allen Aufgabentypen ausgeführt werden können: generate_until loglikelihood , „ loglikelihood_rolling “ und multiple_choice .
Weitere Informationen zu den verschiedenen Aufgaben output_types und Modellanforderungstypen finden Sie in unserer Dokumentation.
Notiz
Um die beste Leistung mit geschlossenen Chat-Modell-APIs wie Anthropic Claude 3 und GPT-4 zu erzielen, empfehlen wir, zunächst einige Beispielausgaben mit --limit 10 sorgfältig anzusehen, um sicherzustellen, dass die Antwortextraktion und die Bewertung generativer Aufgaben wie erwartet funktionieren. Es kann nützlich sein system="<some system prompt here>" innerhalb von --model_args für anthropic-chat-completions bereitzustellen, um dem Modell mitzuteilen, in welchem Format es antworten soll.
Eine Reihe anderer Bibliotheken enthalten Skripte zum Aufrufen des Evaluierungs-Harness über ihre Bibliothek. Dazu gehören GPT-NeoX, Megatron-DeepSpeed und Mesh-Transformer-Jax.
Um Ihre eigene benutzerdefinierte Integration zu erstellen, können Sie den Anweisungen in diesem Tutorial folgen.
Notiz
Für Aufgaben, die für eine direkte Auswertung ungeeignet sind – entweder aufgrund von Risiken im Zusammenhang mit der Ausführung nicht vertrauenswürdigen Codes oder wegen der Komplexität des Auswertungsprozesses – ist das Flag --predict_only verfügbar, um dekodierte Generationen für die Post-hoc-Auswertung zu erhalten.
Wenn Sie einen Metal-kompatiblen Mac haben, können Sie die Evaluierungsumgebung mit dem MPS-Backend ausführen, indem Sie --device cuda:0 durch --device mps ersetzen (erfordert PyTorch Version 2.1 oder höher). Beachten Sie, dass sich das PyTorch MPS-Backend noch in einem frühen Entwicklungsstadium befindet, sodass möglicherweise Probleme mit der Korrektheit oder nicht unterstützte Vorgänge vorliegen. Wenn Sie Auffälligkeiten bei der Modellleistung im MPS-Backend feststellen, empfehlen wir, zunächst zu überprüfen, ob ein Vorwärtsdurchlauf Ihres Modells auf --device cpu und --device mps übereinstimmt.
Notiz
Sie können überprüfen, wie die LM-Eingaben aussehen, indem Sie den folgenden Befehl ausführen:
python write_out.py
--tasks < task1,task2,... >
--num_fewshot 5
--num_examples 10
--output_base_path /path/to/output/folderDadurch wird für jede Aufgabe eine Textdatei geschrieben.
Um die Datenintegrität der von Ihnen ausgeführten Aufgaben zusätzlich zur Ausführung der Aufgaben selbst zu überprüfen, können Sie das Flag --check_integrity verwenden:
lm_eval --model openai
--model_args engine=davinci
--tasks lambada_openai,hellaswag
--check_integrity Bei Modellen, die mit der HuggingFace transformers geladen werden, werden alle über --model_args bereitgestellten Argumente direkt an den entsprechenden Konstruktor übergeben. Das bedeutet, dass alles, was Sie mit AutoModel tun können, auch mit unserer Bibliothek möglich ist. Sie können beispielsweise einen lokalen Pfad über pretrained= übergeben oder mit PEFT feinabgestimmte Modelle verwenden, indem Sie den Aufruf übernehmen, den Sie ausführen würden, um das Basismodell auszuwerten, und ,peft=PATH zum Argument model_args hinzufügen:
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:0Modelle, die als Delta-Gewichte bereitgestellt werden, können einfach mit der Hugging-Face-Transformer-Bibliothek geladen werden. Legen Sie in --model_args das Delta-Argument fest, um die Delta-Gewichte anzugeben, und verwenden Sie das vorab trainierte Argument, um das relative Basismodell anzugeben, auf das sie angewendet werden:
lm_eval --model hf
--model_args pretrained=Ejafa/llama_7B,delta=lmsys/vicuna-7b-delta-v1.1
--tasks hellaswagGPTQ-quantisierte Modelle können mit GPTQModel (schneller) oder AutoGPTQ geladen werden
GPTQModel: ,gptqmodel=True zu model_args hinzufügen
lm_eval --model hf
--model_args pretrained=model-name-or-path,gptqmodel=True
--tasks hellaswag AutoGPTQ: ,autogptq=True zu model_args hinzufügen:
lm_eval --model hf
--model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True
--tasks hellaswag Wir unterstützen Platzhalter in Aufgabennamen. Sie können beispielsweise alle maschinell übersetzten Lambada-Aufgaben über --task lambada_openai_mt_* ausführen.
Um die Auswertungsergebnisse zu speichern, geben Sie einen --output_path an. Wir unterstützen auch die Protokollierung von Modellantworten mit dem Flag --log_samples für die Post-hoc-Analyse.
Darüber hinaus kann man mit --use_cache ein Verzeichnis bereitstellen, um die Ergebnisse früherer Läufe zwischenzuspeichern. Dadurch können Sie die wiederholte Ausführung derselben (Modell-, Aufgaben-)Paare zur erneuten Bewertung vermeiden.
Um Ergebnisse und Proben an den Hugging Face Hub zu übertragen, stellen Sie zunächst sicher, dass in der Umgebungsvariablen HF_TOKEN ein Zugriffstoken mit Schreibzugriff festgelegt ist. Verwenden Sie dann das Flag --hf_hub_log_args , um die Organisation, den Repository-Namen und die Repository-Sichtbarkeit anzugeben und ob Ergebnisse und Proben an den Hub übertragen werden sollen – Beispieldatensatz auf dem HF-Hub. Zum Beispiel:
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 Auf diese Weise können Sie die Ergebnisse und Proben ganz einfach vom Hub herunterladen, indem Sie Folgendes verwenden:
from datasets import load_dataset
load_dataset ( "EleutherAI/lm-eval-results-private" , "hellaswag" , "latest" )Eine vollständige Liste der unterstützten Argumente finden Sie im Schnittstellenleitfaden in unserer Dokumentation!
Mit Weights & Biases (W&B) und Zeno können Sie die Ergebnisse Ihrer Bewertungskabelläufe nahtlos visualisieren und analysieren.
Sie können Zeno verwenden, um die Ergebnisse Ihrer Testläufe zu visualisieren.
Gehen Sie zunächst zu hub.zenoml.com, um ein Konto zu erstellen und einen API-Schlüssel auf Ihrer Kontoseite zu erhalten. Fügen Sie diesen Schlüssel als Umgebungsvariable hinzu:
export ZENO_API_KEY=[your api key] Sie müssen außerdem das Paket lm_eval[zeno] zusätzlich installieren.
Um die Ergebnisse zu visualisieren, führen Sie den Eval-Harness mit den Flags log_samples und output_path aus. Wir erwarten, dass output_path mehrere Ordner enthält, die einzelne Modellnamen darstellen. So können Sie Ihre Auswertung an beliebig vielen Aufgaben und Modellen durchführen und alle Ergebnisse als Projekte auf Zeno hochladen.
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 Anschließend können Sie die resultierenden Daten mit dem Skript zeno_visualize hochladen:
python scripts/zeno_visualize.py
--data_path output
--project_name " Eleuther Project " Dadurch werden alle Unterordner in data_path als unterschiedliche Modelle verwendet und alle Aufgaben in diesen Modellordnern nach Zeno hochgeladen. Wenn Sie die Evaluierungsumgebung für mehrere Aufgaben ausführen, wird der project_name als Präfix verwendet und pro Aufgabe wird ein Projekt erstellt.
Ein Beispiel für diesen Workflow finden Sie in examples/visualize-zeno.ipynb.
Mit der Integration von Gewichtungen und Verzerrungen können Sie jetzt mehr Zeit damit verbringen, tiefere Einblicke in Ihre Bewertungsergebnisse zu gewinnen. Die Integration soll den Prozess der Protokollierung und Visualisierung von Experimentergebnissen mithilfe der Weights & Biases (W&B)-Plattform optimieren.
Die Integration stellt Funktionalitäten bereit
results.json als Artefakt zur Versionskontrolle.<task_name>_eval_samples.json , wenn die Proben protokolliert werden. Zuerst müssen Sie das zusätzliche Paket lm_eval[wandb] installieren. Führen Sie pip install lm_eval[wandb] durch.
Authentifizieren Sie Ihr Gerät mit Ihrem einzigartigen W&B-Token. Besuchen Sie https://wandb.ai/authorize, um eines zu erhalten. Melden Sie wandb login in Ihrem Befehlszeilenterminal an.
Führen Sie Eval Harness wie gewohnt mit einem wandb_args -Flag aus. Verwenden Sie dieses Flag, um Argumente für die Initialisierung eines Wandb-Laufs (wandb.init) als durch Kommas getrennte Zeichenfolgenargumente bereitzustellen.
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_samplesIn der Standardausgabe finden Sie den Link zur W&B-Laufseite sowie einen Link zum generierten Bericht. Ein Beispiel für diesen Workflow finden Sie in examples/visualize-wandb.ipynb und ein Beispiel für die Integration über die CLI hinaus.
Weitere Informationen zur Bibliothek und wie alles zusammenpasst, finden Sie auf allen unseren Dokumentationsseiten! Wir planen, bald eine umfassendere Roadmap der gewünschten und geplanten Bibliotheksverbesserungen zu veröffentlichen, mit weiteren Informationen darüber, wie Mitwirkende helfen können.
Informationen zum Implementieren einer neuen Aufgabe in der Evaluierungsumgebung finden Sie in dieser Anleitung.
Im Allgemeinen befolgen wir diese Prioritätenliste, um Bedenken hinsichtlich der Eingabeaufforderung und anderer Bewertungsdetails auszuräumen:
Hierbei handelt es sich um Richtlinien und nicht um Regeln, die unter besonderen Umständen außer Kraft gesetzt werden können.
Wir versuchen, der Zustimmung zu den von anderen Gruppen verwendeten Verfahren Vorrang zu geben, um den Schaden zu verringern, wenn Menschen unweigerlich Läufe in verschiedenen Zeitungen vergleichen, obwohl wir von dieser Praxis abraten. In der Vergangenheit haben wir auch der Implementierung von Language Models are Few Shot Learners Priorität eingeräumt, da unser ursprüngliches Ziel speziell darin bestand, die Ergebnisse mit diesem Papier zu vergleichen.
Der beste Weg, Unterstützung zu erhalten, besteht darin, ein Problem in diesem Repo zu eröffnen oder dem EleutherAI Discord-Server beizutreten. Der Kanal #lm-thunderdome widmet sich der Entwicklung dieses Projekts und der Kanal #release-discussion dient der Unterstützung für unsere Veröffentlichungen. Wenn Sie die Bibliothek genutzt und eine positive (oder negative) Erfahrung gemacht haben, würden wir uns freuen, von Ihnen zu hören!
Zusätzliche Abhängigkeiten können über pip install -e ".[NAME]" installiert werden.
| Name | Verwenden |
|---|---|
| API | Zur Verwendung von API-Modellen (Anthropic, OpenAI API) |
| tiefspärlich | Zum Ausführen der DeepSparse-Modelle von NM |
| Entwickler | Für fusselige PRs und Beiträge |
| gptq | Zum Laden von Modellen mit GPTQ |
| hf_transfer | Zur Beschleunigung des Herunterladens von HF Hub-Dateien |
| ifeval | Zum Ausführen der IFEval-Aufgabe |
| Neuronx | Zur Ausführung auf AWS inf2-Instanzen |
| Mamba | Zum Laden von Mamba SSM-Modellen |
| Mathe | Zum Ausführen der Antwortüberprüfung bei Mathe-Aufgaben |
| mehrsprachig | Für mehrsprachige Tokenizer |
| Optimum | Zum Ausführen von Intel OpenVINO-Modellen |
| promptsource | Zur Verwendung von PromptSource-Eingabeaufforderungen |
| Satzstück | Für die Verwendung des Satzstück-Tokenizers |
| spärlich | Zur Verwendung der SparseML-Modelle von NM |
| Testen | Zum Ausführen der Bibliothekstestsuite |
| vllm | Zum Laden von Modellen mit vLLM |
| Zeno | Zur Ergebnisvisualisierung mit Zeno |
| --------------- | --------------------------------------- |
| alle | Lädt alle Extras (nicht empfohlen) |
@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}
}
