> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-1917.mintlify.site/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.
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 la Weave UI et le SDK Python de Weave. Les utilisateurs de TypeScript peuvent créer et gérer des leaderboards à l’aide de la [Weave UI](#using-the-ui).
## Créer un leaderboard
Vous pouvez créer un leaderboard via la [Weave UI](#ui) ou [par code](#python).
### Utiliser l'UI
Pour créer et personnaliser des leaderboards directement dans la Weave UI :
1. Dans la Weave UI, 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. Une fois la mise en page finalisée, enregistrez et publiez votre leaderboard pour le partager avec d’autres.
#### Ajouter des colonnes
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 ex. `jaccard_similarity`, `simple_accuracy`) utilisée dans cette évaluation.
* **Métrique** : Choisissez une métrique de synthèse à afficher (par ex. `mean`, `true_fraction`, etc.).
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 / 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)
### Python
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)
```
## 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 3 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 le script exécuté, affichez le leaderboard :
1. Dans la **Weave UI**, 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 \~46 % de chevauchement.
* `model_vanilla` (une troncature naïve) atteint \~21 %.
* `model_messy`, un modèle délibérément mauvais, obtient un score d’environ \~2 %.