> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Démarrage rapide du Leaderboard

> Découvrez comment utiliser Démarrage rapide du Leaderboard avec W&B Weave

<Note>
  Il s’agit d’un notebook interactif. Vous pouvez l’exécuter en local 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)
</Note>

<div id="leaderboard-quickstart">
  # Démarrage rapide du Leaderboard
</div>

Ce démarrage rapide vous montre comment utiliser le leaderboard W\&B Weave pour comparer les performances de modèles sur plusieurs jeux de données et avec plusieurs fonctions de score. À la fin, vous aurez publié un leaderboard qui classe plusieurs modèles à partir d’un ensemble commun d’évaluations. Vous pourrez ensuite identifier le modèle le plus performant pour chaque métrique. Ce guide s’adresse aux développeurs déjà familiers avec l’exécution d’é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 factice de codes postaux.
2. Créer quelques fonctions de score et évaluer un modèle de référence.
3. Utiliser ces techniques pour évaluer une matrice de modèles et d’évaluations.
4. Consulter le leaderboard dans l’interface Weave.

<div id="step-1-generate-a-dataset-of-fake-zip-code-data">
  ## Étape 1 : Générer un jeu de données fictif de codes postaux
</div>

Créez d’abord une fonction `generate_dataset_rows` qui génère une liste de données fictives de codes postaux. Ce jeu de données synthétique fournit au leaderboard un ensemble cohérent d’entrées et de valeurs attendues pour attribuer un score à chaque modèle.

```python lines theme={null}
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")
```

<div id="step-2-author-scoring-functions">
  ## Étape 2 : Créez des fonctions de score
</div>

Créez ensuite trois fonctions de score. Chaque scorer évalue un aspect différent de la sortie du modèle afin que le leaderboard puisse classer les modèles selon des dimensions distinctes de la qualité :

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 se situe dans une marge de 10 % par rapport à la population et au 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={null}
@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)
```

<div id="step-3-create-an-evaluation">
  ## Étape 3 : Créer une évaluation
</div>

Définissez ensuite une évaluation à l’aide des données factices et des fonction de score. L’objet `Evaluation` associe le jeu de données aux évaluateurs, afin que vous puissiez exécuter n’importe quel modèle sur le même benchmark.

```python lines theme={null}
rows = generate_dataset_rows()
evaluation = weave.Evaluation(
    name="United States - 2022",
    dataset=rows,
    scorers=[
        check_concrete_fields,
        check_value_fields,
        check_subjective_fields,
    ],
)
```

<div id="step-4-evaluate-a-baseline-model">
  ## Étape 4 : Évaluer un modèle de référence
</div>

Évaluez maintenant un modèle de référence qui renvoie une réponse statique. L’établissement d’une base de référence vous fournit un point de repère dans le leaderboard, afin de mesurer dans quelle mesure chaque modèle suivant améliore l’implémentation statique.

```python lines theme={null}
@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)
```

<div id="step-5-create-more-models">
  ## Étape 5 : Créer d’autres modèles
</div>

Créez maintenant deux modèles supplémentaires pour les comparer au modèle de référence. Un modèle reçoit le code postal sans prompt supplémentaire, tandis que l’autre reçoit un prompt structuré. Leur comparaison dans le leaderboard montre l’impact du contexte du prompt sur la qualité des réponses.

```python lines theme={null}
@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)
```

<div id="step-6-create-more-evaluations">
  ## Étape 6 : Créez davantage d’évaluations
</div>

À présent, évaluez une matrice croisant des modèles et des évaluations. En exécutant chaque modèle sur plusieurs jeux de données (régions et années différentes), vous produisez les données dont le leaderboard a besoin pour classer les modèles dans différentes conditions.

```python lines theme={null}
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__}
        )
```

<div id="step-7-review-the-leaderboard">
  ## Étape 7 : consultez le leaderboard
</div>

Une fois les résultats d’évaluation publiés, vous pouvez maintenant les regrouper dans un leaderboard pour les comparer côte à côte.

Vous pouvez créer un nouveau Leaderboard en accédant à l’onglet Leaderboard dans l’interface utilisateur, puis en cliquant sur **Create Leaderboard**.

Vous pouvez également générer un Leaderboard directement depuis Python :

```python lines theme={null}
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 maintenant d’un leaderboard publié dans Weave qui classe chaque modèle en fonction des trois évaluations et des métriques de scoring que vous avez définies. Depuis l’interface Weave, vous pouvez consulter les scores de chaque modèle, examiner en détail les différents runs d’évaluation et comparer les futures itérations du modèle à la même référence.