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.

​

Créer un leaderboard

Vous pouvez créer un leaderboard via la Weave UI ou par code.

​

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 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 son menu à trois points (⋯) à 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.

Pour créer et publier un leaderboard :

1. Définissez un jeu de données de test. Vous pouvez utiliser le Dataset intégré ou définir manuellement une liste d’entrées et de cibles :

   dataset = [
       {"input": "...", "target": "..."},
       ...
   ]
   

2. Définissez un ou plusieurs évaluateurs :

   @weave.op
   def jaccard_similarity(target: str, output: str) -> float:
       ...
   

3. Créez une Evaluation :

   evaluation = weave.Evaluation(
       name="My Eval",
       dataset=dataset,
       scorers=[jaccard_similarity],
   )
   

4. Définissez les modèles à évaluer :

   @weave.op
   def my_model(input: str) -> str:
       ...
   

5. Lancez l’évaluation :

    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 :

   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.

   weave.publish(spec)
   

8. Récupérez les résultats :

   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, puis publie les résultats dans un leaderboard Weave.

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 %.