Comparer et classer les modèles

• Suivre les régressions des performances du modèle.
• Coordonner des flux de travail d’évaluation partagés.

​

Créer un leaderboard

​

Utiliser l’UI

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

• É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).

• 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

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

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

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.

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