> ## Documentation Index > Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt > Use this file to discover all available pages before exploring further. # DSPy > Utilisez Weave pour suivre et journaliser automatiquement les appels effectués avec les modules et les fonctions DSPy export const GitHubLink = ({url, compact = false}) => {compact ? "View source" : <> GitHub source } ; export const ColabLink = ({url}) => Try in Colab ;
[DSPy](https://dspy.ai) est un framework qui permet d’optimiser de manière algorithmique les prompts et les poids des modèles de langage (LM), en particulier lorsque vous faites appel à des LM une ou plusieurs fois au sein d’un pipeline. W\&B Weave suit et journalise automatiquement les appels effectués avec les modules et les fonctions DSPy. Ce guide explique comment activer le traçage Weave pour vos programmes DSPy, suivre vos 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. Centralisez le stockage des traces de vos applications de modèles de langage, aussi bien pendant le développement qu’en production. Ces traces facilitent le débogage et peuvent servir de jeu de données pour améliorer votre application. Weave capture automatiquement les traces de [DSPy](https://dspy.ai). Pour commencer à suivre vos appels, appelez `weave.init(project_name="[YOUR-WANDB-PROJECT-NAME]")`, puis utilisez la bibliothèque comme d’habitude. Remplacez `[YOUR-OPENAI-API-KEY]` par votre clé API OpenAI et `[YOUR-WANDB-PROJECT-NAME]` par le nom de votre projet Weights & Biases. ```python lines theme={"system"} 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.") ``` [Trace DSPy dans Weave affichant les entrées, les sorties et les métadonnées d’un appel de LM](https://forge.coreweave.com/wandb/geekyrakshit/dspy-project/weave/calls) Une fois le traçage activé, Weave journalise dans votre projet Weave chaque appel de LM effectué par votre programme DSPy. Vous pouvez alors y inspecter les entrées, les sorties et les métadonnées.

Suivre vos propres modules et signatures DSPy

Outre les 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 des programmes DSPy : doté de paramètres entraînables, il 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 tous les objets `Signature` et `Module` de vos programmes DSPy, qu’ils soient intégrés ou personnalisés. Remplacez `[YOUR-OPENAI-API-KEY]` par votre clé API OpenAI et `[YOUR-WANDB-PROJECT-NAME]` par le nom de votre projet Weights & Biases. ```python lines theme={"system"} 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") ``` [Trace d’un module DSPy personnalisé dans Weave, avec le flux d’exécution du module et les détails de la trace](https://forge.coreweave.com/wandb/geekyrakshit/dspy-project/weave/calls)

Optimiser et évaluer votre programme DSPy

Weave capture également les traces des optimiseurs DSPy et des appels d'évaluation, qui vous permettent d'améliorer et d'é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 Weights & Biases. ```python lines theme={"system"} 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 ) ``` [Trace de l’optimiseur DSPy dans Weave, montrant le processus d’optimisation et les améliorations des performances](https://forge.coreweave.com/wandb/geekyrakshit/dspy-project/weave/calls) ## Related topics - [Optimisation des prompts avec DSPy](/fr/products/wandb/weave/cookbooks/dspy_prompt_optimization.md)