Tracer DSPy

DSPy est un framework open source pour la création de systèmes d'IA modulaires et propose des algorithmes pour l'optimisation de leurs invites et de leurs poids.

MLflow Tracing offre une capacité de traçage automatique pour DSPy. Vous pouvez activer le traçage pour DSPy en appelant la fonction mlflow.dspy.autolog, et les traces imbriquées sont automatiquement journalisées dans l'Expérience MLflow active lors de l'invocation des modules DSPy.

Python

import mlflow

mlflow.dspy.autolog()

remarque

Sur les clusters de compute serverless, l'autologging n'est pas activé automatiquement. Vous devez appeler explicitement mlflow.dspy.autolog() pour activer le traçage automatique de cette intégration.

Prérequis

Pour utiliser MLflow Tracing avec DSPy, vous devez installer MLflow et la bibliothèque dspy-ai.

Development

Pour les environnements de développement, installez le package MLflow complet avec les extras Databricks et dspy-ai:

Bash

pip install --upgrade "mlflow[databricks]>=3.1" dspy-ai

Le package mlflow[databricks] complet inclut toutes les fonctionnalités pour le développement local et l’expérimentation sur Databricks.

Production

Pour les déploiements en production, installez mlflow-tracing et dspy-ai:

Bash

pip install --upgrade mlflow-tracing dspy-ai

Le mlflow-tracing package est optimisé pour une utilisation en production.

remarque

MLflow 3 est fortement recommandé pour une meilleure expérience de traçage avec DSPy.

Avant d'exécuter les exemples, vous devrez configurer votre environnement :

Pour les utilisateurs en dehors des notebooks Databricks : Définissez vos variables d'environnement Databricks :

Bash

export DATABRICKS_HOST="https://your-workspace.cloud.databricks.com"
export DATABRICKS_TOKEN="your-personal-access-token"

Pour les utilisateurs dans les Notebooks Databricks : ces identifiants sont définis automatiquement pour vous.

Clés API : Assurez-vous que les clés API de votre fournisseur LLM sont configurées. Pour les environnements de production, utilisez AI Gateway ou les secrets Databricks au lieu de valeurs codées en dur pour une gestion sécurisée des clés API.

Bash

export OPENAI_API_KEY="your-openai-api-key"
# Add other provider keys as needed

Exemple d'utilisation

Python

import dspy
import mlflow
import os

# Ensure your OPENAI_API_KEY (or other LLM provider keys) is set in your environment
# os.environ["OPENAI_API_KEY"] = "your-openai-api-key" # Uncomment and set if not globally configured

# Enabling tracing for DSPy
mlflow.dspy.autolog()

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/dspy-tracing-demo")

# Define a simple ChainOfThought model and run it
lm = dspy.LM("openai/gpt-4o-mini")
dspy.configure(lm=lm)


# Define a simple summarizer model and run it
class SummarizeSignature(dspy.Signature):
    """Given a passage, generate a summary."""

    passage: str = dspy.InputField(desc="a passage to summarize")
    summary: str = dspy.OutputField(desc="a one-line summary of the passage")


class Summarize(dspy.Module):
    def __init__(self):
        self.summarize = dspy.ChainOfThought(SummarizeSignature)

    def forward(self, passage: str):
        return self.summarize(passage=passage)


summarizer = Summarize()
summarizer(
    passage=(
        "MLflow Tracing is a feature that enhances LLM observability in your Generative AI (GenAI) applications "
        "by capturing detailed information about the execution of your application's services. Tracing provides "
        "a way to record the inputs, outputs, and metadata associated with each intermediate step of a request, "
        "enabling you to easily pinpoint the source of bugs and unexpected behaviors."
    )
)

attention

Pour les environnements de production, utilisez AI Gateway ou les secrets Databricks au lieu de valeurs codées en dur pour la gestion sécurisée des clés API.

Suivi pendant l’évaluation

L'évaluation des modèles DSPy est une étape importante dans le développement des systèmes d'IA. MLflow Tracing peut vous aider à suivre les performances de vos programmes après l'évaluation, en fournissant des informations détaillées sur l'exécution de vos programmes pour chaque entrée.

