Aller au contenu principal
Dernière mise à jour le

Exemples d’évaluation MLflow pour GenAI

Le harnais d'évaluation MLflow accepte les données d'évaluation dans plusieurs formats et prend en charge des fonctions de prédiction flexibles. Cette page présente les modèles courants de saisie de données et les modèles predict_fn pour les applications GenAI.

Modèles d'entrée de données courants​

Évaluer à l'aide d'un dataset d'évaluation MLflow (recommandé)​

Les Datasets d'évaluation MLflow offrent la gestion de version, la traçabilité et l'intégration avec Unity Catalog pour une évaluation prête pour la production. Ils sont utiles lorsque vous avez besoin d'un contrôle de version et d'une traçabilité pour vos données d'évaluation, et lorsque vous devez convertir les traces en enregistrements d'évaluation.

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()],
)

Pour créer des datasets à partir de traces ou à partir de zéro, consultez Construire des datasets d'évaluation.

Évaluer à l'aide d'une liste de dictionnaires​

Utilisez une simple liste de dictionnaires pour un prototypage rapide sans créer de dataset d'évaluation formel. Ceci est utile pour un prototypage rapide, les petits datasets (moins de 100 exemples) et les tests de développement informels.

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 AI engineering platform", "agents, LLMs, and ML models"]}
    },
    {
        "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": ["Tracing", "Evaluation", "Prompt Engineering", "Model Registry"]}
    }
]

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

Pour la production, convertissez-le en un dataset d'évaluation MLflow.

Évaluer à l'aide d'un DataFrame Pandas​

Utilisez des DataFrames Pandas pour l'évaluation lorsque vous travaillez avec des fichiers CSV ou des workflows de Data Science existants. Ceci est utile pour un prototypage rapide, les petits datasets (moins de 100 exemples) et les tests de développement informels.

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 the largest open source AI engineering platform for agents, LLMs, and ML models."}
    },
    {
        "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()],
)

Évaluer à l'aide d'un Spark DataFrame​

Utilisez les DataFrames Spark pour les évaluations à grande échelle ou lorsque les données se trouvent déjà dans Delta Lake ou Unity Catalog. C'est utile lorsque les données existent déjà dans Delta Lake ou Unity Catalog, ou si vous avez besoin de filtrer les enregistrements dans un Dataset d'évaluation MLflow avant d'exécuter l'évaluation.

Le DataFrame doit être conforme au schéma du dataset d'évaluation.

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()],
)

Modèles predict_fn courants​

Appelez votre application directement​

Transmettez votre application directement en tant que predict_fn lorsque les noms des paramètres correspondent aux clés de votre jeu de données d'évaluation. Ceci est utile pour les applications dont les noms de paramètres correspondent à inputs dans votre jeu de données d'évaluation.

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()]
)

Encapsulez votre application dans une fonction appelable​

Si votre application s’attend à des noms de paramètres ou des structures de données différents de ceux de votre dataset d’évaluation inputs, enveloppez-la dans une fonction invocable. Ceci est utile lorsqu'il y a des incohérences de noms de parameter entre les parameters de votre application et les clés du dataset d'évaluation input (par exemple, user_input vs question), ou lorsque des conversions de format de données sont requises (par exemple, chaîne en liste ou analyse 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()]
)

Évaluer un Endpoint déployé​

Utilisez la fonction to_predict_fn pour évaluer les Agents personnalisés, les endpoints de chat Model Serving et les endpoints personnalisés.

Cette fonction crée une fonction de prédiction compatible avec ces endpoints et extrait automatiquement les traces des endpoints avec traçage activé pour une observabilité complète.

remarque

La fonction to_predict_fn effectue une transmission kwargs directement vers votre Endpoint. Vos données d'évaluation doivent correspondre au format d'entrée que votre endpoint attend. Si les formats ne correspondent pas, l'évaluation échoue avec un message d'erreur concernant des clés d'entrée non reconnues.

Les Endpoint de discussion Model Serving nécessitent des données formatées avec la clé messages.

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()]
)

Évaluer un modèle enregistré​

Enveloppez les modèles MLflow enregistrés pour traduire entre les paramètres nommés de l'évaluation et l'interface à paramètre unique du modèle.

La plupart des modèles journalisés (tels que ceux utilisant PyFunc ou les variantes de journalisation comme LangChain) acceptent un seul parameter d'entrée (par exemple, model_inputs pour PyFunc), tandis que predict_fn attend des parameters nommés qui correspondent aux clés de votre dataset d'évaluation.

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:/catalog.schema.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()]
)
Sur cette page