Pular para o conteúdo principal

Exemplos de avaliação do MLflow para GenAI

Esta página apresenta alguns padrões de uso comuns para o conjunto de avaliação, incluindo padrões de dados e padrões predict_fn .

Padrões comuns de entrada de dados​

Avaliar usando um conjunto de dados de avaliação MLflow (recomendado)​

O conjunto de dados de avaliação MLflow fornece controle de versão, acompanhamento de linhagem e integração com Unity Catalog para avaliação pronta para produção. Eles são úteis quando você precisa de controle de versão e acompanhamento de linhagem para seus dados de avaliação e quando precisa converter rastreamentos em registros de avaliação.

Python
import mlflow
from mlflow.genai.scorers import Correctness, Safety
from my_app import agent  # Your GenAI app with tracing

# Load versioned evaluation dataset
dataset = mlflow.genai.datasets.get_dataset("catalog.schema.eval_dataset_name")

# Run evaluation
results = mlflow.genai.evaluate(
    data=dataset,
    predict_fn=agent,
    scorers=[Correctness(), Safety()],
)

Para criar um conjunto de dados a partir de rastreamentos ou do zero, consulte Construir conjunto de dados de avaliação.

Avalie usando uma lista de dicionários​

Use uma lista simples de dicionários para prototipagem rápida sem criar um dataset de avaliação formal. Isso é útil para prototipagem rápida, pequenos conjuntos de dados (menos de 100 exemplos) e testes de desenvolvimento informais.

Python
import mlflow
from mlflow.genai.scorers import Correctness, RelevanceToQuery
from my_app import agent  # Your GenAI app with tracing

# Define test data as a list of dictionaries
eval_data = [
    {
        "inputs": {"question": "What is MLflow?"},
        "expectations": {"expected_facts": ["open-source platform", "ML lifecycle management"]}
    },
    {
        "inputs": {"question": "How do I track experiments?"},
        "expectations": {"expected_facts": ["mlflow.start_run()", "log metrics", "log parameters"]}
    },
    {
        "inputs": {"question": "What are MLflow's main components?"},
        "expectations": {"expected_facts": ["Tracking", "Projects", "Models", "Registry"]}
    }
]

# Run evaluation
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=agent,
    scorers=[Correctness(), RelevanceToQuery()],
)

Para produção, converta para um conjunto de dados de avaliaçãoMLflow.

Avalie usando um Pandas DataFrame​

Use Pandas DataFrames para avaliação ao trabalhar com arquivos CSV ou dados científicos de fluxo de trabalho existentes. Isso é útil para prototipagem rápida, pequenos conjuntos de dados (menos de 100 exemplos) e testes de desenvolvimento informais.

Python
import mlflow
import pandas as pd
from mlflow.genai.scorers import Correctness, Safety
from my_app import agent  # Your GenAI app with tracing

# Create evaluation data as a Pandas DataFrame
eval_df = pd.DataFrame([
    {
        "inputs": {"question": "What is MLflow?"},
        "expectations": {"expected_response": "MLflow is an open-source platform for ML lifecycle management"}
    },
    {
        "inputs": {"question": "How do I log metrics?"},
        "expectations": {"expected_response": "Use mlflow.log_metric() to log metrics"}
    }
])

# Run evaluation
results = mlflow.genai.evaluate(
    data=eval_df,
    predict_fn=agent,
    scorers=[Correctness(), Safety()],
)

Avaliar usando um Spark DataFrame​

Use Spark DataFrames para avaliações em larga escala ou quando os dados já estiverem no Delta Lake ou no Unity Catalog. Isso é útil quando os dados já existem no Delta Lake ou Unity Catalog, ou se você precisa filtrar os registros em um conjunto de dados de avaliação MLflow antes de executar a avaliação.

O DataFrame deve estar em conformidade com o esquema dataset de avaliação.

Python
import mlflow
from mlflow.genai.scorers import Safety, RelevanceToQuery
from my_app import agent  # Your GenAI app with tracing

# Load evaluation data from a Delta table in Unity Catalog
eval_df = spark.table("catalog.schema.evaluation_data")

# Or load from any Spark-compatible source
# eval_df = spark.read.parquet("path/to/evaluation/data")

# Run evaluation
results = mlflow.genai.evaluate(
    data=eval_df,
    predict_fn=agent,
    scorers=[Safety(), RelevanceToQuery()],
)

Padrões comuns predict_fn​

Ligue para seu aplicativo diretamente​

Passe seu aplicativo diretamente como predict_fn quando os nomes dos parâmetros corresponderem à sua chave dataset de avaliação. Isso é útil para aplicativos que têm nomes de parâmetros que correspondem ao inputs no seu dataset de avaliação.

