Aller au contenu principal
Dernière mise à jour le

Évaluer et comparer les versions d'invites

info

Bêta

Cette fonctionnalité est en Bêta. Les administrateurs du Workspace peuvent contrôler l'accès à cette fonctionnalité à partir de la page Previews . Consultez Gérer les aperçus Databricks.

Ce guide vous montre comment évaluer systématiquement différentes versions de prompt afin d'identifier les plus efficaces pour vos agents et applications GenAI. Vous apprendrez à créer des versions de prompt, à créer des datasets d'évaluation avec les faits attendus et à utiliser le framework d'évaluation de MLflow pour comparer les performances.

Tout le code de cette page est inclus dans l'exemple de notebook.

Prérequis​

Ce guide requiert :

  • MLflow 3.1.0 ou supérieur.
  • Accès à l'API OpenAI ou Databricks Model Serving.
  • Schéma Unity Catalog avec les privilèges CREATE FUNCTION, EXECUTE et MANAGE.
remarque

Si vous utilisez un compte d'essai Databricks, vous disposez des autorisations requises sur le schéma Unity Catalog workspace.default.

Bonnes pratiques​

  1. Start simple : débutez avec des prompts de base et améliorez de manière itérative en fonction des résultats d'évaluation.
  2. Utilisez des datasets cohérents : évaluez toutes les versions avec les mêmes données pour une comparaison équitable.
  3. Suivre tout : Enregistrez les versions des invites, les résultats d'évaluation et les décisions de déploiement.
  4. Tester les cas limites : incluez des exemples difficiles dans votre dataset d'évaluation.
  5. Surveillez la production : continuez à évaluer les invites après le déploiement pour détecter la dégradation.
  6. Documentez les modifications : utilisez des messages de commit significatifs pour suivre la raison des modifications.

Étape 1 : Configurez votre environnement​

remarque

Vous avez besoin des privilèges CREATE FUNCTION, EXECUTE et MANAGE sur le catalogue et le schéma pour créer des invites et des datasets d'évaluation.

Tout d'abord, configurez votre schéma Unity Catalog et installez les packages requis :

Python
# Install required packages
%pip install --upgrade "mlflow[databricks]>=3.1.0" "openai>=1.0.0"
dbutils.library.restartPython()

# Configure your Unity Catalog schema
import mlflow
import pandas as pd
from openai import OpenAI
import uuid

CATALOG = "main"        # Replace with your catalog name
SCHEMA = "default"      # Replace with your schema name

# Create unique names for the prompt and dataset
SUFFIX = uuid.uuid4().hex[:8]  # Short unique suffix
PROMPT_NAME = f"{CATALOG}.{SCHEMA}.summary_prompt_{SUFFIX}"
EVAL_DATASET_NAME = f"{CATALOG}.{SCHEMA}.summary_eval_{SUFFIX}"

print(f"Prompt name: {PROMPT_NAME}")
print(f"Evaluation dataset: {EVAL_DATASET_NAME}")

# Set up OpenAI client
client = OpenAI()

Étape 2 : Créez des versions d'invite​

Enregistrer différentes versions de prompt représentant différentes approches pour votre tâche :

Python
# Version 1: Basic prompt
prompt_v1 = mlflow.genai.register_prompt(
    name=PROMPT_NAME,
    template="Summarize this text: {{content}}",
    commit_message="v1: Basic summarization prompt"
)

print(f"Created prompt version {prompt_v1.version}")

# Version 2: Improved with comprehensive guidelines
prompt_v2 = mlflow.genai.register_prompt(
    name=PROMPT_NAME,
    template="""You are an expert summarizer. Create a summary of the following content in *exactly* 2 sentences (no more, no less - be very careful about the number of sentences).

Guidelines:
- Include ALL core facts and key findings
- Use clear, concise language
- Maintain factual accuracy
- Cover all main points mentioned
- Write for a general audience
- Use exactly 2 sentences

Content: {{content}}

Summary:""",
    commit_message="v2: Added comprehensive fact coverage with 2-sentence requirement"
)

print(f"Created prompt version {prompt_v2.version}")

Étape 3 : Créer un dataset d’évaluation​

Créez un dataset avec les faits attendus qui devraient apparaître dans de bons résumés :

Python
# Create evaluation dataset
eval_dataset = mlflow.genai.datasets.create_dataset(
    uc_table_name=EVAL_DATASET_NAME
)

# Add summarization examples with expected facts
evaluation_examples = [
    {
        "inputs": {
            "content": """Remote work has fundamentally changed how teams collaborate and communicate. Companies have adopted new digital tools for video conferencing, project management, and file sharing. While productivity has remained stable or increased in many cases, challenges include maintaining company culture, ensuring work-life balance, and managing distributed teams across time zones. The shift has also accelerated digital transformation initiatives and changed hiring practices, with many companies now recruiting talent globally rather than locally."""
        },
        "expectations": {
            "expected_facts": [
                "remote work changed collaboration",
                "digital tools adoption",
                "productivity remained stable",
                "challenges with company culture",
                "work-life balance issues",
                "global talent recruitment"
            ]
        }
    },
    {
        "inputs": {
            "content": """Electric vehicles are gaining mainstream adoption as battery technology improves and charging infrastructure expands. Major automakers have committed to electrification with new models launching regularly. Government incentives and environmental regulations are driving consumer interest. However, challenges remain including higher upfront costs, limited charging stations in rural areas, and concerns about battery life and replacement costs. The market is expected to grow significantly over the next decade."""
        },
        "expectations": {
            "expected_facts": [
                "electric vehicles gaining adoption",
                "battery technology improving",
                "charging infrastructure expanding",
                "government incentives",
                "higher upfront costs",
                "limited rural charging",
                "market growth expected"
            ]
        }
    },
    {
        "inputs": {
            "content": """Artificial intelligence is transforming healthcare through diagnostic imaging, drug discovery, and personalized treatment plans. Machine learning algorithms can now detect diseases earlier and more accurately than traditional methods. AI-powered robots assist in surgery and patient care. However, concerns exist about data privacy, algorithm bias, and the need for regulatory oversight. Healthcare providers must balance innovation with patient safety and ethical considerations."""
        },
        "expectations": {
            "expected_facts": [
                "AI transforming healthcare",
                "diagnostic imaging improvements",
                "drug discovery acceleration",
                "personalized treatment",
                "earlier disease detection",
                "data privacy concerns",
                "algorithm bias issues",
                "regulatory oversight needed"
            ]
        }
    }
]

