DSPy

Utilisez Weave pour suivre et consigner automatiquement les appels effectués avec les modules et fonctions DSPy

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.")

Weave enregistre 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 des programmes DSPy : il contient des paramètres apprenables et encapsule une technique de prompting. Une Signature est une spécification déclarative du comportement d’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")

​

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
)