Création de datasets d'évaluation MLflow

Pour tester et améliorer systématiquement une application GenAI, vous utilisez un dataset d'évaluation. Un dataset d'évaluation est un ensemble sélectionné d'entrées d'exemple, soit étiquetées (avec des sorties attendues connues) soit non étiquetées (sans réponses de vérité terrain). Les datasets d'évaluation vous aident à améliorer les performances de votre application des manières suivantes :

• Améliorez la qualité en testant les correctifs par rapport à des exemples problématiques connus issus de la production.
• Prévenir les régressions. Créez un "jeu d'or" d'exemples qui doivent toujours fonctionner correctement.
• Comparez les versions d'application. Testez différents prompts, modèles ou logiques d'application par rapport aux mêmes données.
• Cibler des fonctionnalités spécifiques. Créez des datasets spécialisés pour la sécurité, les connaissances du domaine ou les cas limites.
• Validez l'application dans différents environnements dans le cadre de LLMOps.

Les datasets d'évaluation MLflow sont stockés dans Unity Catalog, qui offre une gestion des versions, une lignée, un partage et une gouvernance intégrés.

Exigences

• Pour créer un dataset d'évaluation, vous devez disposer des autorisations CREATE TABLE sur un schéma Unity Catalog.
• Un jeu de données d'évaluation est attaché à une expérience MLflow. Si vous n'avez pas déjà d'expérimentation, consultez Créer une expérimentation MLflow pour en créer une.

Sources de données pour les jeux de données d'évaluation

Vous pouvez utiliser l’une des méthodes suivantes pour créer un dataset d’évaluation :

• Traces existantes. Si vous avez déjà capturé des traces d’une application GenAI, vous pouvez les utiliser pour créer un dataset d’évaluation basé sur des scénarios réels.
• Un dataset existant, ou des exemples saisis directement. Cette option est utile pour le prototypage rapide ou pour le test ciblé de fonctionnalités spécifiques.
• Données synthétiques. Databricks peut générer automatiquement un ensemble d'évaluation représentatif à partir de vos documents, vous permettant ainsi d'évaluer rapidement votre agent avec une bonne couverture des cas de test.

Cette page décrit comment créer un dataset d’évaluation MLflow. Vous pouvez également utiliser d'autres types de datasets, tels que des DataFrames Pandas ou une liste de dictionnaires. Consultez les exemples d’évaluation MLflow pour GenAI pour obtenir des exemples.

Créer un dataset à l'aide de l'interface utilisateur

Suivez ces étapes pour utiliser l'interface utilisateur afin de créer un dataset à partir de traces existantes. Pour des informations de référence, consultez l'interface utilisateur du dataset d'évaluation MLflow.

1. Cliquez sur **Expériences** dans la barre latérale pour afficher la page Expériences.

2. Cliquez sur le nom de votre experimentation pour l'ouvrir.

   

3. Dans la barre latérale gauche, cliquez sur **Traces**.

4. Utilisez les cases à cocher sur le côté gauche de la liste de traces pour sélectionner les traces que vous souhaitez ajouter. Pour sélectionner toutes les traces de la page actuelle, cliquez sur la case à cocher à côté de **Trace ID** dans l’en-tête de colonne.

   

5. Cliquez sur Actions . L'étiquette du bouton indique le nombre de traces sélectionnées, par exemple Actions (3) .

   

6. Sous **Utiliser pour l'évaluation**, sélectionnez **Ajouter au dataset d'évaluation**. La boîte de dialogue **Ajouter des traces au dataset d’évaluation** s’ouvre.

7. Si aucun dataset d'évaluation n'existe pour cette expérimentation, ou si vous souhaitez ajouter des traces à un nouveau dataset, suivez ces étapes pour créer un nouveau dataset d'évaluation :

   1. Cliquez sur Créer un nouveau dataset .
   2. Sélectionnez le schéma Unity Catalog pour contenir le nouveau dataset.
   3. Saisissez un nom pour le dataset et cliquez sur **Créer un dataset**.
   4. Cliquez sur Exporter , puis sur Terminé .

   

   Si des datasets d'évaluation existent déjà pour l'Experiment, cliquez sur **Exporter** à droite du dataset auquel vous souhaitez ajouter les traces. Vous pouvez exporter vers plus d'un dataset. Lorsque vous avez terminé l'exportation, cliquez sur **Terminé**.

   

Créer un dataset en utilisant le SDK

Suivez ces étapes pour utiliser le SDK pour créer un dataset. Pour les informations de référence, consultez la référence du dataset d'évaluation.

Étape 1. Créer le dataset

Python

import mlflow
import mlflow.genai.datasets
import time
from databricks.connect import DatabricksSession

# 0. If you are using a local development environment, connect to Serverless Spark which powers MLflow's evaluation dataset service
spark = DatabricksSession.builder.remote(serverless=True).getOrCreate()

