DSPy

Ce guide explique comment utiliser W&B avec DSPy pour suivre et optimiser vos programmes pour modèles de langage, afin de surveiller les métriques d’évaluation, d’examiner l’évolution des signatures de programme pendant l’optimisation et de versionner les programmes obtenus sous forme d’artefacts reproductibles. Utilisez-le si vous souhaitez disposer d’un suivi des expériences et d’une observabilité pour vos modules compilés. W&B complète l’intégration DSPy de Weave en fournissant :

Le suivi des métriques d’évaluation dans le temps
W&B Tables pour suivre l’évolution des signatures de programme
L’intégration avec des optimiseurs DSPy comme MIPROv2

Pour une observabilité complète lors de l’optimisation des modules DSPy, activez l’intégration dans W&B et dans Weave.

RemarqueDepuis wandb==0.21.2 et weave==0.52.5, Weave s’initialise automatiquement lorsqu’il est utilisé avec W&B :

Si weave est importé, puis wandb.init() est appelé (cas d’un script)
Si wandb.init() a été appelé, puis weave est importé plus tard (cas d’un notebook/Jupyter)

Aucun appel explicite à weave.init(...) n’est nécessaire.

Installer et s’authentifier

Installez les bibliothèques requises et authentifiez-vous avec W&B :

Ligne de commande
Python
Notebook

Installez les bibliothèques requises :
pip install wandb weave dspy
Définissez la variable d’environnement WANDB_API_KEY, puis connectez-vous. Remplacez <your_api_key> par votre clé API W&B :
export WANDB_API_KEY=<your_api_key> wandb login

Installez les bibliothèques requises :
pip install wandb weave dspy
Dans votre code, connectez-vous à W&B :
import wandb wandb.login()

Installez et importez les bibliothèques requises, puis connectez-vous à W&B :

!pip install wandb weave dspy

import wandb
wandb.login()

Vous découvrez W&B ? Voir le Démarrage rapide. Une fois les bibliothèques installées et l’authentification en place, vous êtes prêt à instrumenter une exécution d’optimisation DSPy.

Suivre l’optimisation du programme (expérimental)

Pour les optimiseurs DSPy qui utilisent dspy.Evaluate (comme MIPROv2), utilisez WandbDSPyCallback pour consigner les métriques d’évaluation au fil du temps et suivre l’évolution des signatures du programme dans W&B Tables. L’ajout du callback vous permet d’observer comment le score de l’optimiseur évolue et comment les prompts et les signatures du programme changent au fil des itérations.

import dspy
from dspy.datasets import MATH

import weave
import wandb
from wandb.integration.dspy import WandbDSPyCallback

# Initialiser W&B (importer weave suffit ; inutile d'appeler weave.init explicitement)
project_name = "dspy-optimization"
with wandb.init(project=project_name) as run:
    # Ajouter le callback W&B à DSPy
    dspy.settings.callbacks.append(
        WandbDSPyCallback(run=run)
    )

    # Configurer les modèles de langage
    teacher_lm = dspy.LM('openai/gpt-4o', max_tokens=2000, cache=True)
    student_lm = dspy.LM('openai/gpt-4o-mini', max_tokens=2000)
    dspy.configure(lm=student_lm)

    # Charger le dataset et définir le programme
    dataset = MATH(subset='algebra')
    program = dspy.ChainOfThought("question -> answer")

    # Configurer et lancer l'optimizer
    optimizer = dspy.MIPROv2(
        metric=dataset.metric,
        auto="light",
        num_threads=24,
        teacher_settings=dict(lm=teacher_lm),
        prompt_model=student_lm
    )

    optimized_program = optimizer.compile(
        program,
        trainset=dataset.train,
        max_bootstrapped_demos=2,
        max_labeled_demos=2
    )

Après avoir exécuté ce code, vous recevez à la fois une URL de Run W&B et une URL Weave. W&B affiche les métriques d’évaluation au fil du temps, ainsi que des tableaux montrant l’évolution des signatures du programme. L’onglet Aperçu du run inclut des liens vers les traces Weave pour une inspection détaillée. Si vous ne transmettez pas d’objet run à WandbDSPyCallback, le callback utilise l’objet run global.

Pour plus de détails sur le traçage Weave, l’évaluation et l’optimisation avec DSPy, voir le guide d’intégration DSPy de Weave.

Journaliser les prédictions dans W&B Tables

En plus des métriques agrégées, vous pouvez activer la journalisation détaillée des prédictions pour examiner des exemples individuels pendant l’optimisation. Le callback crée un tableau W&B à chaque étape d’évaluation, ce qui vous aide à analyser des réussites et des échecs spécifiques.

from wandb.integration.dspy import WandbDSPyCallback

# Activer la journalisation des prédictions (activé par défaut)
callback = WandbDSPyCallback(log_results=True)
dspy.settings.callbacks.append(callback)

# Lancer votre optimisation
optimized_program = optimizer.compile(program, trainset=train_data)

# Désactiver la journalisation des prédictions si nécessaire
# callback = WandbDSPyCallback(log_results=False)

Accéder aux données de prédiction

Après l’optimisation, retrouvez vos données de prédiction dans W&B :

Accédez à la page Aperçu de votre run.
Recherchez les panneaux de tableau nommés selon un format comme predictions_0 ou predictions_1.
Filtrez sur is_correct pour analyser les échecs.
Comparez les tableaux entre les runs dans l’espace de travail du projet.

Chaque tableau inclut des colonnes pour :

example : données d’entrée
prediction : sortie du modèle
is_correct : résultat de l’évaluation

Pour en savoir plus, consultez le guide W&B Tables.

Enregistrer et versionner des programmes DSPy

Une fois que vous avez identifié un programme optimisé très performant, enregistrez-le comme artefact W&B afin de pouvoir reproduire les résultats et suivre les versions au fil du temps. Choisissez entre l’enregistrement du programme complet ou du seul état, selon que vous avez besoin de l’architecture complète ou d’un point de contrôle plus léger.

from wandb.integration.dspy import WandbDSPyCallback

# Créer une instance de callback
callback = WandbDSPyCallback()
dspy.settings.callbacks.append(callback)

# Lancer l'optimisation
optimized_program = optimizer.compile(program, trainset=train_data)

# Options de sauvegarde :

# 1. Programme complet (recommandé) - inclut l'architecture et l'état
callback.log_best_model(optimized_program, save_program=True)

# 2. État uniquement en JSON - plus léger, lisible par un humain
callback.log_best_model(optimized_program, save_program=False, filetype="json")

# 3. État uniquement en pickle - préserve les objets Python
callback.log_best_model(optimized_program, save_program=False, filetype="pkl")

# Ajouter des aliases personnalisés pour la gestion des versions
callback.log_best_model(
    optimized_program,
    save_program=True,
    aliases=["best", "production", "v2.0"]
)

Weights & Biases

Powered by CoreWeave

Platform Details

Resources

Installer et s’authentifier

Suivre l’optimisation du programme (expérimental)

Journaliser les prédictions dans W&B Tables

Accéder aux données de prédiction

Enregistrer et versionner des programmes DSPy

​Installer et s’authentifier

​Suivre l’optimisation du programme (expérimental)

​Journaliser les prédictions dans W&B Tables

​Accéder aux données de prédiction

​Enregistrer et versionner des programmes DSPy

Installer et s’authentifier

Suivre l’optimisation du programme (expérimental)

Journaliser les prédictions dans W&B Tables

Accéder aux données de prédiction

Enregistrer et versionner des programmes DSPy