Skip to main content
Utilisez W&B avec DSPy pour suivre et optimiser vos programmes pour modèles de langage. 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 :
  1. Installez les bibliothèques requises : 
    pip install wandb weave dspy
  2. Définissez la variable d’environnement WANDB_API_KEY, puis connectez-vous : 
    export WANDB_API_KEY=<your_api_key>
wandb login
Vous découvrez W&B ? Voir notre guide de démarrage rapide.

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

Pour les optimiseurs DSPy qui utilisent dspy.Evaluate (comme MIPROv2), utilisez WandbDSPyCallback pour journaliser les métriques d’évaluation au fil du temps et suivre l’évolution de la signature du programme dans les W&B Tables. 
import dspy
from dspy.datasets import MATH

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

# Initialiser W&B (importer weave est suffisant ; pas besoin 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 jeu de données et définir le programme
    dataset = MATH(subset='algebra')
    program = dspy.ChainOfThought("question -> answer")

    # Configurer et exécuter l'optimiseur
    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 obtenez à 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 Tables 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 aucun objet run n’est passé à WandbDSPyCallback, l’objet global run est utilisé.
run d’optimisation DSPy dans W&B
Pour des informations complètes sur le tracing dans Weave, l’évaluation et l’optimisation avec DSPy, voir le guide d’intégration Weave DSPy.

​
Enregistrez les prédictions dans W&B Tables

Activez un logging détaillé des prédictions pour inspecter des exemples individuels pendant l’optimisation. Le callback crée une W&B Tables pour chaque étape d’évaluation, ce qui peut vous aider à analyser des réussites et des échecs précis. 
from wandb.integration.dspy import WandbDSPyCallback

# Activer la journalisation des prédictions (activée 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 :
  1. Accédez à la page Aperçu de votre run.
  2. Recherchez les panneaux de tableau nommés selon un format comme predictions_0, predictions_1, etc.
  3. Filtrez sur is_correct pour analyser les échecs.
  4. 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

Pour reproduire et versionner vos meilleurs programmes DSpy, enregistrez-les sous forme de W&B Artifacts. Choisissez entre enregistrer l’intégralité du programme ou seulement son état. 
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 alias personnalisés pour la gestion des versions
callback.log_best_model(
    optimized_program,
    save_program=True,
    aliases=["best", "production", "v2.0"]
)