> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-2751.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Suivez et optimisez les programmes DSPy avec W&B pour consigner les prompts, les évaluations et les performances des modules compilés.
# 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](/fr/weave/guides/integrations/dspy) 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.
**Remarque**
Depuis `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 :
```shell theme={null}
pip install wandb weave dspy
```
2. Définissez la variable d’[environnement](/fr/models/track/environment-variables/) `WANDB_API_KEY`, puis connectez-vous. Remplacez `` par votre clé API W\&B :
```bash theme={null}
export WANDB_API_KEY=
wandb login
```
1. Installez les bibliothèques requises :
```bash theme={null}
pip install wandb weave dspy
```
2. Dans votre code, connectez-vous à W\&B :
```python theme={null}
import wandb
wandb.login()
```
Installez et importez les bibliothèques requises, puis connectez-vous à W\&B :
```notebook theme={null}
!pip install wandb weave dspy
import wandb
wandb.login()
```
Vous découvrez W\&B ? Voir le [Démarrage rapide](/fr/models/quickstart/).
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.
```python theme={null}
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](/fr/weave/guides/integrations/dspy).
## 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.
```python theme={null}
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 :
1. Accédez à la page **Aperçu** de votre run.
2. Recherchez les panneaux de tableau nommés selon un format comme `predictions_0` ou `predictions_1`.
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](/fr/models/tables/visualize-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.
```python theme={null}
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"]
)
```