> ## 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.
# DSPy
> Utilisez Weave pour suivre et consigner automatiquement les appels effectués avec les modules et fonctions DSPy
export const GitHubLink = ({url}) =>
Source GitHub
;
export const ColabLink = ({url}) =>
Essayer sur Colab
;
[DSPy](https://dspy.ai) est un framework permettant d’optimiser algorithmiquement les prompts et les poids des modèles de langage (LM), en particulier lorsque vous utilisez des LM une ou plusieurs fois dans un pipeline. W\&B Weave suit et journalise automatiquement les appels effectués à l’aide des modules et fonctions DSPy. Ce guide vous montre comment activer le traçage Weave pour les programmes DSPy, suivre les modules et signatures personnalisés, et capturer les traces des optimiseurs et des évaluations DSPy. Grâce à ces traces, vous pouvez déboguer, analyser et améliorer vos applications DSPy.
## Traces
Cette section explique comment activer le traçage automatique des appels DSPy dans Weave. Stockez les traces des applications de modèles de langage dans un emplacement centralisé, pendant le développement comme en production. Ces traces sont utiles pour le débogage et constituent aussi un jeu de données qui vous aide à améliorer votre application.
Weave capture automatiquement les traces de [DSPy](https://dspy.ai). Pour commencer à suivre, appelez `weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")`, puis utilisez la bibliothèque normalement. Remplacez `[YOUR-OPENAI-API-KEY]` par votre clé API OpenAI et `[YOUR-WANDB-PROJECT-NAME]` par le nom de votre projet W\&B.
```python lines theme={null}
import os
import dspy
import weave
os.environ["OPENAI_API_KEY"] = "[YOUR-OPENAI-API-KEY]"
weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")
lm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=lm)
classify = dspy.Predict("sentence -> sentiment")
classify(sentence="it's a charming and often affecting journey.")
```
[](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)
Avec le traçage activé, Weave journalise chaque appel LM effectué par votre programme DSPy dans votre projet Weave, où vous pouvez inspecter les entrées, les sorties et les métadonnées.
## Suivez vos propres modules et signatures DSPy
Au-delà des appels intégrés, Weave trace également les modules et signatures personnalisés que vous définissez. Un `Module` est l’élément de base d’un programme DSPy, avec des paramètres entraînables, qui encapsule une technique de prompting. Une `Signature` est une spécification déclarative du comportement en entrée/sortie d’un module DSPy. Weave suit automatiquement toutes les `Signatures` et tous les `Modules` intégrés et personnalisés dans vos programmes DSPy. Remplacez `[YOUR-OPENAI-API-KEY]` par votre clé API OpenAI et `[YOUR-WANDB-PROJECT-NAME]` par le nom de votre projet W\&B.
```python lines theme={null}
import os
import dspy
import weave
os.environ["OPENAI_API_KEY"] = "[YOUR-OPENAI-API-KEY]"
weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")
class Outline(dspy.Signature):
"""Outline a thorough overview of a topic."""
topic: str = dspy.InputField()
title: str = dspy.OutputField()
sections: list[str] = dspy.OutputField()
section_subheadings: dict[str, list[str]] = dspy.OutputField(
desc="mapping from section headings to subheadings"
)
class DraftSection(dspy.Signature):
"""Draft a top-level section of an article."""
topic: str = dspy.InputField()
section_heading: str = dspy.InputField()
section_subheadings: list[str] = dspy.InputField()
content: str = dspy.OutputField(desc="markdown-formatted section")
class DraftArticle(dspy.Module):
def __init__(self):
self.build_outline = dspy.ChainOfThought(Outline)
self.draft_section = dspy.ChainOfThought(DraftSection)
def forward(self, topic):
outline = self.build_outline(topic=topic)
sections = []
for heading, subheadings in outline.section_subheadings.items():
section, subheadings = (
f"## {heading}",
[f"### {subheading}" for subheading in subheadings],
)
section = self.draft_section(
topic=outline.title,
section_heading=section,
section_subheadings=subheadings,
)
sections.append(section.content)
return dspy.Prediction(title=outline.title, sections=sections)
draft_article = DraftArticle()
article = draft_article(topic="World Cup 2002")
```
[](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)
## Optimisez et évaluez votre programme DSPy
Weave capture aussi les traces des optimiseurs DSPy et des appels d’évaluation, que vous pouvez utiliser pour améliorer et évaluer les performances de votre programme DSPy sur un jeu de développement. Remplacez `[YOUR-OPENAI-API-KEY]` par votre clé API OpenAI et `[YOUR-WANDB-PROJECT-NAME]` par le nom de votre projet W\&B.
```python lines theme={null}
import os
import dspy
import weave
os.environ["OPENAI_API_KEY"] = "[YOUR-OPENAI-API-KEY]"
weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")
def accuracy_metric(answer, output, trace=None):
predicted_answer = output["answer"].lower()
return answer["answer"].lower() == predicted_answer
module = dspy.ChainOfThought("question -> answer: str, explanation: str")
optimizer = dspy.BootstrapFewShot(metric=accuracy_metric)
optimized_module = optimizer.compile(
module, trainset=SAMPLE_EVAL_DATASET, valset=SAMPLE_EVAL_DATASET
)
```
[](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)
](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)
Avec le traçage activé, Weave journalise chaque appel LM effectué par votre programme DSPy dans votre projet Weave, où vous pouvez inspecter les entrées, les sorties et les métadonnées.
](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)
](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)