> ## Documentation Index > Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt > Use this file to discover all available pages before exploring further. # Démarrage rapide du Leaderboard > Découvrez comment utiliser le démarrage rapide du Leaderboard avec W&B Weave Ceci est un notebook interactif. Vous pouvez l’exécuter localement ou utiliser les liens ci-dessous : * [Ouvrir dans Google Colab](https://colab.research.google.com/github/wandb/docs/blob/main/weave/cookbooks/source/leaderboard_quickstart.ipynb) * [Voir la source sur GitHub](https://github.com/wandb/docs/blob/main/weave/cookbooks/source/leaderboard_quickstart.ipynb)

Démarrage rapide du Leaderboard

Ce guide de démarrage rapide vous montre comment utiliser le Leaderboard de W\&B Weave pour comparer les performances de modèles sur plusieurs jeux de données et fonctions de score. À l’issue de ce guide, vous aurez publié un leaderboard qui classe plusieurs modèles selon un ensemble commun d’évaluations. Vous pourrez alors identifier le modèle le plus performant pour chaque métrique. Ce guide s’adresse aux développeurs qui savent déjà exécuter des évaluations Weave et qui souhaitent comparer les résultats côte à côte. Plus précisément, vous allez : 1. Générer un jeu de données fictif de codes postaux. 2. Écrire quelques fonctions de score et évaluer un modèle de référence. 3. Appliquer ces techniques pour évaluer une matrice croisant modèles et évaluations. 4. Consulter le leaderboard dans l’interface de Weights & Biases.

Étape 1 : Générer un jeu de données de faux codes postaux

Commencez par créer une fonction `generate_dataset_rows` qui génère une liste de fausses données de codes postaux. Ce jeu de données synthétique fournit au leaderboard un ensemble cohérent d’entrées et de valeurs attendues sur lequel évaluer chaque modèle. ```python lines theme={"system"} import json from openai import OpenAI from pydantic import BaseModel class Row(BaseModel): zip_code: str city: str state: str avg_temp_f: float population: int median_income: int known_for: str class Rows(BaseModel): rows: list[Row] def generate_dataset_rows( location: str = "United States", count: int = 5, year: int = 2022 ): client = OpenAI() completion = client.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "You are a helpful assistant."}, { "role": "user", "content": f"Please generate {count} rows of data for random zip codes in {location} for the year {year}.", }, ], response_format={ "type": "json_schema", "json_schema": { "name": "response_format", "schema": Rows.model_json_schema(), }, }, ) return json.loads(completion.choices[0].message.content)["rows"] python import weave weave.init("leaderboard-demo") ```

Étape 2 : Écrire les fonctions de score

Écrivez ensuite trois fonctions de score. Chaque évaluateur évalue un aspect différent de la sortie du modèle, ce qui permet au leaderboard de classer les modèles selon plusieurs dimensions de qualité distinctes : 1. `check_concrete_fields` : vérifie si la sortie du modèle correspond à la ville et à l’État attendus. 2. `check_value_fields` : vérifie si la sortie du modèle s’écarte de moins de 10 % de la population et du revenu médian attendus. 3. `check_subjective_fields` : utilise un LLM pour vérifier si la sortie du modèle correspond au champ "known for" attendu. ```python lines theme={"system"} @weave.op def check_concrete_fields(city: str, state: str, output: dict): return { "city_match": city == output["city"], "state_match": state == output["state"], } @weave.op def check_value_fields( avg_temp_f: float, population: int, median_income: int, output: dict ): return { "avg_temp_f_err": abs(avg_temp_f - output["avg_temp_f"]) / avg_temp_f, "population_err": abs(population - output["population"]) / population, "median_income_err": abs(median_income - output["median_income"]) / median_income, } @weave.op def check_subjective_fields(zip_code: str, known_for: str, output: dict): client = OpenAI() class Response(BaseModel): correct_known_for: bool completion = client.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "You are a helpful assistant."}, { "role": "user", "content": f"My student was asked what the zip code {zip_code} is best known best for. The right answer is '{known_for}', and they said '{output['known_for']}'. Is their answer correct?", }, ], response_format={ "type": "json_schema", "json_schema": { "name": "response_format", "schema": Response.model_json_schema(), }, }, ) return json.loads(completion.choices[0].message.content) ```

Étape 3 : Créer une évaluation

Définissez ensuite une évaluation à partir des données fictives et des fonctions de score. L’objet `Evaluation` associe le jeu de données aux évaluateurs, ce qui vous permet d’exécuter n’importe quel modèle sur le même benchmark. ```python lines theme={"system"} rows = generate_dataset_rows() evaluation = weave.Evaluation( name="United States - 2022", dataset=rows, scorers=[ check_concrete_fields, check_value_fields, check_subjective_fields, ], ) ```

Étape 4 : Évaluer un modèle de référence