# 1. Create an evaluation dataset

# Replace with a Unity Catalog schema where you have CREATE TABLE permission
uc_schema = "workspace.default"
# This table will be created in the above UC schema
evaluation_dataset_table_name = "email_generation_eval"

eval_dataset = mlflow.genai.datasets.create_dataset(
    name=f"{uc_schema}.{evaluation_dataset_table_name}",
)
print(f"Created evaluation dataset: {uc_schema}.{evaluation_dataset_table_name}")

Étape 2 : Ajoutez des enregistrements à votre dataset

Cette section décrit plusieurs options pour ajouter des enregistrements au dataset d’évaluation.

From existing traces

L'une des façons les plus efficaces de créer un dataset d'évaluation pertinent est de sélectionner des exemples directement à partir des interactions historiques de votre application capturées par MLflow Tracing. Vous pouvez créer des datasets à partir de traces en utilisant l'interface utilisateur de monitoring MLflow ou le SDK.

Recherchez des traces par programmation, puis ajoutez-les au dataset à l'aide de search_traces(). Utilisez des filtres pour identifier les traces par succès, échec, utilisation en production ou d'autres propriétés. Voir Rechercher des traces par programmation.

Python

import mlflow

# 2. Search for traces
traces = mlflow.search_traces(
    filter_string="attributes.status = 'OK'",
    order_by=["attributes.timestamp_ms DESC"],
    tags.environment = 'production',
    max_results=10
)

print(f"Found {len(traces)} successful traces")

# 3. Add the traces to the evaluation dataset
eval_dataset = eval_dataset.merge_records(traces)
print(f"Added {len(traces)} records to evaluation dataset")

# Preview the dataset
df = eval_dataset.to_df()
print(f"\nDataset preview:")
print(f"Total records: {len(df)}")
print("\nSample record:")
sample = df.iloc[0]
print(f"Inputs: {sample['inputs']}")

Sélectionnez les traces pour les datasets d'évaluation

Avant d'ajouter des traces à votre dataset, identifiez les traces qui représentent des cas de test importants pour vos besoins d'évaluation. Vous pouvez utiliser une analyse quantitative et qualitative pour sélectionner des traces représentatives.

Sélection quantitative de traces

Utilisez l'interface utilisateur ou le SDK MLflow pour filtrer et analyser les traces en fonction de caractéristiques mesurables :

• Dans l'interface utilisateur de MLflow : filtrez par balises (par exemple, tag.quality_score < 0.7), recherchez des entrées/sorties spécifiques, triez par latence ou utilisation des jetons
• Par programmation : Query des traces pour effectuer une analyse avancée

Python

import mlflow
import pandas as pd

# Search for traces with potential quality issues
traces_df = mlflow.search_traces(
    filter_string="tag.quality_score < 0.7",
    max_results=100
)

# Analyze patterns
# For example, check if quality issues correlate with token usage
correlation = traces_df["span.attributes.usage.total_tokens"].corr(traces_df["tag.quality_score"])
print(f"Correlation between token usage and quality: {correlation}")

Pour la syntaxe complète et des exemples de trace query, consultez Rechercher les traces par programme.

Sélection qualitative des traces

Passez en revue les traces individuelles pour identifier les modèles nécessitant un jugement humain :

• Examinez les entrées qui ont conduit à des sorties de mauvaise qualité.
• Recherchez des modèles dans la manière dont votre application a géré les cas limites.
• Identifier le contexte manquant ou le raisonnement erroné
• Comparer les traces de haute qualité et de faible qualité pour comprendre les facteurs de différenciation.

Une fois que vous avez identifié les traces représentatives, ajoutez-les à votre dataset en utilisant les méthodes de recherche et de Merge décrites ci-dessus.

astuce

Enrichissez vos traces avec des sorties attendues ou des indicateurs de qualité pour permettre la comparaison de la vérité terrain. Consultez recueillir les commentaires d'experts du domaine pour ajouter des étiquettes humaines.

From domain expert labels

Tirer parti des commentaires d'experts en la matière capturés lors de sessions d'étiquetage MLflow pour enrichir vos jeux de données d'évaluation avec des étiquettes de vérité terrain. Avant d'effectuer ces étapes, suivez le guide pour recueillir les commentaires des experts du domaine afin de créer une session d'étiquetage.

Python

import mlflow.genai.labeling as labeling

# Get a labeling sessions
all_sessions = labeling.get_labeling_sessions()
print(f"Found {len(all_sessions)} sessions")

for session in all_sessions:
    print(f"- {session.name} (ID: {session.labeling_session_id})")
    print(f"  Assigned users: {session.assigned_users}")

# Sync from the labeling session to the dataset

all_sessions[0].sync(dataset_name=f"{uc_schema}.{evaluation_dataset_table_name}")

