> ## Documentation Index > Fetch the complete documentation index at: https://wb-21fd5541-docs-hivemind-launch.mintlify.site/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 LM, en particulier lorsque les LM sont utilisés une ou plusieurs fois dans un pipeline. Weave suit et journalise automatiquement les appels effectués à l’aide des modules et fonctions DSPy.
## Tracing
Il est important de stocker les traces des applications basées sur des modèles de langage dans un emplacement centralisé, à la fois pendant le développement et en Production. Ces traces peuvent être utiles pour le débogage, et constituer un jeu de données qui vous aidera à améliorer votre application. Weave capturera automatiquement les traces de [DSPy](https://dspy.ai). Pour commencer à suivre, appelez `weave.init(project_name="")` et utilisez la bibliothèque normalement. ```python lines theme={null} import os import dspy import weave os.environ["OPENAI_API_KEY"] = "" weave.init(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.") ``` [dspy_trace.png](https://wandb.ai/geekyrakshit/dspy-project/weave/calls) Weave journalise tous les appels au modèle de langage dans votre programme DSPy, avec des détails sur les entrées, les sorties et les métadonnées.
## Suivez vos propres modules et signatures DSPy
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. ```python lines theme={null} import os import dspy import weave os.environ["OPENAI_API_KEY"] = "" weave.init(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://wandb.ai/geekyrakshit/dspy-project/weave/calls)
## Optimisation et évaluation de votre programme DSPy
Weave capture aussi automatiquement 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. ```python lines theme={null} import os import dspy import weave os.environ["OPENAI_API_KEY"] = "" weave.init(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, avec le processus d’optimisation et les améliorations des performances](https://wandb.ai/geekyrakshit/dspy-project/weave/calls)