Rastreamento DSPy

DSPy é uma estrutura de código aberto para a construção de sistemas modulares de IA e oferece algoritmos para otimizar seus prompts e pesos.

MLflow Tracing fornece capacidade de rastreamento automático para DSPy. Você pode habilitar o rastreamento para DSPy chamando a função mlflow.dspy.autolog, e os rastreamentos aninhados são automaticamente registados na Experiência MLflow ativa após a invocação dos módulos DSPy.

import mlflow

mlflow.dspy.autolog()

Pré-requisitos

Para usar o MLflow Tracing com DSPy, você precisa instalar o MLflow e a dspy-ai biblioteca.

Desenvolvimento

Para ambientes de desenvolvimento, instale o pacote MLflow completo com os extras do Databricks e dspy-ai:

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

O pacote completo mlflow[databricks] inclui todos os recursos para desenvolvimento local e experimentação no Databricks.

Produção

Para implantações de produção, instale mlflow-tracing e dspy-ai:

pip install --upgrade mlflow-tracing dspy-ai

O mlflow-tracing pacote é otimizado para uso em produção.

Antes de executar os exemplos, você precisará configurar seu ambiente:

Para utilizadores fora dos notebooks Databricks: defina as suas variáveis de ambiente Databricks:

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

Para utilizadores dentro de blocos de notas Databricks: estas credenciais são definidas automaticamente para si.

Chaves de API: verifique se as chaves de API do provedor LLM estão configuradas. Para ambientes de produção, use segredos do Mosaic AI Gateway ou Databricks em vez de valores codificados para gerenciamento seguro de chaves de API.

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

Exemplo de Utilização

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

Rastreio durante a avaliação

A avaliação de modelos DSPy é um passo importante no desenvolvimento de sistemas de IA. O MLflow Tracing pode ajudá-lo a acompanhar o desempenho de seus programas após a avaliação, fornecendo informações detalhadas sobre a execução de seus programas para cada entrada.

Quando o rastreamento automático do MLflow está ativado para DSPy, os rastreamentos são gerados automaticamente quando você executa as suites de avaliação integradas do DSPy. O exemplo a seguir demonstra como executar rastreamentos de avaliação e revisão no MLflow:

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

Se abrir a interface de utilizador MLflow e for para a execução "Avaliação CoT", verá o resultado da avaliação e a lista de traços gerados durante a avaliação na aba Traces.

Rastreamento durante a compilação (optimização)

Compilação (otimização) é o conceito central do DSPy. Através da compilação, o DSPy otimiza automaticamente os prompts e pesos do seu programa DSPy para alcançar o melhor desempenho.

Por padrão, o MLflow NÃO gera rastreamentos durante a complicação, porque a complicação pode acionar centenas ou milhares de invocações de módulos DSPy. Para habilitar o rastreamento para compilação, você pode chamar a mlflow.dspy.autolog função com o log_traces_from_compile parâmetro definido como True.

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

Desativar o rastreamento automático

O rastreamento automático para LlamaIndex pode ser desativado globalmente chamando mlflow.llama_index.autolog(disable=True) ou mlflow.autolog(disable=True).