Passer au contenu principal
DSPy 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. 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. 
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 des appels LM 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. 
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

​
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. 
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, avec le processus d’optimisation et les améliorations des performances