alpaca_eval
v0.6.5
Alpacaeval 2.0 mit längenkontrollierten Win-Raten (Papier) hat eine Spearman-Korrelation von 0,98 mit Chatbot Arena und kostet weniger als 10 US-Dollar an OpenAI-Credits, die in weniger als 3 Minuten laufen und ausgeführt werden. Unser Ziel ist es, einen Benchmark für Chat -LLMs zu haben: FAST (<5 min), billig (<$ 10) und stark korreliert mit Menschen (0,98). Hier ist ein Vergleich mit anderen Benchmarks:
Aktualisierungen:
? Die längenkontrollierten Siegespreise sind standardmäßig aus und werden standardmäßig verwendet! Dies erhöht die Korrelation mit der Chatbot -Arena von 0,93 auf 0,98 und verkleinert die Länge signifikant. Die RAW -Gewinnraten werden weiterhin auf der Website und der CLI angezeigt. Weitere Details hier.
? Alpacaeval 2.0 ist standardmäßig aus und wird standardmäßig verwendet! Wir haben den Auto-Annotator (besser und billiger) verbessert und verwenden die GPT-4-Vorschau als Grundlinie. Weitere Details hier. Setzen Sie für die alte Version Ihre Umgebungsvariable IS_ALPACA_EVAL_2=False .
Die Bewertung von Anweisungsverfolgungsmodellen (z. B. ChatGPT) erfordert typischerweise menschliche Interaktionen. Dies ist zeitaufwändig, teuer und schwer zu replizieren. AlpaCaeval in einer auf LLM basierenden automatischen Bewertung, die schnell, billig, reproduzierbar und gegen 20.000 menschliche Anmerkungen validiert ist. Es ist besonders nützlich für die Modellentwicklung. Obwohl wir uns gegenüber früheren automatischen Bewertungsleitungen verbessert haben, gibt es immer noch grundlegende Einschränkungen wie die Präferenz für längere Ausgaben. Alpacaeval liefert Folgendes:
Wann kann man Alpacaeval verwenden? Unser automatischer Bewerter ist ein schneller und billiger Proxy für die menschliche Bewertung einfacher Anweisungsaufgaben. Es ist nützlich, wenn Sie während der Modellentwicklung viele Bewertungen schnell durchführen müssen.
Wann nicht Alpacaeval verwenden? Wie jeder andere automatische Bewerter sollte AlpaCaEVAL die menschliche Bewertung bei der Entscheidungsfindung mit hoher Stake-Entscheidung, z. B., nicht ersetzen, um sich für die Modellfreigabe zu entscheiden. Insbesondere ist Alpacaeval durch die Tatsache begrenzt, dass (1) die Anweisungen im EV -Set möglicherweise nicht für die fortgeschrittene Verwendung von LLMs repräsentativ sind. (2) Automatische Bewerter können Vorurteile haben, wie z. und (3) Alpacaeval misst die Risiken, die ein Modell verursachen könnte, nicht. Details in Einschränkungen.
Um die stabile Version zu installieren, laufen Sie aus
pip install alpaca-evalUm die nächtliche Version zu installieren, laufen Sie aus
pip install git+https://github.com/tatsu-lab/alpaca_evalDann können Sie es wie folgt verwenden:
export OPENAI_API_KEY= < your_api_key > # for more complex configs, e.g. using Azure or switching clients see client_configs/README.md
alpaca_eval --model_outputs ' example/outputs.json ' Dadurch wird die Rangliste in die Konsole gedruckt und sowohl die Rangliste als auch die Annotationen in demselben Verzeichnis wie die Datei model_outputs gespeichert. Wichtige Parameter sind die folgenden:
instruction und output der Schlüsseln enthalten.weighted_alpaca_eval_gpt4_turbo (Standard für Alpacaeval 2.0), was mit unseren menschlichen Annotationsdaten, einer großen Kontextgröße und ziemlich billig eine hohe Vereinbarung hat. Für einen Vergleich aller Annotatoren finden Sie hier.model_outputs . Standardmäßig ist dies gpt4_turbo für alpacaeval 2.0. Wenn Sie nicht über die Modellausgaben verfügen, können Sie evaluate_from_model verwenden und einen lokalen Pfad oder einen Namen eines Umarmungsface -Modells oder ein Modell aus einer Standard -API (OpenAI, Anthrop, Cohere, Google, ...) übergeben. Andere Befehle:
>>> alpaca_eval -- --help SYNOPSIS
alpaca_eval COMMAND
COMMANDS
COMMAND is one of the following:
evaluate
Evaluate a model based on its outputs. This is the default entrypoint if no command is specified.
evaluate_from_model
Evaluate a model from HuggingFace or an API provider. This is a wrapper around `evaluate` which includes generating from a desired model.
make_leaderboard
Precompute and save an entire leaderboard for a given dataset / evaluator / set of models generations.
analyze_evaluators
Analyze an evaluator and populates the evaluators leaderboard (agreement with human, speed, price,...).
Weitere Informationen zu jeder Funktion verwenden Sie alpaca_eval <command> -- --help .
Unsere Bestenlisten werden im AlpaCaeval -Datensatz berechnet. Wir haben die Rangliste für wichtige Modelle mit verschiedenen Basismodellen und Autoannotatoren vorberechnet. Unsere zwei Hauptbesten "AlpaCaEval 2.0" verwendet weighted_alpaca_eval_gpt4_turbo für den Annotator und gpt4_turbo für die Grundlinie. "AlpaCaeval" verwendet alpaca_eval_gpt4 für den Annotator und text_davinci_003 für die Basislinie. Für alle vorberechtigten Bestenlisten siehe hier. Später zeigen wir auch, wie Sie Ihr Modell in die Rangliste hinzufügen und wie Sie eine neue Rangliste für Ihren Evaluator/Datensatz erstellen. Hier finden Sie die Konfigurationen aller Modelle, die außerhalb der Box verfügbar sind.
Alpakaevale minimale Rangliste :
| Gewinnrate | STD -Fehler | |
|---|---|---|
| gpt4 | 95.3 | 0,7 |
| Claude | 88,4 | 1.1 |
| Chatgpt | 86.1 | 1.2 |
| Guanaco-65b | 71,8 | 1.6 |
| Vicuna-13b | 70,4 | 1.6 |
| text_davinci_003 | 50.0 | 0,0 |
| Alpaka-Farm-PPO-Human | 41.2 | 1.7 |
| Alpaca-7b | 26,5 | 1.5 |
| text_davinci_001 | 15.2 | 1.2 |
Gewinnrate : Die Gewinnrate misst den Bruchteil der Zeit, in der die Ausgabe des Modells gegenüber den Ausgängen der Referenz bevorzugt wird ( test-davinci-003 für Alpacaeval und gpt4_turbo für Alpacaeval 2.0). Insbesondere, um die Gewinnrate zu berechnen, sammeln wir auf jeder Anweisung aus dem Apacaeval -Datensatz Paare von Ausgaben des gewünschten Modells. Wir kombinieren dann jede Ausgabe mit der Ausgabe unseres Referenzmodells (z. B. text-davinci-003 ) auf derselben Anweisung. Wir fragen dann unseren automatischen Bewerter, welche Ausgabe sie bevorzugen. Siehe AlpaCaeval- und AlpaCaeval 2.0 -Eingabeaufforderungen und -Entätigkeiten. Insbesondere die Reihenfolge der Ausgänge randomisieren, um eine Positionsverzerrung zu vermeiden. Wir haben dann die Einstellungen für alle Anweisungen im Datensatz durchschnittlich, um die Gewinnrate des Modells über die Basislinie zu erhalten. Wenn beide Ausgänge genau gleich sind, verwenden wir für beide Modelle eine halbe Präferenz.
Standardfehler : Dies ist der Standardfehler (normalisiert durch N-1) der Gewinnrate, dh den durchschnittlichen Vorlieben, die über die verschiedenen Anweisungen gemittelt wurden.
alpaca_eval_gpt4 Unser Annotator alpaca_eval_gpt4 (siehe Konfigurationen) Annotator -Durchschnittswerte gegenüber den Vorlieben, bei denen Präferenzen wie folgt erhalten werden:
temperature=0Der Annotator ist eine Mischung aus (und wurde stark von) Alpacafarm- und Visuatoren -Bewertern. Insbesondere verwenden wir den gleichen Code wie für Alpacafarm (Caching/Randomisierung/Hyperparameter), aber eine Ranking -Eingabeaufforderung ähnlich der der Aviary. Wir ändern Änderungen an der Aufforderung von Aviary, die Verzerrung für längere Ausgaben zu verringern. Details in verwandten Arbeiten.
Für AlpaCaEVAL 2.0 verwenden wir weighted_alpaca_eval_gpt4_turbo , das LogProbs verwendet, um kontinuierliche Präferenz zu berechnen und GPT4_Turbo als Modell zu verwenden (siehe Konfigurationen).
Wir bewerten verschiedene automatische Annotatoren auf dem Alpakaeval -Set, indem wir mit 2,5K -Annotationen des von uns gesammelten menschlichen Anmerkungen (~ 650 Anweisungen mit je 4 menschlichen Annotationen) verglichen werden. Im Folgenden zeigen wir Metriken für unsere vorgeschlagenen Bewerter ( weighted_alpaca_eval_gpt4_turbo , alpaca_eval_gpt4 ) für claude automatische Evaluatoren ( alpaca_farm_greedy_gpt4 , aviary_gpt4 , lmsys_gpt4 gpt4 humans text_davinci_003 , chatgpt_fn , guanaco_33b , chatgpt ). Hier finden Sie die Konfigurationen aller Evaluatoren, die außerhalb der Box verfügbar sind, und deren zugehörigen Metriken.
| Menschliche Vereinbarung | Preis [$/1000 Beispiele] | Zeit [Sekunden/1000 Beispiele] | Spearman Corr. | Pearson Corr. | Voreingenommenheit | Varianz | Proba. länger bevorzugen | |
|---|---|---|---|---|---|---|---|---|
| ALPACA_EVAL_GPT4 | 69.2 | 13.6 | 1455 | 0,97 | 0,93 | 28.4 | 14.6 | 0,68 |
| ALPACA_EVAL_COT_GPT4_TURBO_FN | 68,6 | 6.3 | 1989 | 0,97 | 0,90 | 29.3 | 18.4 | 0,67 |
| ALPACA_EVAL_GPT4_TURBO_FN | 68.1 | 5.5 | 864 | 0,93 | 0,82 | 30.2 | 15.6 | 0,65 |
| ALPACA_EVAL_LLAMA3_70B_FN | 67,5 | 0,4 | 209 | 0,90 | 0,86 | 32.3 | 8.2 | 0,79 |
| gpt4 | 66,9 | 12.5 | 1037 | 0,88 | 0,87 | 31.5 | 14.6 | 0,65 |
| ALPACA_FARM_GREDY_GPT4 | 66,4 | 15.3 | 878 | 0,85 | 0,75 | 30.2 | 19.3 | 0,60 |
| ALPACA_EVAL_COT_GPT4_TURBO_FN | 65.7 | 4.3 | 228 | 0,78 | 0,77 | 33.9 | 23.7 | 0,61 |
| Menschen | 65.7 | 300.0 | 36800 | 1.00 | 1.00 | 0,0 | 34.3 | 0,64 |
| Claude | 65.3 | 3.3 | 173 | 0,93 | 0,90 | 32.4 | 18.5 | 0,66 |
| LMSYS_GPT4 | 65.3 | 13.9 | 17982 | 0,98 | 0,97 | 31.6 | 15.9 | 0,74 |
| text_davinci_003 | 64.1 | 8.7 | 121 | 0,85 | 0,83 | 33.8 | 22.7 | 0,70 |
| längste | 62.2 | 0,0 | 0 | 0,27 | 0,56 | 37,8 | 0,0 | 1.00 |
| Chatgpt | 57.3 | 0,8 | 285 | 0,72 | 0,71 | 39.4 | 34.1 | 0,59 |
Wir erklären jetzt in Worten, wie wir die Metriken in der obigen Tabelle berechnen. Der Code ist hier.
Menschliche Vereinbarung : Dies misst die Vereinbarung zwischen dem aktuellen Annotator und den Mehrheitspräferenzen des Menschen zu unseren ~ 650 Annotationen aus unserem Cross-Annotation-Set, das 4 menschliche Annotationen pro Beispiel enthält. Um die Vereinbarung zwischen einem einzelnen Menschen ( humans in der obigen Tabelle) und der Mehrheit der Menschen abzuschätzen, nehmen wir eine der 4 Anmerkungen ein und berechnen die Genauigkeit, die sie bei der Vorhersage der Art der anderen 3 Anmerkungen vorhersagt. Wir haben dann diese Genauigkeit in allen 4 Anmerkungen und über die 650 Anweisungen, um die menschliche Vereinbarung zu erhalten, dh die erwarteten (über Menschen und Proben) Urlaubsvereinbarung berechnet. Wenn der Modus nicht eindeutig ist, nehmen wir zufällig einen der Modi. Wir führen genau die gleiche Berechnung für die automatischen Annotatoren durch, damit die endgültigen Zahlen vergleichbar sind.
Preis [$/1000 Beispiele] : Dies ist der Durchschnittspreis von 1000 Anmerkungen. Für den Menschen ist es der Preis, den wir mechanischen Türkern bezahlt haben, um diese Anmerkungen (21 US -Dollar pro Stunde) zu sammeln. Wenn der Preis von der Maschine abhängt, mit der die Anmerkungen (z. B. Guanaco) berechnet werden, lassen wir sie leer.
Zeit [Sekunden/1000 Beispiele] : Dies ist die durchschnittliche Zeit, die für die Berechnung von 1000 Anmerkungen benötigt wird. Für den Menschen ist es die geschätzte mittlere Zeit, die jeder mechanische Turker 1000 Beispiele für Anmerkungen nutzte. Für automatische Annotatoren ist es die durchschnittliche Zeit, die wir beim Ausführen der Anmerkungen benötigten. Beachten Sie, dass dies von API -Grenzen abhängen kann, die für verschiedene Benutzer unterschiedlich sind, und von der Anzahl der Anforderungen, die die Cluster verarbeiten.
Spearman Corr. : Dies misst die Spearman-Korrelation zwischen einem mit der Präferenz des Auto-Annotators berechneten Ranglistenboards und der mit menschlichen Vorlieben berechneten Rangliste. Wie bei Human agreement verwenden wir die menschlichen Annotationen von Alpacafarm, aber jetzt betrachten wir die Vereinbarung auf Methodenebene und nicht nur die Stichprobenvereinbarung mit Menschen. Beachten Sie, dass wir nur 9 Modelle verwenden und daher die Korrelation nicht sehr zuverlässig ist.
Pearson Corr. : Gleich wie bei Spearman corr. aber mit Pearson -Korrelation.
Voreingenommenheit : Übereinstimmung zwischen dem wahrscheinlichsten menschlichen und dem wahrscheinlichsten automatischen Label. Für automatische Annotatoren schätzen wir es, indem wir für jedes Beispiel 4 verschiedene Anmerkungen abtasten. Die Zufälligkeit stammt hier aus der Reihenfolge der Ausgänge in der Eingabeaufforderung, abtastet aus der LLM und gegebenenfalls die Reihenfolge der Anweisung in der Charge und die Wahl des Annotators im Pool. Wir nehmen dann den Modus der 4 Anmerkungen an und berechnen die Genauigkeit des Modus, wenn wir den Modus der 4 menschlichen Anmerkungen vorhersagen. Beachten Sie, dass dies wahrscheinlich eine Überschätzung der wirklichen Voreingenommenheit ist, die wir bekommen würden, wenn wir eine "unendliche" Anzahl von Cross-Annotationen hätten. Eine niedrige Verzerrung bedeutet, dass der Annotator die gleichen Vorlieben wie Menschen in Erwartung hat. Für den Fall des Menschen ist die Verzerrung per Definition Null. Beachten Sie, dass dies mit der statistischen Standardverzerrung zusammenhängt, da wir den Modus anstelle des Durchschnitts gegenüber Annotationen einnehmen und einen Verlust von 0: 1 anstelle des quadratischen Verlusts betrachten.
Varianz : Erwartete Übereinstimmung Eine einzelne automatische Präferenz und die wahrscheinlichste. Wir schätzen es genauso wie die "menschliche Vereinbarung" für den Menschen, dh den erwarteten Leave One -Fehler, wenn wir den Modus der 3 Anmerkungen mithilfe der 4. Annotation vorhersagen. Eine geringe Varianz bedeutet, dass der Annotator mit seiner Präferenz übereinstimmt. Wie bei der Verzerrung ist dies nicht genau die statistische Standardvarianz, da wir den Modus anstelle des Durchschnitts gegenüber Annotationen einnehmen und einen Verlust von 0: 1 anstelle des quadratischen Verlusts betrachten.
Beachten Sie, dass die "menschliche Vereinbarung" eng mit der Verzerrung und der Varianz zusammenhängt. Insbesondere misst die Varianz den Fehler, weil wir nur eine einzige Annotation verwenden, während die Vorspannung den nicht reduzierbaren Fehler für den aktuellen Annotator messen soll.
Proba. Bevorzugt länger : Dies ist die Wahrscheinlichkeit, dass der Annotator die längere Ausgabe bevorzugt, wenn einer der beiden Ausgänge signifikant länger ist als der andere (mehr als 30 Zeichen Unterschied).
In der vollständigen Tabelle bieten wir auch die folgenden Metriken an:
Proba. Bevorzugen Sie Listen : Dies ist die Wahrscheinlichkeit, dass der Annotator die Ausgabe bevorzugt, die eine Liste/Aufzählungszeichen enthält, wenn eine Ausgabe jedoch nicht die andere ausführt.
Proba. bevorzugen 1 : Dies ist die Wahrscheinlichkeit, dass der Annotator das erste der Ausgängepaare bevorzugt. Alle unsere vorgeschlagenen Annotatoren haben in der Eingabeaufforderung über die Ausgänge hinweg randomisieren, daher sollte dies 0,5 sein. Frühere Annotatoren wie lmsys und aviary tun dies nicht.
# Analyse : Dies ist die Anzahl der Beispiele, die der Annotator analysieren konnte.
Beachten Sie, dass, wenn die Varianz und die Verzerrung leer sind, dies bedeutet, dass wir nur eine einzige Annotation für jedes 648 -Beispiel aufgrund von Ressourcen- (Zeit- und Preis-) Einschränkungen durchgeführt haben. Dies erklärt, warum die #pareted 648 ist, sonst sollte es 2592 sein.
Insgesamt empfehlen wir die Verwendung von annotators_config=weighted_alpaca_eval_gpt4_turbo , wenn Sie die hohe Übereinstimmung mit dem Menschen und annotators_config=chatgpt_fn wünschen, wenn Sie ein knappes Budget haben.
Bei der Auswahl eines Annotators empfehlen wir Ihnen, Folgendes zu berücksichtigen (die ersten drei sind offensichtlich):
"Human agreement [%]""Price [$/1000 examples]""Time [seconds/1000 examples]""* corr." ca. > 0,7. Es ist wichtig, dass die Korrelation nicht zu niedrig ist, aber wir empfehlen nicht, sie als Hauptmetrik zu verwenden, da die Korrelation nur auf 9 Modellen berechnet wird."Proba. prefer longer" ca. <0,7. In der Tat haben wir festgestellt, dass der Großteil der Präferenz menschlicher Annotatoren für längere Antworten eine starke Verzerrung hat (wie die Hochleistung = 62,2 des "longest" Bewerters gezeigt, der immer die längste Ausgabe bevorzugt). Dies deutet darauf hin, dass es mehr eine Voreingenommenheit mit den menschlichen Annotatoren. Um zu vermeiden, dass Bestandteile mit starken Vorurteilen für die Länge haben, empfehlen wir, automatische Annotatoren mit weniger als 0,7 "proba. Bevorzugt länger" zu verwenden."Variance" ca. <0,2. Wir glauben, dass ein guter Bewerter so wenig Varianz wie möglich haben sollte, damit die Ergebnisse größtenteils reproduzierbar sind. Beachten Sie, dass Varianz in dem Fall wünschenswert sein kann, in dem wir Menschen simulieren, wie in Alpacafarm gezeigt. Wir haben die Annotatoren gefiltert, die diese Anforderungen in der obigen Tabelle nicht erfüllen (neben Menschen / Chatgpt / 003 / LMSYs zu Bezugszwecken). Für alle Ergebnisse siehe hier. Im Allgemeinen fanden wir, dass weighted_alpaca_eval_gpt4_turbo einen guten Kompromiss zwischen Qualität / Preis / Zeit / Varianz / Längenverzerrung darstellt.
Die oben genannten Metriken werden in Bezug auf Anmerkungen von Menschenarbeitern berechnet. Obwohl nützlich, sind diese Annotationen nicht perfekt, z. B. die Publikumsarbeiter bevorzugen oft den Stil gegenüber der Tatsache. Wir empfehlen den Benutzern daher, automatische Evaluatoren auf ihren eigenen Anweisungen und menschlichen Anmerkungen zu validieren. Details in Einschränkungen.
>>> alpaca_eval evaluate -- --help NAME
alpaca_eval evaluate - Evaluate a model based on its outputs. This is the default entrypoint if no command is specified.
SYNOPSIS
alpaca_eval evaluate <flags>
DESCRIPTION
Evaluate a model based on its outputs. This is the default entrypoint if no command is specified.
FLAGS
--model_outputs=MODEL_OUTPUTS
Type: Optional[Union]
Default: None
The outputs of the model to add to the leaderboard. Accepts data (list of dictionary, pd.dataframe, datasets.Dataset) or a path to read those (json, csv, tsv) or a function to generate those. Each dictionary (or row of dataframe) should contain the keys that are formatted in the prompts. E.g. by default `instruction` and `output` with optional `input`. If None, we just print the leaderboard.
-r, --reference_outputs=REFERENCE_OUTPUTS
Type: Union
Default: <func...
The outputs of the reference model. Same format as `model_outputs`. If None, the reference outputs are a specific set of Davinci 003 outputs on the AlpacaEval set:
--annotators_config=ANNOTATORS_CONFIG
Type: Union
Default: 'alpaca_eval_gpt4_turbo_fn'
The path the (or list of dict of) the annotator's config file. For details see the docstring of `PairwiseAnnotator`.
-n, --name=NAME
Type: Optional[Optional]
Default: None
The name of the model to add to the leaderboard. If None we check if `generator is in model_outputs` if not we use "Current model".
-o, --output_path=OUTPUT_PATH
Type: Union
Default: 'auto'
Path to the directory where the new leaderboard and the annotations should be stored. If None we don't save. If `auto` we use `model_outputs` if it is a path, and otherwise use the directory from which we call the script.
-p, --precomputed_leaderboard=PRECOMPUTED_LEADERBOARD
Type: Union
Default: 'auto'
The precomputed leaderboard or a path to it (json, csv, or tsv). The leaderboard should contain at least the column `win_rate`. If `auto` we will try to use the corresponding leaderboard for the reference outputs (only if in CORRESPONDING_OUTPUTS_LEADERBOARDS). If `None` we won't add other models from the leaderboard.
--is_overwrite_leaderboard=IS_OVERWRITE_LEADERBOARD
Type: bool
Default: False
Whether to overwrite the leaderboard if the model is already in it.
-l, --leaderboard_mode_to_print=LEADERBOARD_MODE_TO_PRINT
Type: Optional
Default: 'minimal'
The mode of the leaderboard to use. Only used if the precomputed leaderboard has a column `mode`, in which case it will filter the leaderboard by this mode. If None keeps all.
-c, --current_leaderboard_mode=CURRENT_LEADERBOARD_MODE
Type: str
Default: 'community'
The mode of the leaderboard for the current method.
--is_return_instead_of_print=IS_RETURN_INSTEAD_OF_PRINT
Type: bool
Default: False
Whether to return the metrics instead of printing the results.
-f, --fn_metric=FN_METRIC
Type: Union
Default: 'pairwise_to_winrate'
The function or function name in `metrics.py` that will be used to convert preference to metrics. The function should take a sequence of preferences (0 for draw, 1 for base win, 2 when the model to compare wins) and return a dictionary of metrics and the key by which to sort the leaderboard.
-s, --sort_by=SORT_BY
Type: str
Default: 'win_rate'
The key by which to sort the leaderboard.
--is_cache_leaderboard=IS_CACHE_LEADERBOARD
Type: Optional[Optional]
Default: None
Whether to save the result leaderboard to `precomputed_leaderboard`. If None we save only if max_instances not None. A preferred way of adding models to the leaderboard is to set `precomputed_leaderboard` to the previously saved leaderboard at `<output_path>/leaderboard.csv`.
--max_instances=MAX_INSTANCES
Type: Optional[Optional]
Default: None
The maximum number of instances to annotate. Useful for testing.
--annotation_kwargs=ANNOTATION_KWARGS
Type: Optional[Optional]
Default: None
Additional arguments to pass to `PairwiseAnnotator.annotate_head2head`.
-A, --Annotator=ANNOTATOR
Default: <class 'alpaca_eval.annotators.pairwise_evaluator.PairwiseAn...
The annotator class to use.
Additional flags are accepted.
Additional arguments to pass to `PairwiseAnnotator`.
>>> alpaca_eval evaluate_from_model -- --help NAME
alpaca_eval evaluate_from_model - Evaluate a model from HuggingFace or an API provider. This is a wrapper around `evaluate` which includes generating from a desired model.
SYNOPSIS
alpaca_eval evaluate_from_model MODEL_CONFIGS <flags>
DESCRIPTION
Evaluate a model from HuggingFace or an API provider. This is a wrapper around `evaluate` which includes generating from a desired model.
POSITIONAL ARGUMENTS
MODEL_CONFIGS
Type: Union
A dictionary or path (relative to `models_configs`) to a yaml file containing the configuration of the model to decode from. If a directory,we search for 'configs.yaml' in it. The keys in the first dictionary should be the generator's name, and the value should be a dictionary of the generator's configuration which should have the
FLAGS
-r, --reference_model_configs=REFERENCE_MODEL_CONFIGS
Type: Optional[Union]
Default: None
Same as in `model_configs` but for the reference model. If None, we use the default Davinci003 outputs.
-e, --evaluation_dataset=EVALUATION_DATASET
Type: Union
Default: <func...
Path to the evaluation dataset or a function that returns a dataframe. If None, we use the default evaluation
-a, --annotators_config=ANNOTATORS_CONFIG
Type: Union
Default: 'alpaca_eval_gpt4_turbo_fn'
Path to the annotators configuration or a dictionary. If None, we use the default annotators configuration.
-o, --output_path=OUTPUT_PATH
Type: Union
Default: 'auto'
Path to save the generations, annotations and leaderboard. If auto saves at `results/<model_name>`
-m, --max_instances=MAX_INSTANCES
Type: Optional[int]
Default: None
Maximum number of instances to generate and evaluate. If None, we evaluate all instances.
--is_strip_output=IS_STRIP_OUTPUT
Type: bool
Default: True
Whether to strip trailing and leading whitespaces from the outputs.
--is_load_outputs=IS_LOAD_OUTPUTS
Type: bool
Default: True
Whether to try to load outputs from the output path. If True and outputs exist we only generate outputs for instructions that don't have outputs yet.
-c, --chunksize=CHUNKSIZE
Type: int
Default: 64
Number of instances to generate before saving. If None, we save after all generations.
Additional flags are accepted.
Other kwargs to `evaluate`
NOTES
You can also use flags syntax for POSITIONAL ARGUMENTS
Um ein Modell zu bewerten, das Sie benötigen:
model_outputs angegeben sind. Standardmäßig verwenden wir die 805 Beispiele von Alpacaeval. Um Ausgänge für die Verwendung von AlpaCaeval zu berechnen: import datasets
eval_set = datasets . load_dataset ( "tatsu-lab/alpaca_eval" , "alpaca_eval" )[ "eval" ]
for example in eval_set :
# generate here is a placeholder for your models generations
example [ "output" ] = generate ( example [ "instruction" ])
example [ "generator" ] = "my_model" # name of your model Wenn Ihr Modell ein Umarmungsface -Modell oder ein Standard -API -Anbieter (OpenAI, Anthropic, Cohere) ist. Anschließend können Sie direkt alpaca_eval evaluate_from_model verwenden, um auch die Generierung von Ausgängen zu erledigen.
reference_outputs . Standardmäßig verwenden wir vorberechtigte Ausgänge von gpt4_turbo auf Alpakaeval. Wenn Sie ein anderes Modell oder einen anderen Datensatz verwenden möchten, führen Sie dieselben Schritte aus wie (1.).annotators_config angegeben ist. Wir empfehlen die Verwendung alpaca_eval_gpt4_turbo_fn . Weitere Optionen und Vergleiche finden Sie in dieser Tabelle. Abhängig vom Evaluator müssen Sie möglicherweise den entsprechenden API_Key in Ihrer Umgebung oder in den Client_Configs festlegen.All zusammen laufen:
alpaca_eval --model_outputs ' example/outputs.json '
--annotators_config ' alpaca_eval_gpt4_turbo_fn ' Wenn Sie keine dekodierten Ausgänge haben, können Sie evaluate_from_model verwenden, das für Sie die Dekodierung (Modell und Referenz) kümmert. Hier ist ein Beispiel:
# need a GPU for local models
alpaca_eval evaluate_from_model
--model_configs ' oasst_pythia_12b '
--annotators_config ' alpaca_eval_gpt4_turbo_fn ' Hier sind die model_configs und reference_model_configs (optional) Pfade zu einem Verzeichnis, das die Eingabeaufforderung, den Modellanbieter (hier Huggingface) und Decodierungsparameter angibt. Beispiele finden Sie in diesem Verzeichnis. Für alle Modellanbieter, die außerhalb des Boxs verfügbar sind, finden Sie hier.
caching_path zwischengespeichert. Anmerkungen werden somit nie neu berechnet, was Annotationen schneller, billiger macht und die Reproduzierbarkeit ermöglicht. Dies hilft auch bei der Bewertung verschiedener Modelle, wie viele Modelle die gleichen Ausgänge haben.>>> alpaca_eval make_leaderboard -- --help NAME
alpaca_eval make_leaderboard - Precompute and save an entire leaderboard for a given dataset / evaluator / set of models generations.
SYNOPSIS
alpaca_eval make_leaderboard <flags>
DESCRIPTION
Precompute and save an entire leaderboard for a given dataset / evaluator / set of models generations.
FLAGS
--leaderboard_path=LEADERBOARD_PATH
Type: Optional[Union]
Default: None
The path to save the leaderboard to. The leaderboard will be saved as a csv file, if it already exists it will
--annotators_config=ANNOTATORS_CONFIG
Type: Union
Default: 'alpaca_eval_gpt4_turbo_fn'
The path the (or list of dict of) the annotator's config file.
--all_model_outputs=ALL_MODEL_OUTPUTS
Type: Union
Default: <fu...
The outputs of all models to add to the leaderboard. Accepts data (list of dictionary, pd.dataframe, datasets.Dataset) or a path to read those (json, csv, tsv potentially with globbing) or a function to generate those. If the path contains a globbing pattern, we will read all files matching the pattern and concatenate them. Each dictionary (or row of dataframe) should contain the keys that are formatted in the prompts. E.g. by default `instruction` and `output` with optional `input`. It should also contain a column `generator` with the name of the current model.
-r, --reference_outputs=REFERENCE_OUTPUTS
Type: Union
Default: <func...
The outputs of the reference model. Same format as `all_model_outputs` but without needing `generator`. By default, the reference outputs are the 003 outputs on AlpacaEval set.
-f, --fn_add_to_leaderboard=FN_ADD_TO_LEADERBOARD
Type: Callable
Default: 'evaluate'
The function to use to add a model to the leaderboard. If a string, it should be the name of a function in `main.py`. The function should take the arguments: `model_outputs`, `annotators_config`, `name`, `precomputed_leaderboard`, `is_return_instead_of_print`, `reference_outputs`.
--leaderboard_mode=LEADERBOARD_MODE
Type: str
Default: 'verified'
The mode of the leaderboard to save all new entries with.
-i, --is_return_instead_of_print=IS_RETURN_INSTEAD_OF_PRINT
Type: bool
Default: False
Whether to return the metrics instead of printing the results.
Additional flags are accepted.
Additional arguments to pass to `fn_add_to_leaderboard`.
Wenn Sie mit einem einzigen Befehl (anstelle von mehreren Aufrufen alpaca_eval ) eine neue Rangliste erstellen möchten, können Sie Folgendes verwenden:
alpaca_eval make_leaderboard
--leaderboard_path < path_to_save_leaderboard >
--all_model_outputs < model_outputs_path >
--reference_outputs < reference_outputs_path >
--annotators_config < path_to_config.yaml >Wo:
leaderboard_path : Pfad, um die Rangliste zu retten. Die Rangliste wird als CSV -Datei gespeichert, wenn sie bereits vorhanden ist, wird sie angehängt.all_model_outputs : Der JSON -Pfad zu den Ausgängen aller Modelle, um der Rangliste (als einzelne Datei oder durch Kloben mehrerer Dateien) hinzuzufügen. Jedes Wörterbuch sollte die Schlüssel ( instruction und output ) enthalten, die in den Eingabeaufforderungen formatiert sind, und einen generator mit dem Namen des aktuellen Modells. Als Beispiel sehen Sie diese Datei.reference_outputs den Pfad zu den Ausgängen des Referenzmodells. Jedes Wörterbuch sollte die Schlüssel ( instruction und output ) enthalten, die in den Eingabeaufforderungen formatiert sind. Standardmäßig sind die Referenzausgänge die 003 Ausgänge auf dem Alpacaeval -Satz.annotators_config : Der Pfad zur Konfigurationsdatei des Annotators. Standardeinstellungen zu alpaca_eval_gpt4 . >>> alpaca_eval analyze_evaluators -- --help NAME
alpaca_eval analyze_evaluators - Analyze an evaluator and populates the evaluators leaderboard (agreement with human, speed, price,...).
SYNOPSIS
alpaca_eval analyze_evaluators <flags>
DESCRIPTION
Analyze an evaluator and populates the evaluators leaderboard (agreement with human, speed, price,...).
FLAGS
--annotators_config=ANNOTATORS_CONFIG
Type: Union
Default: 'alpaca_eval_gpt4_turbo_fn'
The path the (or list of dict of) the annotator's config file.
-A, --Annotator=ANNOTATOR
Default: <class 'alpaca_eval.annotators.pairwise_evaluator.PairwiseAn...
The annotator class to use.
--analyzer_kwargs=ANALYZER_KWARGS
Type: Optional[Optional]
Default: None
Additional arguments to pass to the analyzer.
-p, --precomputed_leaderboard=PRECOMPUTED_LEADERBOARD
Type: Union
Default: PosixPath('/Users/yanndubois/Desktop/GitHub/alpaca_eval/src/...
The precomputed (meta)leaderboard of annotators or a path to it (json, csv, or tsv).
--is_save_leaderboard=IS_SAVE_LEADERBOARD
Type: bool
Default: False
Whether to save the leaderboard (ie analyzed results).
--is_return_instead_of_print=IS_RETURN_INSTEAD_OF_PRINT
Type: bool
Default: False
Whether to return the leaderboard (ie analyzed results). If True, it will not print the results.
--is_overwrite_leaderboard=IS_OVERWRITE_LEADERBOARD
Type: bool
Default: False
Whether to overwrite the leaderboard if it already exists.
-m, --max_instances=MAX_INSTANCES
Type: Optional[Optional]
Default: None
The maximum number of instances to analyze.
--is_single_annotator=IS_SINGLE_ANNOTATOR
Type: bool
Default: False
Whether to analyze a single annotator. If True, will not be able to estimate the annotator's bias.
-l, --leaderboard_mode_to_print=LEADERBOARD_MODE_TO_PRINT
Type: str
Default: 'minimal'
The mode of the leaderboard to print.
-c, --current_leaderboard_mode=CURRENT_LEADERBOARD_MODE
Type: str
Default: 'minimal'
The mode of the leaderboard to save all new entries with.
-o, --output_path=OUTPUT_PATH
Type: Union
Default: 'auto'
Path to save the leaderboard and annotataions. If None, we don't save.
Additional flags are accepted.
Additional arguments to pass to `Annotator`.
Alpacaeval bietet eine einfache Möglichkeit, neue Evaluatoren herzustellen. Alles, was Sie brauchen, ist eine neue configs.yaml zu erstellen, die Sie dann als --annotators_config <path_to_config.yaml> an alpaca_eval übergeben. Hier sind einige Möglichkeiten, wie Sie einen neuen Bewerter erstellen können:
prompt_template der Konfigurationsdatei an. Die Pfade sind relativ zur Konfigurationsdatei.completions_kwargs in der Konfigurationsdatei an. Um alle verfügbaren Parameter anzuzeigen, beziehen Sie sich auf die DOCStrings der entsprechenden Funktion in dieser Datei, die von fn_completions in der Konfigurationsdatei angegeben wurde.model_name und die entsprechende Eingabeaufforderung in prompt_template an. Wenn das Modell von einem anderen Anbieter stammt, müssen Sie fn_completions ändern, die in die entsprechende Funktion in dieser Datei ordnen. Wir bieten fn_completions -Funktionen, um Modelle von OpenAI, Anthropic, Cohere oder Hugging Face zu verwenden. Um Pakete zu installieren, die für alle Anbieter benötigt werden, verwenden Sie pip install alpaca_eval[all] . Am einfachsten ist es, die Docstrings von SinglePairwiseAnnotator zu überprüfen. Hier sind einige wichtige:
Parameters
----------
prompt_template : path
A prompt that will be given to `fn_prompter` or path to the prompts. Path is relative to
`evaluators_configs/`
fn_completion_parser : callable or str
Function in `completion_parsers.py` to use for parsing the completions into preferences. For each completion,
the number of preferences should be equal to the batch_size if not we set all the preferences in that batch to
NaN.
completion_parser_kwargs : dict
Kwargs for fn_completion_parser.
fn_completions : callable or str
Function in `decoders.py` to use for decoding the output.
completions_kwargs : dict
kwargs for fn_completions. E.g. model_name, max_tokens, temperature, top_p, top_k, stop_seq.
is_randomize_output_order : bool
Whether to randomize output_1, output_2 when formatting.
batch_size : int
Number of examples that will be added in a single prompt.
Sobald Sie den Evaluator gemacht haben, können Sie ihn auch analysieren und mit dem folgenden Befehl dem Auslöser des Bewerters hinzufügen:
alpaca_eval analyze_evaluators --annotators_config ' <path_to_config.yaml> ' Um die Verzerrung und Varianz abzuschätzen, bewertet dies jedes Beispiel mit 4 Samen, dh 2,5K -Bewertung. Wenn Sie eine billigere Bewertung wünschen, können Sie einen einzelnen Saatgut verwenden --is_single_annotator True wodurch die Schätzung von Voreingenommenheit und Varianz überspringt.
Zusätzlich zu Fehlerbehebungen akzeptieren wir PRs für neue Modelle, Evaluatoren und Eval -Sets. Wir werden die Leaderboard -Website regelmäßig mit neuen Community -Beiträgen aktualisieren. Wir haben auch eine Support -Zwietracht für AlpaCaeval geschaffen, falls Sie auf Probleme stoßen und um Hilfe von der Community bitten möchten.
Bitte geben Sie zuerst das Repo an und installieren Sie das Paket von Source pip install -e .
Zunächst müssen Sie eine Modellkonfigurationsdefinition im Ordner models_configs hinzufügen. Als Beispiel können Sie sich das Falcon-7b-in-Struktur-Yaml ansehen. Bitte stellen Sie sicher, dass der Ordnername und der Schlüsselname in der YAML genau übereinstimmen.
Befolgen Sie dann bitte die Schritte zur Bewertung eines Modells, um die Inferenz auf dem Modell auszuführen, um Ausgänge auf dem Eval -Set zu erzeugen und das Modell gemäß einem der Evaluatoren zu bewerten. Ein Beispielbefehl kann aussehen wie:
alpaca_eval evaluate_from_model
--model_configs ' falcon-7b-instruct 'Nachdem Sie diesen Befehl ausgeführt haben, sollten Sie einen Ausgabemittel JSON und einen neuen Eintrag in der entsprechenden Ranglistendatei generieren sollen. Bitte erstellen Sie eine PR mit der Konfiguration, Ausgabedatei und aktualisierter Rangliste.
Konkret sollten Sie so etwas tun wie:
git clone <URL>src/alpaca_eval/models_configs/<model_name> und bewerten Sie es evaluate_from_model --model_configs '<model_name>'git add src/alpaca_eval/models_configs/ < model_name > # add the model config
git add src/alpaca_eval/leaderboards/ # add the actual leaderboard entry
git add src/alpaca_eval/metrics/weights # add the weights for LC
git add -f results/ < model_name > /model_outputs.json # force add the outputs on the dataset
git add -f results/ < model_name > / * /annotations.json # force add the evaluations from the annotators
git commit -m " Add <model_name> to AlpacaEval "
git push Hinweis: Wenn Sie Ausgaben außerhalb von AlpaCaEval generieren, sollten Sie immer noch eine Modellkonfiguration hinzufügen, jedoch mit fn_completions: null . Ein Beispiel finden Sie in dieser Konfiguration.
Ein verifiziertes Ergebnis in AlpaCaeval zeigt an, dass ein Kernwarter die Ausgänge aus dem Modell dekodiert und die Bewertung durchgeführt hat. Leider fehlt uns wir, die Alpakaeval-Betreuer, die Ressourcen, um alle Modelle zu überprüfen, und so werden wir dies nur für Modelle tun, die sich in der Top-5 der Rangliste befinden. Wir entschuldigen uns für etwaige Unannehmlichkeiten, die Ihr Verständnis verursachen und schätzen können. Um Ihr Modell zu verifizieren, befolgen Sie bitte die folgenden Schritte:
@yann über Discord oder senden Sie uns eine E -Mail, wenn Sie unsere E -Mail haben, und liefern eine kurze Begründung dafür, warum Ihr Modell überprüft werden sollte.alpaca_eval evaluate_from_model --model_configs '<your_model_name>' ausgeführt werden, ohne dass eine lokale GPU erforderlich ist.alpaca_eval evaluate_from_model --model_configs '<your_model_name>' aus, aktualisieren die Ergebnisse und informieren Sie, damit Sie die temporären Schlüssel widerrufen können.Beachten Sie, dass wir dasselbe Modell nicht neu bewerten. Aufgrund der Abtastungsvarianz können sich die Ergebnisse leicht von Ihren anfänglichen unterscheiden. Wir werden Ihre früheren Community -Ergebnisse durch die verifizierten ersetzen.
Bitte folgen Sie zuerst den Anweisungen bei der Erstellung eines neuen Bewerters. Sobald Sie die Annotator -Konfiguration erstellt haben, bitten wir Sie, eine neue Rangliste für den Annotator zu erstellen, indem Sie die minimale Modelle bewerten. Die Ausgänge für diese Modelle finden Sie durch Herunterladen von alpaca_eval_all_outputs.json.
alpaca_eval make_leaderboard
--leaderboard_path src/alpaca_eval/leaderboards/data_AlpacaEval/ < evaluator > _leaderboard.csv
--all_model_outputs alpaca_eval_all_outputs.json
--annotators_config < evaluator_config >Erstellen Sie dann bitte eine PR mit der Annotator -Konfiguration und dem CSV von Bohrlochboard.
Um einen neuen Eval -Set beizutragen, müssen Sie zunächst eine Reihe von Textanweisungen angeben. Anschließend müssen Sie eine Reihe von Referenzausgängen angeben (Modell-Win-Raten werden mit dieser Referenz berechnet). Zur einfachen Gebrauchsanwendung können Sie die Standard-Text-Davinci-003-Referenzkonfiguration verwenden.
Legen Sie diese zusammen in einen JSON, wobei jeder Eintrag die instruction , output und generator spezifiziert. Sie können sich als Handbuch auf alpaca_eval.json ansehen (das Feld dataset ist nicht erforderlich).
Schließlich bitten wir, dass Sie eine minimale Rangliste für dieses neue Bewertungssatz erstellen. Sie können dies mit Folgendes tun:
alpaca_eval make_leaderboard
--leaderboard_path < src/alpaca_eval/leaderboards/data_AlpacaEval/your_leaderboard_name.csv >
--all_model_outputs alpaca_eval_all_outputs.json
--reference_outputs < path_to_json_file >Bitte senden Sie eine PR mit dem Eval -Set JSON und der entsprechenden Rangliste CSV.
Derzeit erlauben wir unterschiedliche Abschlussfunktionen, z. B. openai , anthropic , huggingface_local , huggingface_hub_api ... Wenn Sie eine neue Fertigstellung / API beitragen möchten, um Inferenz durchzuführen, befolgen Sie diese Schritte:
<name>_completions(prompts : Sequence[str], model_name :str, ... ) im Decoder -Ordner. Diese Funktion sollte als Argument die Eingabeaufforderungen + KWARGs erfolgen und die Fertigstellungen zurückgeben. Bitte sehen Sie sich andere Abschlussfunktionen im Verzeichnis für Vorlagen an. ZB Huggingface_local_completions oder anthropisch.<name>_completions und Abhängigkeiten in init . Auch hier können Sie dem Beispiel von Huggingface_local_Completions folgenalpaca_eval evaluate_from_model --model_configs '<model_configs>'Fühlen Sie sich frei, eine PR früh zu beginnen. Wir können dabei Hilfe leisten!
Die Alpaka -Eval -Bewertungspipeline haben wie andere aktuelle Bewerter wichtige Einschränkungen und sollten daher nicht als Ersatz für die menschliche Bewertung in wichtigen Einstellungen verwendet werden, z. B. um zu entscheiden, ob ein Modell bereit ist, bereit zu sein. Diese können im Großen und Ganzen in 3 Kategorien zusammengefasst werden:
Die Anweisungen sind möglicherweise nicht realiert für die Realität : Das Alpakaer-Set enthält Beispiele aus einer Vielzahl von Datensätzen (Selbststruktur, offen-assistierender, Vicuna, Koala, HH-RLHF), die möglicherweise nicht repräsentativ für realistische und fortgeschrittene Anwendungen besserer Modelle wie GPT4 repräsentieren. Dies lässt die besten geschlossenen Modelle (GPT4 / Claude / Chatgpt / ...) den offenen Modellen ähnlicher erscheinen als das, was sie sind. In der Tat scheinen diese geschlossenen Modelle auf viel vielfältigere Daten vorab/finationstuniert zu sein. In diesem Blog finden Sie vorläufige Ergebnisse zu komplexeren Anweisungen. Beachten Sie jedoch, dass wir in Alpacafarm gezeigt haben, dass Win-Rates in unserem Bewertungssatz stark korreliert (0,97 R2) mit Win-Rates für Anweisungen aus Benutzerinteraktionen mit der Alpaca-Demo. Darüber hinaus zeigt die Alpakaevale Rangliste eine größere Lücke zwischen den offenen Modellen und OpenAI -Modellen als andere Bestenlisten (z. B. LMSYs).
Vorurteile automatischer Annotatoren : Die automatischen Annotatoren von Rohen scheinen implizite Vorurteile zu haben. Insbesondere haben wir festgestellt, dass sie dazu neigen, längere Ausgänge und Ausgänge zu bevorzugen, die Listen enthalten (z. B. 0,68 / 0,69 für alpaca_eval_gpt4 und 0,62 / 0,58 für claude ). Obwohl wir feststellten, dass Menschen ähnliche Verzerrungen haben (0,64 / 0,61), glauben wir, dass dies eher eine Einschränkung der menschlichen Annotationspipeline sein könnte, die wir verwendet haben, als eine wahre menschliche Vorurteile. Allgemeiner stellten wir durch qualitative Analyse fest, dass automatische Annotatoren den Stil des Ausgangs mehr Bedeutung haben als der Inhalt (z. B. Tatsache). Schließlich stellten wir fest, dass automatische Bewerter tendenziell aus ähnlichem (wahrscheinlich auf denselben Daten geschult) Ausgänge bevorzugen, wie durch den großen Unterschied zwischen Chatgpt/GPT4 auf claude 's und alpaca_eval_gpt4 Rangliste vorgeschlagen. Beachten Sie, dass die Längenverzerrung in unseren längenkontrollierten Win-Raten teilweise gemindert wird.
Mangelnde Sicherheitsbewertung : Wichtig ist, dass AlpaCaeval nur die Anweisungsfunktionen von Modellen und nicht den Schaden bewertet, den sie verursachen könnten (z. B. giftiges Verhalten oder Verzerrung). Infolgedessen sollte die kleine Lücke zwischen dem aktuellen Chatgpt und den besten Open -Source -Modellen nicht so interpretiert werden, als ob letztere bereit sind, bereitzustellen.
Über diese Einschränkungen hinsichtlich der Bewertungspipelines hinaus gibt es auch Einschränkungen hinsichtlich unserer Validierung der Bewerter und unserem vorgeschlagenen Ansatz zur Auswahl der Bewertungssätze.
Erstens leidet unsere Validierung von Evaluatoren, die auf menschlichen Querversorgungen basieren, unter den folgenden Einschränkungen: (1) Wir haben qualitativ festgestellt, dass unsere Publikumspersonal auch einen Stil wie Länge und Vorhandensein von Listen gegenüber der Tatsache bevorzugen; (2) Dies bestätigt nicht, ob Win-Rates gegen ein Referenzmodell in erster Linie eine gute Bewertungsstrategie ist. (3) Präferenzen von 16 Menschenarbeitern sind nicht repräsentativ für die Präferenzen aller Menschen.
Zweitens leidet unser vorgeschlagener Ansatz zur Auswahl der Bewertungssätze auf der Grundlage statistischer Macht unter den folgenden Einschränkungen: (1) Die statistische Leistung sorgt nicht für die richtige Richtung, z. B. können Sie einen unnatürlichen Satz von Anweisungen haben, bei denen Alpaka "besser als besseres Modell ausführt". und (2) Dies kann die Benutzer dazu drängen, Daten auszuwählen, um die Hypothese zu unterstützen, die sie validieren möchten.
Länge kontrollierte Alpa-Visualisierungen:
Länge kontrollierte Alpakaevale Entwicklung:
Das Notizbuch zeigt unterschiedliche Optionen, die wir in Betracht gezogen haben, um die Länge der automatischen Annotatoren zu mildern.
Hier fassen wir kurz die Hauptergebnisse zusammen. Nämlich:
win_rate(m,b) = 1 - win_rate(b,m) in [0,1] and win_rate(m,m) = 0.5 . This is shown in the plot below. 
Finally, note that we are only controlling for length bias. There are other known biases that we are not controlling for, such as the fact that auto-annotators prefer outputs similar to their model. Although we could control for that, in practice we have found that to be less of an issue than length bias. For two reasons (1) this mostly a single model in the leaderboard because fine-tuning on outputs from the auto-annotator doesn't seem to have doesn't seem to impact the win-rate as much, and (2) the bias is actually less strong that what one could think. For example we show below a subset of the leaderboards auto-annotated by three different models, and we see that the ranking of models is exactly the same. In particular, claude-3-opus prefers gpt4_preview , and mistral-large prefers the former two.
Caution : all the following results are about AlpacaEval 1.0 and have not been updated since
Analyzing evaluators:
As we saw in the evaluator's leaderboard, there are many metrics to consider when selecting an evaluator, eg the quality, price, and speed. To assist with selection of the evaluator we provide a few functions to plot those metrics. The following shows for example the price/time/agreement of the different evaluators.
Here we see that alpaca_eval_gpt4 performs very well and is better than humans on all the considered metrics.
Previously we only considered the agreement with human annotators overall. An additional validation that one could do is checking whether making a leaderboard using our automatic annotator gives similar results as a leaderboard from humans. To enable such analysis, we release human annotations of outputs from 22 methods from AlpacaFarm => 22*805 = ~18K annotations. As a result we can test the correlation between the win-rates of the 22 models as evaluated by the humans and our automatic annotator. Note that this is arguably a better way of selecting an automatic evaluator than using "human agreement [%]" but is expensive given that it requires 18K annotations. The plot below shows such correlation for the alpaca_eval_gpt4 evaluator.
We see that the alpaca_eval_gpt4 leaderboard is highly correlated (0.94 Pearson correlation) to the leaderboard from humans, which further suggests that automatic evaluation is a good proxy for human evaluation. For the code and more analysis, see this notebook, or the colab notebook above.
Caution : all the following results are about AlpacaEval 1.0 and have not been updated since.
Making evaluation sets:
When creating an evaluation set there are two main factors to consider: how much data to use? and what data?
One way of answering those question is by considering a leaderboard of models that you believe are of different quality and checking what and how much data is needed to distinguish between them in a statistically significant way. We will do so below using a paired t-test to test if the difference in win-rates between every pair of models is statistically significant.
First, let us consider the question of how much data to use. Below we show the number of random samples needed from AlpacaEval for the paired t-test to give a p-value < 0.05 for each pair of models in the minimal alpaca_eval_gpt4 leaderboard. Grey cells correspond to pairs that are not significantly different on the 805 samples. y- and x-axis are ordered by the win-rate of the first and second model respectively.
We see that most models can already be distinguished with 50 samples, and that 150 samples allows distinguishing the majority of pairs (74 out of 78). This suggests that we can decrease the evaluation set size by a factor of 4 when testing two models that have similar performance gaps as those on the minimal alpaca_eval_gpt4 leaderboard.
The second question is what data to use. Again we can try to answer this question from a statistical power perspective: what data allows to best distinguish between models. Let's consider this for all the datasets that are part of AlpacaEval, but let us control for the size of the evaluation sets as we only care about the quality of the data. The following plot shows the p-values from the paired t-test of each pairs of models on 80 examples of each subset of AlpacaEval.
We see for example that the self-instruct dataset yields the least statistical power, which suggests that one could remove this dataset from the evaluation set. The exact reason should be analyzed in future work. For the code and more analysis see this notebook, or the colab notebook above.
Please consider citing the following depending on what you are using and referring to:
alpaca_eval (this repo). Specify whether you are using AlpacaEval or AlpacaEval 2.0. For length-controlled win-rates see below.alpaca_eval_length .dubois2023alpacafarm (AlpacaFarm)alpaca_eval and self-instruct, open-assistant, vicuna, koala, hh-rlhf.Here are the bibtex entries:
@misc{alpaca_eval,
author = {Xuechen Li and Tianyi Zhang and Yann Dubois and Rohan Taori and Ishaan Gulrajani and Carlos Guestrin and Percy Liang and Tatsunori B. Hashimoto },
title = {AlpacaEval: An Automatic Evaluator of Instruction-following Models},
year = {2023},
month = {5},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {url{https://github.com/tatsu-lab/alpaca_eval}}
}
@article{dubois2024length,
title={Length-Controlled AlpacaEval: A Simple Way to Debias Automatic Evaluators},
author={Dubois, Yann and Galambosi, Bal{'a}zs and Liang, Percy and Hashimoto, Tatsunori B},
journal={arXiv preprint arXiv:2404.04475},
year={2024}
}
@misc{dubois2023alpacafarm,
title={AlpacaFarm: A Simulation Framework for Methods that Learn from Human Feedback},
author={Yann Dubois and Xuechen Li and Rohan Taori and Tianyi Zhang and Ishaan Gulrajani and Jimmy Ba and Carlos Guestrin and Percy Liang and Tatsunori B. Hashimoto},
year={2023},
eprint={2305.14387},
archivePrefix={arXiv},
primaryClass={cs.LG}
}
Length controlled (LC) win-rates are a debiased version of the win-rates that control for the length of the outputs.
The main idea is that for each model we will fit a logistic regression to predict the preference of the autoannotator given: (1) the instruction, (2) the model, and (3) the difference of length between the baseline and model output. Given such a logistic regression we can then try to predict the counterfactual "what would the preference be if the model's output had the same length as the baseline" by setting the length difference to 0. By averaging over this length-controlled preference, we then obtain the length-controlled win-rate. The exact form of the logistic regression is taken such that the interpretation of LC win rates is similar to the raw win rates, for example for any model m1 and m2 we have win_rate(m1, m2) = 1 - win_rate(m2, m1) in [0,100] and win_rate(m1, m1) = 0.5 . Length controlled win-rates increase the correlation between AlpacaEval's leaderboard and Chat Arena from 0.93 to 0.98 Spearman correlation, while significantly decreasing the length gameability of the annotator . For more information and results about length controlled win-rates see this notebook.
This idea of estimating the controlled direct effect, by predicting the outcome while conditioning on the mediator (the length difference), is common in statistical inference.
To get LC win rates on previously annotated models, you can use the following command:
pip install -U alpaca_eval
alpaca_eval --model_outputs … --is_recompute_metrics_only TrueAlpacaEval 2.0 is a new version of AlpacaEval. Here are the differences:
gpt4_turbo : we upgraded the baseline from text-davinci-003 to gpt4_turbo to make the benchmark more challenging and have a metric that better reflects the current state of the art.weighted_alpaca_eval_gpt4_turbo : we improved the annotator in quality and price. First, we use the gpt4_turbo model for annotating, which is approximately 2x cheaper than gpt4 . Second, we changed the prompt such that the model outputs a single token, which further reduced cost and speed. Finally, instead of using a binary preference, we used the logprobs to compute a continuous preference, which gives the final weighted win-rate. Note that the latter two changes had the surprising effect of decreasing the annotators' length biased. By default, AlpacaEval 2.0 will be used from pip install alpaca_eval==0.5 . If you wish to use the old configs by default, you can set IS_ALPACA_EVAL_2=False in your environment.
As part of AlpacaEval, we release the following data:
text-davinci-003 reference on the AlpacaFarm evaluation set. Annotations are from a pool of 16 crowd workers on Amazon Mechanical Turk. The different models are: 6 from OpenAI, 2 SFT models from AlpacaFarm, 13 RLHF methods from AlpacaFarm, and LLaMA 7B.For more details about the human annotations refer to the AlpacaFarm paper.
AlpacaEval is an improvement and simplification of the automatic pairwise preference simulator from AlpacaFarm. Outside AlpacaFarm, you should be using AlpacaEval. Here are the main differences:
{instruction}nn{input} . This affects 1/4 of the examples in the AlpacaFarm evaluation set (the self-instruct subset). This simplification provides a more fair comparison for models that were not trained by distinguishing between the two fields.text-davinci-003 ), so the results on AlpacaEval are not comparable to those on AlpacaFarm even for examples that had no input field.--anotators_config 'alpaca_farm' and --p_label_flip 0.25 when creating an evaluator. There have been several work that propose new automatic annotators for instruction-following models. Here we list the ones that we are aware of and discuss how they differ from ours. We evaluated all of those in our evaluator's leaderboard.
lmsys_gpt4 ) evaluates the pair by asking the annotator a score from 1-10 for each output, and then selecting the output with the highest score as preferred. They do not randomize over output order and they ask an explanation after the score. Overall, we found that this annotator has strong bias towards longer outputs (0.74) and relatively low correlation with human annotations (63.2).alpaca_farm_greedy_gpt4 ) evaluates the pair by directly asking the annotator which output it prefers. Furthermore, it batches 5 examples together to amortize the length of the prompt and randomizes the order of outputs. Overall, we found that this annotator has much less bias towards longer outputs (0.60) and is faster (878 seconds/1000 examples) than others. It has a slightly higher correlation with the majority of human annotations (66.4) than humans themselves (65.7). However, it is more expensive ($15.3/1000 examples) and doesn't work with very long outputs given the batching.aviary_gpt4 ) asks the annotator to order the output by its preference, rather than simply selecting the preferred output. It does not randomize the order of outputs and uses high temperature for decoding (0.9). Overall, we found that this annotator has relatively strong bias towards longer outputs (0.70) and very high correlation with human annotations (69.1). By decreasing the temperature and randomizing the order of outputs, we further improved the correlation to 69.8 ( improved_aviary_gpt4 ) but this further increased the length bias to 0.73. Our alpaca_eval_gpt4 is a mix between the AlpacaFarm and Aviary annotators. It asks the annotator to order the outputs by preference, but it uses temperature 0, randomizes over outputs, and made some modifications to the prompt to decrease length bias to 0.68.
Other related work include recent papers which analyze automatic evaluators. Zum Beispiel:
For all models you can find the auto-annotations under results/<model_name>/*/annotations.json . The annotations have the following columns:
instruction : the promptgenerator_1 : the baseline modeloutput_1 : the output of the baseline modelgenerator_2 : the model being evaluatedoutput_2 : the output of the model being evaluatedannotator : the auto-annotatorpreference : the result of the auto-annotator. This is a float between 1 and 2. Closer to 1 means that the auto-annotator prefers output_1 , closer to 2 means that it prefers output_2 . For AlpacaEval 2.0, preference-1 corresponds to the probability of output_1 being preferred. For AlpacaEval 1.0, preference is 1 if output_1 is preferred, 2 if output_2 is preferred, and 1.5 if they are the same. The win rate is always (preference -1).mean() .raw_completion : the raw output of the auto-annotator. This is field contains the completions before de-randomization of the order between output_1 and output_2 ! It is thus much harder to interpret, see below for more information.Chain of thought
For some annotators, eg alpaca_eval_cot_gpt4_turbo_fn we use chain of thought reasoning to make the models preferences more interpretable. Those can then be found under concise_explanation . To interpret them, you should also look at referenced_models which translates the temporary model name (in the prompt) to the actual output. Below, we provide more explanation as to what is happening behind the scenes.
You can check the raw_annotations["concise_explanation] column in annotations.json (eg here) which contains the chain of thought reasoning of the auto annotator. Note that the raw_annotations is not modified by the randomization of the order of the outputs. In particular, "m" and "M" can sometime refer to the first model (the reference) and sometime to the second model (the model being evaluated). To understand which model is being referred to, you should use the column preference and ordered_models . To make it easier we add a column "referenced_models" mapping the model names to the corresponding outputs. For example in the following annotation we see that the preference is 1.0 (ie output_1 ) and corresponds to model M in concise_explanation (see ordered_models ).
{
"instruction" : " How did US states get their names? " ,
"output_1" : " The names of U.S. states are derived from a variety of languages and sources, including indigenous American languages, European languages (primarily English, Spanish, and French), as well as other historical influences. Here is a brief overview of how some states got their names: nn 1. **Indigenous American Languages**: Many state names come from Native American words or names of tribes, often from the languages of the indigenous peoples who lived in or near those areas. n - **Alabama**: Possibly derived from the Choctaw language, meaning " thicket clearers. "n - **Connecticut**: From a Mohegan-Pequot word meaning " long tidal river. "n - **Massachusetts**: [...] " ,
"generator_1" : " gpt4_1106_preview " ,
"dataset" : " helpful_base " ,
"output_2" : " The names of the 50 U.S. states come from a variety of sources, including Native American languages, European languages, and historical figures. Here's a brief overview of how some states got their names: nn 1. Native American origins: Many states have names derived from Native American languages. For example, Alabama comes from the Choctaw word " Albah amo, " meaning " plant gatherers " or " herb gatherers. " Similarly, the name Mississippi comes from the Ojibwe word " Misi-ziibi, " meaning " great river. "nn 2. European languages: [...]. " ,
"generator_2" : " gpt4 " ,
"annotator" : " alpaca_eval_cot_gpt4_turbo_fn " ,
"preference" : 1.0 ,
"raw_completion" : {
"concise_explanation" : " Model M provided a more detailed and structured response, including bold headings for each category and a wider range of examples. It also included additional categories such as 'Other European Languages' and 'Combination of Languages and Influences', which added depth to the explanation. Model m's response was accurate but less comprehensive and lacked the clear structure found in Model M's output. " ,
"ordered_models" : [
{
"model" : " M " ,
"rank" : 1
},
{
"model" : " m " ,
"rank" : 2
}
]
},
"referenced_models" : {
"M" : " output_1 " ,
"m" : " output_2 "
}
}chatgpt_fn that anyone can use (no waiting lists).chatgpt_fn or alpaca_eval_gpt4_fn .
