> ## 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.
# Comparer et classer les modèles
> Comparer et classer différentes versions de modèles à partir de métriques d’évaluation
Utilisez les *Leaderboards* de Weave pour évaluer et comparer plusieurs modèles selon plusieurs métriques, et mesurer la précision, la qualité de génération, la latence ou une logique d’évaluation personnalisée. Un leaderboard vous aide à visualiser les performances du modèle dans un emplacement centralisé, à suivre les changements au fil du temps et à vous aligner sur des benchmarks communs pour toute l’équipe.
Ce guide vous montre comment créer, configurer et publier un leaderboard afin que votre équipe puisse comparer des versions de modèles par rapport à des benchmarks partagés.
Les leaderboards sont idéaux pour :
* Suivre les régressions des performances du modèle.
* Coordonner des flux de travail d’évaluation partagés.
La création de leaderboards n’est possible que dans l’interface Weave et le SDK Python de Weave. Les utilisateurs de TypeScript peuvent créer et gérer des leaderboards à l’aide de l’[interface Weave](#use-the-ui).
## Créer un leaderboard
Vous pouvez créer un leaderboard à partir de l'[interface Weave](#use-the-ui) ou [par programmation](#use-the-python-sdk). Choisissez l'interface pour des comparaisons ad hoc, ou le SDK Python pour intégrer la création de leaderboards à des flux de travail d'évaluation automatisés.
### Utiliser l'UI
Utilisez l’interface Weave pour créer et personnaliser des leaderboards de manière interactive. Suivez ces étapes :
1. Dans l’interface Weave, accédez à la section **Leaders**. Si elle n’est pas visible, cliquez sur **More** → **Leaders**.
2. Cliquez sur **+ New Leaderboard**.
3. Dans le champ **Leaderboard Title**, saisissez un nom explicite (par exemple, `summarization-benchmark-v1`).
4. Vous pouvez également ajouter une description pour préciser ce que ce leaderboard compare.
5. [Ajoutez des colonnes](#add-columns) pour définir quelles évaluations et métriques afficher.
6. Lorsque la mise en page est prête, enregistrez et publiez votre leaderboard pour le partager avec d’autres.
#### Ajouter des colonnes
Les colonnes définissent ce que votre leaderboard affiche pour chaque modèle. Chaque colonne d’un leaderboard représente une métrique issue d’une évaluation donnée. Pour configurer une colonne, vous devez préciser :
* **Évaluation**: Sélectionnez un run d’évaluation dans la liste déroulante (il doit avoir été créé au préalable).
* **Évaluateur**: Choisissez une fonction de score (par exemple, `jaccard_similarity` ou `simple_accuracy`) utilisée dans cette évaluation.
* **Métrique**: Choisissez une métrique de synthèse à afficher (par exemple, `mean` ou `true_fraction`).
Pour ajouter d’autres colonnes, cliquez sur **Ajouter une colonne**.
Pour modifier une colonne, cliquez sur le menu action () à droite. Vous pouvez :
* **Déplacer avant ou après**. Réordonner les colonnes.
* **Dupliquer**. Copier la définition de la colonne.
* **Supprimer**. Supprimer la colonne.
* **Trier par ordre croissant**. Définir l’ordre de tri par défaut du leaderboard (cliquez à nouveau pour basculer en ordre décroissant).
### Utilisez le SDK Python
Utilisez le SDK Python pour définir, publier et récupérer des leaderboards dans le code. Cette approche vous permet de versionner les leaderboards avec votre code d’évaluation et de les exécuter dans le cadre d’un flux de travail automatisé.
Vous cherchez un exemple de code complet et exécutable ? Voir l’[exemple Python de bout en bout](#end-to-end-python-example).
Pour créer et publier un leaderboard :
1. Définissez un jeu de données de test. Vous pouvez utiliser le [`Dataset`](./datasets) intégré ou définir manuellement une liste d’entrées et de cibles :
```python lines theme={null}
dataset = [
{"input": "...", "target": "..."},
...
]
```
2. Définissez un ou plusieurs [évaluateurs](../evaluation/scorers) :
```python lines theme={null}
@weave.op
def jaccard_similarity(target: str, output: str) -> float:
...
```
3. Créez une [`Evaluation`](../core-types/evaluations) :
```python lines theme={null}
evaluation = weave.Evaluation(
name="My Eval",
dataset=dataset,
scorers=[jaccard_similarity],
)
```
4. Définissez les modèles à évaluer :
```python lines theme={null}
@weave.op
def my_model(input: str) -> str:
...
```
5. Lancez l’évaluation :
```python lines theme={null}
async def run_all():
await evaluation.evaluate(model_vanilla)
await evaluation.evaluate(model_humanlike)
await evaluation.evaluate(model_messy)
asyncio.run(run_all())
```
6. Créez le leaderboard :
```python lines theme={null}
spec = leaderboard.Leaderboard(
name="My Leaderboard",
description="Evaluating models on X task",
columns=[
leaderboard.LeaderboardColumn(
evaluation_object_ref=get_ref(evaluation).uri(),
scorer_name="jaccard_similarity",
summary_metric_path="mean",
)
]
)
```
7. Publiez le leaderboard.
```python lines theme={null}
weave.publish(spec)
```
8. Récupérez les résultats :
```python lines theme={null}
results = leaderboard.get_leaderboard_results(spec, client)
print(results)
```
Après la publication, votre leaderboard est disponible dans l’interface Weave, sous l’onglet **Leaders**, où votre équipe peut consulter et comparer les performances des modèles.
## Exemple Python de bout en bout
L’exemple suivant utilise les évaluations Weave et crée un leaderboard pour comparer trois modèles de résumé sur un jeu de données partagé à l’aide d’une métrique personnalisée. Il crée un petit benchmark, évalue chaque modèle, calcule le score de chaque modèle à l’aide de la [similarité de Jaccard](https://www.learndatasci.com/glossary/jaccard-similarity/), puis publie les résultats dans un leaderboard Weave.
```python lines theme={null}
import weave
from weave.flow import leaderboard
from weave.trace.ref_util import get_ref
import asyncio
client = weave.init("leaderboard-demo")
dataset = [
{
"input": "Weave is a tool for building interactive LLM apps. It offers observability, trace inspection, and versioning.",
"target": "Weave helps developers build and observe LLM applications."
},
{
"input": "The OpenAI GPT-4o model can process text, audio, and vision inputs, making it a multimodal powerhouse.",
"target": "GPT-4o is a multimodal model for text, audio, and images."
},
{
"input": "The W&B team recently added native support for agents and evaluations in Weave.",
"target": "W&B added agents and evals to Weave."
}
]
@weave.op
def jaccard_similarity(target: str, output: str) -> float:
target_tokens = set(target.lower().split())
output_tokens = set(output.lower().split())
intersection = len(target_tokens & output_tokens)
union = len(target_tokens | output_tokens)
return intersection / union if union else 0.0
evaluation = weave.Evaluation(
name="Summarization Quality",
dataset=dataset,
scorers=[jaccard_similarity],
)
@weave.op
def model_vanilla(input: str) -> str:
return input[:50]
@weave.op
def model_humanlike(input: str) -> str:
if "Weave" in input:
return "Weave helps developers build and observe LLM applications."
elif "GPT-4o" in input:
return "GPT-4o supports text, audio, and vision input."
else:
return "W&B added agent support to Weave."
@weave.op
def model_messy(input: str) -> str:
return "Summarizer summarize models model input text LLMs."
async def run_all():
await evaluation.evaluate(model_vanilla)
await evaluation.evaluate(model_humanlike)
await evaluation.evaluate(model_messy)
asyncio.run(run_all())
spec = leaderboard.Leaderboard(
name="Summarization Model Comparison",
description="Evaluate summarizer models using Jaccard similarity on three short samples.",
columns=[
leaderboard.LeaderboardColumn(
evaluation_object_ref=get_ref(evaluation).uri(),
scorer_name="jaccard_similarity",
summary_metric_path="mean",
)
]
)
weave.publish(spec)
results = leaderboard.get_leaderboard_results(spec, client)
print(results)
```
### Consulter et interpréter le leaderboard
Une fois que le script a publié le leaderboard, utilisez l’interface Weave pour examiner les résultats et comparer côte à côte les performances des modèles :
1. Dans l’**interface Weave**, accédez à l’onglet **Leaders**. S’il n’est pas visible, cliquez sur **More**, puis sélectionnez **Leaders**.
2. Cliquez sur le nom de votre leaderboard, par exemple `Summarization Model Comparison`.
Dans le tableau du leaderboard, chaque ligne représente un modèle (`model_humanlike`, `model_vanilla`, `model_messy`). La colonne `mean` indique la similarité de Jaccard moyenne entre la sortie du modèle et les résumés de référence.
Pour cet exemple :
* `model_humanlike` donne les meilleurs résultats, avec environ 46 % de chevauchement.
* `model_vanilla` (une troncature naïve) atteint environ 21 %.
* `model_messy`, un modèle délibérément mauvais, obtient un score d’environ 2 %.