Python
import mlflow
from mlflow.genai.scorers import RelevanceToQuery, Safety

# Your GenAI app that accepts 'question' as a parameter
@mlflow.trace
def my_chatbot_app(question: str) -> dict:
    # Your app logic here
    response = f"I can help you with: {question}"
    return {"response": response}

# Evaluation data with 'question' key matching the function parameter
eval_data = [
    {"inputs": {"question": "What is MLflow?"}},
    {"inputs": {"question": "How do I track experiments?"}}
]

# Pass your app directly since parameter names match
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_chatbot_app,  # Direct reference, no wrapper needed
    scorers=[RelevanceToQuery(), Safety()]
)

Envolva seu aplicativo em um chamável​

Se seu aplicativo espera nomes de parâmetros ou estruturas de dados diferentes do seu dataset de avaliação inputs, envolva-os em uma função que pode ser chamada. Isso é útil quando há incompatibilidades de nomes de parâmetros entre os parâmetros do seu aplicativo e a chave dataset de avaliação input (por exemplo, user_input vs question) ou quando conversões de formato de dados são necessárias (por exemplo, strings para lista ou análise JSON ).

Python
import mlflow
from mlflow.genai.scorers import RelevanceToQuery, Safety

# Your existing GenAI app with different parameter names
@mlflow.trace
def customer_support_bot(user_message: str, chat_history: list = None) -> dict:
    # Your app logic here
    context = f"History: {chat_history}" if chat_history else "New conversation"
    return {
        "bot_response": f"Helping with: {user_message}. {context}",
        "confidence": 0.95
    }

# Wrapper function to translate evaluation data to your app's interface
def evaluate_support_bot(question: str, history: str = None) -> dict:
    # Convert evaluation dataset format to your app's expected format
    chat_history = history.split("|") if history else []

    # Call your app with the translated parameters
    result = customer_support_bot(
        user_message=question,
        chat_history=chat_history
    )

    # Translate output to standard format if needed
    return {
        "response": result["bot_response"],
        "confidence_score": result["confidence"]
    }

# Evaluation data with different key names
eval_data = [
    {"inputs": {"question": "Reset password", "history": "logged in|forgot email"}},
    {"inputs": {"question": "Track my order"}}
]

# Use the wrapper function for evaluation
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=evaluate_support_bot,  # Wrapper handles translation
    scorers=[RelevanceToQuery(), Safety()]
)

Avaliar um endpoint implantado​

Use a função to_predict_fn para avaliar Mosaic AI Agent Framework, o ponto de extremidade de chat do modelo servindo e o ponto de extremidade personalizado.

Esta função cria uma função de previsão compatível com esses pontos de extremidade e extrai automaticamente os rastros do ponto de extremidade habilitado para rastreio para total observabilidade.

nota

A função to_predict_fn executa uma passagem kwargs diretamente para seu endpoint. Seus dados de avaliação devem corresponder ao formato de entrada que seu endpoint espera. Se os formatos não corresponderem, a avaliação falhará com uma mensagem de erro sobre chave de entrada não reconhecida.

servindo modelo chat endpoint require data that is formatted with the messages key.

Python
import mlflow
from mlflow.genai.scorers import RelevanceToQuery

# Create predict function for a chat endpoint
predict_fn = mlflow.genai.to_predict_fn("endpoints:/my-chatbot-endpoint")

# Evaluate the chat endpoint
results = mlflow.genai.evaluate(
    data=[{"inputs": {"messages": [{"role": "user", "content": "How does MLflow work?"}]}}],
    predict_fn=predict_fn,
    scorers=[RelevanceToQuery()]
)

Avaliar um modelo registrado​

Encapsule logs de modelos MLflow para traduzir entre os parâmetros nomeados da avaliação e a interface de parâmetro único do modelo.

A maioria dos modelos registrados (como aqueles que usam PyFunc ou tipos de registro como LangChain) aceitam um único parâmetro de entrada (por exemplo, model_inputs para PyFunc), enquanto predict_fn espera parâmetros nomeados que correspondem à chave no seu dataset de avaliação.

Python
import mlflow
from mlflow.genai.scorers import Safety

# Make sure to load your logged model outside of the predict_fn so MLflow only loads it once!
model = mlflow.pyfunc.load_model("models:/chatbot/staging")

def evaluate_model(question: str) -> dict:
    return model.predict({"question": question})

results = mlflow.genai.evaluate(
    data=[{"inputs": {"question": "Tell me about MLflow"}}],
    predict_fn=evaluate_model,
    scorers=[Safety()]
)
Última atualização em