astuce

Après avoir recueilli le feedback des experts, vous pouvez aligner les juges pour qu'ils correspondent au feedback humain. Voir Aligner les juges LLM avec le feedback humain.

Build from scratch or import existing

Vous pouvez importer un dataset existant ou créer des exemples à partir de zéro. Vos données doivent correspondre (ou être transformées pour correspondre) au schéma du dataset d'évaluation.

Python

# Define comprehensive test cases
evaluation_examples = [
    {
        "inputs": {"question": "What is MLflow?"},
        "expected": {
            "expected_response": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
            "expected_facts": [
                "open source AI engineering platform",
                "agents, LLMs, and ML models",
                "experiment tracking",
                "model deployment"
            ]
        },
    },
]

eval_dataset = eval_dataset.merge_records(evaluation_examples)

Seed using synthetic data

La génération de données synthétiques peut étendre vos efforts de test en créant rapidement des entrées diverses et en couvrant les cas extrêmes. Consultez Synthétiser les jeux d'évaluation.

For conversation simulation

Pour activer des tests multi-tours reproductibles, utilisez un code similaire à ce qui suit pour stocker les cas de test pour la simulation de conversation. Pour la documentation complète sur la simulation des conversations multi-tours, consultez Simulation de conversation.

Python

from mlflow.genai.datasets import create_dataset, get_dataset
from mlflow.genai.simulators import ConversationSimulator

# Create a dataset for simulation test cases
dataset = create_dataset(
    name="conversation_scenarios",
    tags={"type": "simulation", "agent": "support-bot"},
)

# Define test cases with goals and personas
simulation_test_cases = [
    {
        "inputs": {
            "goal": "Get help setting up experiment tracking",
            "persona": "You are a data scientist new to MLflow",
        },
    },
    {
        "inputs": {
            "goal": "Debug a model deployment error",
            "persona": "You are a senior engineer who expects precise answers",
        },
    },
    {
        "inputs": {
            "goal": "Understand model versioning best practices",
            "persona": "You are building an ML platform for your team",
            "context": {"team_size": "large", "compliance": "strict"},
        },
    },
]

dataset.merge_records(simulation_test_cases)

# Later, use the dataset with ConversationSimulator
dataset = get_dataset(name="conversation_scenarios")
simulator = ConversationSimulator(test_cases=dataset)

Mettre à jour les datasets existants

Vous pouvez utiliser l'interface utilisateur ou le SDK pour mettre à jour un dataset d'évaluation.

Databricks UI

Utilisez l'interface utilisateur pour ajouter des enregistrements à un dataset d'évaluation existant.

1. Ouvrez la page du dataset dans le Databricks workspace :

   1. Dans le Workspace Databricks, naviguez vers votre Experimentation.
   2. Dans la barre latérale gauche, cliquez sur **Datasets**.
   3. Cliquez sur le nom du dataset dans la liste.

   

2. Cliquez sur **Ajouter un enregistrement**. Une nouvelle ligne apparaît avec du contenu générique.

3. Modifiez directement la nouvelle ligne pour saisir l'entrée et les attentes du nouvel enregistrement. Si vous le souhaitez, définissez des tags pour le nouvel enregistrement.

4. Cliquez sur Enregistrer les modifications .

MLflow SDK

Utilisez le MLflow SDK pour mettre à jour un dataset d'évaluation existant :

Python

import mlflow.genai.datasets
import pandas as pd

# Load existing dataset
dataset = mlflow.genai.datasets.get_dataset(name="catalog.schema.eval_dataset")

# Add new test cases
new_cases = [
    {
        "inputs": {"question": "What are MLflow models?"},
        "expectations": {
            "expected_facts": ["model packaging", "deployment", "registry"],
            "min_response_length": 100
        }
    }
]

# Merge new cases
dataset = dataset.merge_records(new_cases)

Limitations

• Les datasets d'évaluation ne peuvent pas être stockés dans des catalogues chiffrés avec des clés gérées par les clients (CMK). Les Workspaces avec CMK sont pris en charge tant que le dataset est stocké dans un catalogue sans CMK.
• Maximum de 2000 lignes par dataset d'évaluation.
• Maximum de 20 attentes par enregistrement de dataset.

Si vous avez besoin que l'une de ces limitations soit assouplie pour votre cas d'utilisation, veuillez contacter votre représentant Databricks.

Ressources supplémentaires

• Évaluez votre application - Utilisez votre dataset nouvellement créé pour l'évaluation.
• Créer des juges personnalisés — Créez des juges LLM personnalisés pour évaluer les sorties de vos applications.
• Aligner les juges avec les feedbacks — Améliorez continuellement vos évaluations en alignant les juges avec l'expertise des feedbacks
• query traces via the SDK – Analyse programmatique avancée des traces pour la sélection de dataset