> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/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

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](/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.

<Info>
  **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.
</Info>

<div id="install-and-authenticate">
  ## Installer et s’authentifier
</div>

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

<Tabs>
  <Tab title="Ligne de commande">
    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 :

       ```bash theme={null}
       export WANDB_API_KEY=<your_api_key>
       wandb login
       ```
  </Tab>

  <Tab title="Python">
    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()
       ```
  </Tab>

  <Tab title="Notebook">
    Installez et importez les bibliothèques requises, puis connectez-vous à W\&B :

    ```notebook theme={null}
    !pip install wandb weave dspy

    import wandb
    wandb.login()
    ```
  </Tab>
</Tabs>

Vous découvrez W\&B ? Voir notre [guide de démarrage rapide](/fr/models/quickstart/).

<div id="track-program-optimization-experimental">
  ## Suivez l’optimisation du programme (expérimental)
</div>

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.

```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 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é.

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541/mVjDwbx0mC8gYx-b/images/integrations/dspy_run_page.png?fit=max&auto=format&n=mVjDwbx0mC8gYx-b&q=85&s=f0bd7a2568e48fdf8ea232bf09528af3" alt="run d’optimisation DSPy dans W&B" width="3456" height="1865" data-path="images/integrations/dspy_run_page.png" />
</Frame>

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](/fr/weave/guides/integrations/dspy).

<div id="log-predictions-to-wb-tables">
  ## Enregistrez les prédictions dans W\&B Tables
</div>

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.

```python theme={null}
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)
```

<div id="access-prediction-data">
  ### Accéder aux données de prédiction
</div>

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](/fr/models/tables/visualize-tables/).

<div id="save-and-version-dspy-programs">
  ## Enregistrer et versionner des programmes DSPy
</div>

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.

```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 alias personnalisés pour la gestion des versions
callback.log_best_model(
    optimized_program,
    save_program=True,
    aliases=["best", "production", "v2.0"]
)
```