eval_dataset = eval_dataset.merge_records(evaluation_examples)
print(f"Added {len(evaluation_examples)} summarization examples to evaluation dataset")

Étape 4: Créer des fonctions d'évaluation et des métriques personnalisées​

Définir des fonctions qui utilisent vos versions d'invite et créer des métriques d'évaluation personnalisées :

Python
def create_summary_function(prompt_name: str, version: int):
    """Create a summarization function for a specific prompt version."""

    @mlflow.trace
    def summarize_content(content: str) -> dict:
        # Load the prompt version
        prompt = mlflow.genai.load_prompt(
            name_or_uri=f"prompts:/{prompt_name}/{version}"
        )

        # Format and call the LLM
        formatted_prompt = prompt.format(content=content)

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": formatted_prompt}],
            temperature=0.1
        )

        return {"summary": response.choices[0].message.content}

    return summarize_content

Créez un juge avec une invite personnalisée.​

Créez un juge avec un prompt personnalisé pour évaluer des critères spécifiques en utilisant make_judge:

Python
from typing import Literal
from mlflow.genai import make_judge

# Create a custom judge using make_judge
sentence_count_judge = make_judge(
    name="sentence_count_compliance",
    instructions="""Evaluate if this summary follows the 2-sentence requirement.

Summary: {{ outputs }}

Count the sentences carefully and determine if the summary has exactly 2 sentences.""",
    feedback_value_type=Literal["correct", "incorrect"],
)

Étape 5 : Exécuter une évaluation comparative​

Évaluez chaque version d’invite à l’aide d’évaluateurs intégrés et personnalisés :

Python
from mlflow.genai.scorers import Correctness

# Define scorers
scorers = [
    Correctness(),  # Checks expected facts
    sentence_count_judge,  # Custom sentence count judge
]

# Evaluate each version
results = {}

for version in [1, 2]:
    print(f"\nEvaluating version {version}...")

    with mlflow.start_run(run_name=f"summary_v{version}_eval"):
        mlflow.log_param("prompt_version", version)

        # Run evaluation
        eval_results = mlflow.genai.evaluate(
            predict_fn=create_summary_function(PROMPT_NAME, version),
            data=eval_dataset,
            scorers=scorers,
        )

        results[f"v{version}"] = eval_results
        print(f"  Correctness score: {eval_results.metrics.get('correctness/mean', 0):.2f}")
        print(f"  Sentence compliance: {eval_results.metrics.get('sentence_count_compliance/mean', 0):.2f}")

Étape 6 : Comparer les résultats et sélectionner la meilleure version​

Analysez les résultats pour identifier le prompt le plus performant :

Python
# Compare versions across all metrics
print("=== Version Comparison ===")
for version, result in results.items():
    correctness_score = result.metrics.get('correctness/mean', 0)
    compliance_score = result.metrics.get('sentence_count_compliance/mean', 0)
    print(f"{version}:")
    print(f"  Correctness: {correctness_score:.2f}")
    print(f"  Sentence compliance: {compliance_score:.2f}")
    print()

# Calculate composite scores
print("=== Composite Scores ===")
composite_scores = {}
for version, result in results.items():
    correctness = result.metrics.get('correctness/mean', 0)
    compliance = result.metrics.get('sentence_count_compliance/mean', 0)
    # Weight correctness more heavily (70%) than compliance (30%)
    composite = 0.7 * correctness + 0.3 * compliance
    composite_scores[version] = composite
    print(f"{version}: {composite:.2f}")

# Find best version
best_version = max(composite_scores.items(), key=lambda x: x[1])
print(f"\nBest performing version: {best_version[0]} (score: {best_version[1]:.2f})")

# Show why this version is best
best_results = results[best_version[0]]
print(f"\nWhy {best_version[0]} is best:")
print(f"- Captures {best_results.metrics.get('correctness/mean', 0):.0%} of expected facts")
print(f"- Follows sentence requirements {best_results.metrics.get('sentence_count_compliance/mean', 0):.0%} of the time")

Après avoir identifié la version d'invite la plus performante par l'évaluation, vous êtes prêt à la déployer. Pour apprendre comment utiliser les alias pour le déploiement en production, veuillez consulter Utiliser les prompts dans les applications déployées.

Exemple de Notebook​

Pour un exemple de travail complet, consultez le Notebook suivant.

Évaluation d'un Notebook de démarrage rapide d'application GenAI.

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks

Ressources supplémentaires​

Sur cette page