Évaluez maintenant un modèle de référence qui renvoie une réponse statique. Établir une référence vous fournit un point de comparaison dans le leaderboard, qui vous permet de mesurer les progrès de chaque modèle suivant par rapport à une implémentation statique. ```python lines theme={"system"} @weave.op def baseline_model(zip_code: str): return { "city": "New York", "state": "NY", "avg_temp_f": 50.0, "population": 1000000, "median_income": 100000, "known_for": "The Big Apple", } await evaluation.evaluate(baseline_model) ```

Étape 5 : créer d’autres modèles

Créez maintenant deux autres modèles à comparer à la référence. L’un reçoit le code postal sans prompt supplémentaire, l’autre un prompt structuré. En les comparant dans le leaderboard, vous verrez l’impact du contexte fourni par le prompt sur la qualité des réponses. ```python lines theme={"system"} @weave.op def gpt_4o_mini_no_context(zip_code: str): client = OpenAI() completion = client.chat.completions.create( model="gpt-4o-mini", messages=[{"role": "user", "content": f"""Zip code {zip_code}"""}], response_format={ "type": "json_schema", "json_schema": { "name": "response_format", "schema": Row.model_json_schema(), }, }, ) return json.loads(completion.choices[0].message.content) await evaluation.evaluate(gpt_4o_mini_no_context) python @weave.op def gpt_4o_mini_with_context(zip_code: str): client = OpenAI() completion = client.chat.completions.create( model="gpt-4o-mini", messages=[ { "role": "user", "content": f"""Please answer the following questions about the zip code {zip_code}: 1. What is the city? 2. What is the state? 3. What is the average temperature in Fahrenheit? 4. What is the population? 5. What is the median income? 6. What is the most well known thing about this zip code? """, } ], response_format={ "type": "json_schema", "json_schema": { "name": "response_format", "schema": Row.model_json_schema(), }, }, ) return json.loads(completion.choices[0].message.content) await evaluation.evaluate(gpt_4o_mini_with_context) ```

Étape 6 : créer d’autres évaluations

Évaluez maintenant une matrice croisant modèles et évaluations. En exécutant chaque modèle sur plusieurs jeux de données (différentes régions et années), vous obtenez les données dont le leaderboard a besoin pour classer les modèles selon plusieurs conditions. ```python lines theme={"system"} scorers = [ check_concrete_fields, check_value_fields, check_subjective_fields, ] evaluations = [ weave.Evaluation( name="United States - 2022", dataset=weave.Dataset( name="United States - 2022", rows=generate_dataset_rows("United States", 5, 2022), ), scorers=scorers, ), weave.Evaluation( name="California - 2022", dataset=weave.Dataset( name="California - 2022", rows=generate_dataset_rows("California", 5, 2022) ), scorers=scorers, ), weave.Evaluation( name="United States - 2000", dataset=weave.Dataset( name="United States - 2000", rows=generate_dataset_rows("United States", 5, 2000), ), scorers=scorers, ), ] models = [ baseline_model, gpt_4o_mini_no_context, gpt_4o_mini_with_context, ] for evaluation in evaluations: for model in models: await evaluation.evaluate( model, __weave={"display_name": evaluation.name + ":" + model.__name__} ) ```

Étape 7 : consulter le leaderboard

Maintenant que les résultats de l’évaluation sont publiés, vous pouvez les regrouper dans un leaderboard pour les comparer côte à côte. Pour créer un leaderboard, accédez à l’onglet leaderboard dans l’interface utilisateur, puis cliquez sur **Create Leaderboard**. Vous pouvez également générer un leaderboard directement depuis Python : ```python lines theme={"system"} from weave.flow import leaderboard from weave.trace.ref_util import get_ref spec = leaderboard.Leaderboard( name="Zip Code World Knowledge", description=""" This leaderboard compares the performance of models in terms of world knowledge about zip codes. ### Columns 1. **State Match against `United States - 2022`**: The fraction of zip codes that the model correctly identified the state for. 2. **Avg Temp F Error against `California - 2022`**: The mean absolute error of the model's average temperature prediction. 3. **Correct Known For against `United States - 2000`**: The fraction of zip codes that the model correctly identified the most well known thing about the zip code. """, columns=[ leaderboard.LeaderboardColumn( evaluation_object_ref=get_ref(evaluations[0]).uri(), scorer_name="check_concrete_fields", summary_metric_path="state_match.true_fraction", ), leaderboard.LeaderboardColumn( evaluation_object_ref=get_ref(evaluations[1]).uri(), scorer_name="check_value_fields", should_minimize=True, summary_metric_path="avg_temp_f_err.mean", ), leaderboard.LeaderboardColumn( evaluation_object_ref=get_ref(evaluations[2]).uri(), scorer_name="check_subjective_fields", summary_metric_path="correct_known_for.true_fraction", ), ], ) ref = weave.publish(spec) ``` Vous disposez désormais d’un leaderboard publié dans Weave, qui classe chaque modèle en fonction des trois évaluations et des métriques de notation que vous avez définies. Depuis l’interface de Weights & Biases, vous pouvez examiner les scores de chaque modèle, explorer en détail chaque run d’évaluation et comparer les futures itérations de vos modèles à la même référence.