Passer au contenu principal
DSPy 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. Pour commencer à suivre, appelez weave.init(project_name="<YOUR-WANDB-PROJECT-NAME>") et utilisez la bibliothèque normalement. 
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.")
dspy_trace.png 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. 
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

​
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. 
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