Lorsque le traçage automatique MLflow est activé pour DSPy, des traces sont générées automatiquement lorsque vous exécutez les suites d’évaluation intégrées de DSPy. L'exemple suivant montre comment exécuter l'évaluation et examiner les traces dans MLflow :

Python

import dspy
from dspy.evaluate.metrics import answer_exact_match
import mlflow
import os

# Ensure your OPENAI_API_KEY (or other LLM provider keys) is set in your environment
# os.environ["OPENAI_API_KEY"] = "your-openai-api-key" # Uncomment and set if not globally configured

# Enabling tracing for DSPy evaluation
mlflow.dspy.autolog(log_traces_from_eval=True)

# Set up MLflow tracking to Databricks if not already configured
# mlflow.set_tracking_uri("databricks")
# mlflow.set_experiment("/Shared/dspy-eval-demo")

# Define a simple evaluation set
eval_set = [
    dspy.Example(
        question="How many 'r's are in the word 'strawberry'?", answer="3"
    ).with_inputs("question"),
    dspy.Example(
        question="How many 'a's are in the word 'banana'?", answer="3"
    ).with_inputs("question"),
    dspy.Example(
        question="How many 'e's are in the word 'elephant'?", answer="2"
    ).with_inputs("question"),
]


# Define a program
class Counter(dspy.Signature):
    question: str = dspy.InputField()
    answer: str = dspy.OutputField(
        desc="Should only contain a single number as an answer"
    )


cot = dspy.ChainOfThought(Counter)

# Evaluate the programs
with mlflow.start_run(run_name="CoT Evaluation"):
    evaluator = dspy.evaluate.Evaluate(
        devset=eval_set,
        return_all_scores=True,
        return_outputs=True,
        show_progress=True,
    )
    aggregated_score, outputs, all_scores = evaluator(cot, metric=answer_exact_match)

    # Log the aggregated score
    mlflow.log_metric("exact_match", aggregated_score)
    # Log the detailed evaluation results as a table
    mlflow.log_table(
        {
            "question": [example.question for example in eval_set],
            "answer": [example.answer for example in eval_set],
            "output": outputs,
            "exact_match": all_scores,
        },
        artifact_file="eval_results.json",
    )

Si vous ouvrez l'interface utilisateur MLflow et accédez à l'exécution « CoT Evaluation », vous verrez le résultat de l'évaluation, et la liste des traces générées pendant l'évaluation sur la tab Traces.

remarque

Vous pouvez désactiver le traçage pour ces étapes en appelant la fonction mlflow.dspy.autolog avec les log_traces_from_eval parameters définis sur False.

Traçage pendant la compilation (optimisation)

La compilation (optimisation) est le concept fondamental de DSPy. Grâce à la compilation, DSPy optimise automatiquement les invites et les pondérations de votre programme DSPy afin d'atteindre les meilleures performances.

Par default, MLflow ne génère **PAS** de traces pendant la compilation, car la compilation peut Trigger des centaines ou des milliers d'invocations de modules DSPy. Pour activer le traçage pour la compilation, vous pouvez appeler la fonction mlflow.dspy.autolog avec le log_traces_from_compile paramètre défini sur True.

Python

import dspy
import mlflow
import os

# Ensure your OPENAI_API_KEY (or other LLM provider keys) is set in your environment
# os.environ["OPENAI_API_KEY"] = "your-openai-api-key" # Uncomment and set if not globally configured

# Enable auto-tracing for compilation
mlflow.dspy.autolog(log_traces_from_compile=True)

# Set up MLflow tracking to Databricks if not already configured
# mlflow.set_tracking_uri("databricks")
# mlflow.set_experiment("/Shared/dspy-compile-demo")

# Optimize the DSPy program as usual
tp = dspy.MIPROv2(metric=metric, auto="medium", num_threads=24)
optimized = tp.compile(cot, trainset=trainset, ...)

Désactiver le suivi automatique

Le traçage automatique pour LlamaIndex peut être désactivé globalement en appelant mlflow.llama_index.autolog(disable=True) ou mlflow.autolog(disable=True).