Migrer vers MLflow 3 depuis Agent Evaluation

L’évaluation de l’agent est désormais intégrée à MLflow 3 sur Databricks. Les méthodes du Kit de développement logiciel (SDK) d’évaluation de l’agent sont désormais exposées via le mlflow[databricks]>=3.1 SDK, sous l'espace de noms mlflow.genai. MLflow 3 introduit :

• Interface utilisateur actualisée qui met en miroir toutes les fonctionnalités du Kit de développement logiciel (SDK)
• Nouveau KIT DE DÉVELOPPEMENT LOGICIEL (SDK)mlflow.genai avec des API simplifiées pour l’exécution de l’évaluation, l’étiquetage humain et la gestion des jeux de données d’évaluation
• Suivi amélioré avec un système de back-end d’ingestion des traces à grande échelle qui fournit une observabilité en temps réel
• Collecte simplifiée des commentaires humains
• Amélioration des juges LLM en tant qu’évaluateurs intégrés

Ce guide vous aide à migrer de l’évaluation de l’agent (MLflow 2.x avec databricks-agents<1.0) vers MLflow 3. Ce guide détaillé est également disponible dans un format de référence rapide .

Liste des éléments à vérifier pour la migration

Commencez par utiliser cette liste de contrôle. Chaque élément est lié à des détails dans les sections ci-dessous.

API d’évaluation

• [ ] Mettre à jour les importations depuis databricks.agents vers mlflow.genai.*
• [ ] Convertir @metric des éléments décoratifs en @scorer
  • [ ] Mettre à jour les signatures de fonction de métrique/scoreur personnalisées
• [ ] Remplacer par mlflow.evaluate()mlflow.genai.evaluate()
  • [ ] Mettre à jour les noms des paramètres (model → predict_fn, extra_metrics → scorers)
  • [ ] Mettre à jour les noms des champs de données (request → inputs, response → outputs, expected* → expectations)
  • [ ] Remplacer evaluator_config par la configuration au niveau de l’évaluateur
  • [ ] Mettre à jour l'accès aux résultats pour utiliser mlflow.search_traces()

Juges LLM

• [ ] Remplacer les appels directs au juge par des évaluateurs prédéfinis lorsque cela est possible
• [ ] Mise à jour judges.guideline_adherence() vers judges.meets_guidelines() ou Guidelines() évaluateur
• [ ] Mettre à jour les noms des paramètres de fonction juge pour qu’ils correspondent à la nouvelle API
• [ ] Envisager d’utiliser ExpectationsGuidelines() des instructions basées sur des scénarios réels

Commentaires humains

• [ ] Mettre à jour la session d’étiquetage et examiner les importations d’applications dans mlflow.genai.labeling
• [ ] Mettre à jour les importations de schéma d’étiquette vers mlflow.genai.label_schemas
• [ ] Logique de mise à jour pour la synchronisation des commentaires sur des jeux de données

Pièges courants à éviter

• N’oubliez pas de mettre à jour les noms de champs de données dans vos DataFrames
• N’oubliez pas que model_type="databricks-agent" n’est plus nécessaire
• Vérifiez que les scoreurs personnalisés retournent des valeurs valides (« oui"/"non » pour passer/échouer)
• Utiliser search_traces() au lieu d’accéder directement aux tables de résultats
• Mettre à jour toutes les références d’espace de noms codées en dur dans votre code
• N’oubliez pas de spécifier explicitement tous les scoreurs - MLflow 3 n’exécute pas automatiquement les juges
• Convertir global_guidelines depuis la configuration vers des évaluateurs explicites Guidelines()

Migration de l’API d’évaluation

Importer des mises à jour

La liste ci-dessous résume les importations à mettre à jour, avec des détails et des exemples dans chaque sous-section ci-dessous.

# Old imports
from mlflow import evaluate
from databricks.agents.evals import metric
from databricks.agents.evals import judges

# New imports
from mlflow.genai import evaluate
from mlflow.genai.scorers import scorer
from mlflow.genai import judges
# For predefined scorers:
from mlflow.genai.scorers import (
    Correctness, Guidelines, ExpectationsGuidelines,
    RelevanceToQuery, Safety, RetrievalGroundedness,
    RetrievalRelevance, RetrievalSufficiency
)

De mlflow.evaluate() à mlflow.genai.evaluate()

L’API d’évaluation principale a été déplacée vers un espace de noms GenAI dédié avec des noms de paramètres plus propres.

Modifications de l’API clé :

Mappage des champs de données :

Exemple : Évaluation de base

MLflow 2.x :

import mlflow
import pandas as pd

eval_data = [
        {
            "request":  "What is MLflow?",
            "response": "MLflow is an open-source platform for managing ML lifecycle.",
            "expected_response": "MLflow is an open-source platform for managing ML lifecycle.",
        },
        {
            "request":  "What is Databricks?",
            "response": "Databricks is a unified analytics platform.",
            "expected_response": "Databricks is a unified analytics platform for big data and AI.",
        },
    ]

# Note: By default, MLflow 2.x runs all applicable judges automatically
results = mlflow.evaluate(
    data=eval_data,
    model=my_agent,
    model_type="databricks-agent",
    evaluator_config={
        "databricks-agent": {
            # Optional: limit to specific judges
            # "metrics": ["correctness", "safety"],
            # Optional: add global guidelines
            "global_guidelines": {
                "clarity": ["Response must be clear and concise"]
            }
        }
    }
)

# Access results
eval_df = results.tables['eval_results']

MLflow 3.x :

import mlflow
import pandas as pd
from mlflow.genai.scorers import Guidelines

eval_data = [
        {
            "inputs": {"request": "What is MLflow?"},
            "outputs": {
                "response": "MLflow is an open-source platform for managing ML lifecycle."
            },
            "expectations": {
                "expected_response":
                    "MLflow is an open-source platform for managing ML lifecycle.",

            },
        },
        {
            "inputs": {"request": "What is Databricks?"},
            "outputs": {"response": "Databricks is a unified analytics platform."},
            "expectations": {
                "expected_response":
                    "Databricks is a unified analytics platform for big data and AI.",

            },
        },
    ]

# Define guidelines for scorer
guidelines = {
    "clarity": ["Response must be clear and concise"],
    # supports str or list[str]
    "accuracy": "Response must be factually accurate",
}

print("Running evaluation with mlflow.genai.evaluate()...")

with mlflow.start_run(run_name="basic_evaluation_test") as run:
    # Run evaluation with new API
    # Note: Must explicitly specify which scorers to run (no automatic selection)
    results = mlflow.genai.evaluate(
        data=eval_data,
        scorers=[
            Correctness(),  # Requires expectations.expected_response
            RelevanceToQuery(),  # No ground truth needed
            Guidelines(name="clarity", guidelines=guidelines["clarity"]),
            Guidelines(name="accuracy", guidelines=guidelines["accuracy"]),
            # ExpectationsGuidelines(),
            # Add more scorers as needed: Safety(), RetrievalGroundedness(), etc.
        ],
    )

# Access results using search_traces
traces = mlflow.search_traces(
        run_id=results.run_id,
)

Accès aux résultats de l’évaluation

Dans MLflow 3, les résultats sont stockés sous forme de traces avec des évaluations. Permet mlflow.search_traces() d’accéder aux résultats détaillés :

# Access results using search_traces
traces = mlflow.search_traces(
    run_id=results.run_id,
)

# Access assessments for each trace
for trace in traces:
    assessments = trace.info.assessments
    for assessment in assessments:
        print(f"Scorer: {assessment.name}")
        print(f"Value: {assessment.value}")
        print(f"Rationale: {assessment.rationale}")

Évaluation d’un modèle enregistré MLflow

Dans MLflow 2.x, vous pouvez passer directement un modèle MLflow journalisé (comme un modèle PyFunc ou un modèle journalisé par Agent Framework) à mlflow.evaluate(). Dans MLflow 3.x, vous devez encapsuler le modèle dans une fonction de prédiction pour gérer le mappage de paramètres.

Ce wrapper est nécessaire, car mlflow.genai.evaluate() attend une fonction de prédiction qui accepte les clés du inputs dictionnaire à partir de votre ensemble de données en tant qu’arguments de mot clé, tandis que la plupart des modèles journalisés acceptent un paramètre d’entrée unique (par exemple, model_inputs pour les modèles PyFunc ou des interfaces similaires pour les modèles LangChain).

La fonction de prédiction sert de couche de traduction entre les paramètres nommés de l’infrastructure d’évaluation et le format d’entrée attendu du modèle.

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

Métriques personnalisées pour la migration des scoreurs

Les fonctions d’évaluation personnalisées (@metric) utilisent désormais le @scorer décorateur avec une signature simplifiée.

Modifications clés :

Exemple : Évaluateur réussite/échec

MLflow 2.x :

from databricks.agents.evals import metric

@metric
def response_length_check(request, response, expected_response=None):
    """Check if response is within acceptable length."""
    length = len(response)
    return "yes" if 50 <= length <= 500 else "no"

# Use in evaluation
results = mlflow.evaluate(
    data=eval_data,
    model=my_agent,
    model_type="databricks-agent",
    extra_metrics=[response_length_check]
)

MLflow 3.x :

import mlflow
from mlflow.genai.scorers import scorer


# Sample agent function
@mlflow.trace
def my_agent(request: str):
    """Simple mock agent for testing - MLflow 3 expects dict input"""
    responses = {
        "What is MLflow?": "MLflow is an open-source platform for managing ML lifecycle.",
        "What is Databricks?": "Databricks is a unified analytics platform.",
    }
    return {"response": responses.get(request, "I don't have information about that.")}


@scorer
def response_length_check(inputs, outputs, expectations=None, traces=None):
    """Check if response is within acceptable length."""
    length = len(outputs)
    return "yes" if 50 <= length <= 500 else "no"

# Use in evaluation
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[response_length_check]
)

Exemple : Évaluateur numérique avec Évaluation

MLflow 2.x :

from databricks.agents.evals import metric, Assessment

def calculate_similarity(response, expected_response):
    return 1

@metric
def semantic_similarity(response, expected_response):
    """Calculate semantic similarity score."""
    # Your similarity logic here
    score = calculate_similarity(response, expected_response)

    return Assessment(
        name="semantic_similarity",
        value=score,
        rationale=f"Similarity score based on embedding distance: {score:.2f}"
    )

MLflow 3.x :

from mlflow.genai.scorers import scorer
from mlflow.entities import Feedback

@scorer
def semantic_similarity(outputs, expectations):
    """Calculate semantic similarity score."""
    # Your similarity logic here
    expected = expectations.get("expected_response", "")
    score = calculate_similarity(outputs, expected)

    return Feedback(
        name="semantic_similarity",
        value=score,
        rationale=f"Similarity score based on embedding distance: {score:.2f}"
    )

Migration des juges LLM

Différences clés dans le comportement du juge

Sélection automatique du juge :

Sélection automatique de juge MLflow 2.x :

• Sans scénarios réels : s’exécute chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• Avec des scénarios réels : s’exécute également context_sufficiency, correctness

Sélection explicite de l’évaluateur MLflow 3.x :

• Vous devez répertorier explicitement les évaluateurs que vous souhaitez exécuter
• Plus de contrôle, mais nécessite d’être explicite sur les besoins d’évaluation

Chemins de migration

MLflow 3 offre deux façons d’utiliser les juges LLM :

1. Évaluateurs prédéfinis - Évaluateurs prêts à l’emploi qui incluent les juges dans un wrapper avec l’analyse automatique des traces
2. Appels directs aux juges - Appeler des juges directement au sein de systèmes de score personnalisés pour un meilleur contrôle

Contrôle de l’exécution des juges

Exemple : spécification des juges à exécuter

MLflow 2.x (limitation des juges par défaut) :

import mlflow

# By default, runs all applicable judges
# Use evaluator_config to limit which judges run
results = mlflow.evaluate(
    data=eval_data,
    model=my_agent,
    model_type="databricks-agent",
    evaluator_config={
        "databricks-agent": {
            # Only run these specific judges
            "metrics": ["groundedness", "relevance_to_query", "safety"]
        }
    }
)

MLflow 3.x (sélection explicite du scoreur) :

from mlflow.genai.scorers import (
    RetrievalGroundedness,
    RelevanceToQuery,
    Safety
)

# Must explicitly specify which scorers to run
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[
        RetrievalGroundedness(),
        RelevanceToQuery(),
        Safety()
    ]
)

Exemple de migration complet

Cet exemple montre la migration d’une évaluation qui utilise plusieurs juges avec une configuration personnalisée :

MLflow 2.x :

from databricks.agents.evals import judges, metric
import mlflow

# Custom metric using judge
@metric
def check_no_pii(request, response, retrieved_context):
    """Check if retrieved context contains PII."""
    context_text = '\n'.join([c['content'] for c in retrieved_context])

    return judges.guideline_adherence(
        request=request,
        guidelines=["The context must not contain personally identifiable information."],
        guidelines_context={"retrieved_context": context_text}
    )

# Define global guidelines
global_guidelines = {
    "tone": ["Response must be professional and courteous"],
    "format": ["Response must use bullet points for lists"]
}

# Run evaluation with multiple judges
results = mlflow.evaluate(
    data=eval_data,
    model=my_agent,
    model_type="databricks-agent",
    evaluator_config={
        "databricks-agent": {
            # Specify subset of built-in judges
            "metrics": ["correctness", "groundedness", "safety"],
            # Add global guidelines
            "global_guidelines": global_guidelines
        }
    },
    # Add custom judge
    extra_metrics=[check_no_pii]
)

MLflow 3.x :

from mlflow.genai.scorers import (
    Correctness,
    RetrievalGroundedness,
    Safety,
    Guidelines,
    scorer
)
from mlflow.genai import judges
import mlflow

# Custom scorer using judge
@scorer
def check_no_pii(inputs, outputs, traces):
    """Check if retrieved context contains PII."""
    # Extract retrieved context from trace
    retrieved_context = traces.data.spans[0].attributes.get("retrieved_context", [])
    context_text = '\n'.join([c['content'] for c in retrieved_context])

    return judges.meets_guidelines(
        name="no_pii",
        context={
            "request": inputs,
            "retrieved_context": context_text
        },
        guidelines=["The context must not contain personally identifiable information."]
    )

# Run evaluation with explicit scorers
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[
        # Built-in scorers (explicitly specified)
        Correctness(),
        RetrievalGroundedness(),
        Safety(),
        # Global guidelines as scorers
        Guidelines(name="tone", guidelines="Response must be professional and courteous"),
        Guidelines(name="format", guidelines="Response must use bullet points for lists"),
        # Custom scorer
        check_no_pii
    ]
)

Migration vers des évaluateurs de juges prédéfinis

MLflow 3 fournit des évaluateurs prédéfinis qui intègrent les juges LLM, ce qui facilite leur utilisation avec mlflow.genai.evaluate().

Exemple : Juge de l’exactitude

MLflow 2.x :

from databricks.agents.evals import judges, metric

@metric
def check_correctness(request, response, expected_response):
    """Check if response is correct."""
    return judges.correctness(
        request=request,
        response=response,
        expected_response=expected_response
    )

# Use in evaluation
results = mlflow.evaluate(
    data=eval_data,
    model=my_agent,
    model_type="databricks-agent",
    extra_metrics=[check_correctness]
)

MLflow 3.x (Option 1 : Utilisation du scoreur prédéfini) :

from mlflow.genai.scorers import Correctness

# Use predefined scorer directly
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[Correctness()]
)

MLflow 3.x (Option 2 : Scoreur personnalisé avec juge) :

from mlflow.genai.scorers import scorer
from mlflow.genai import judges

@scorer
def check_correctness(inputs, outputs, expectations):
    """Check if response is correct."""
    return judges.correctness(
        request=inputs,
        response=outputs,
        expected_response=expectations.get("expected_response", "")
    )

# Use in evaluation
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[check_correctness]
)

Exemple : Juge de sécurité

MLflow 2.x :

from databricks.agents.evals import judges, metric

@metric
def check_safety(request, response):
    """Check if response is safe."""
    return judges.safety(
        request=request,
        response=response
    )

MLflow 3.x :

from mlflow.genai.scorers import Safety

# Use predefined scorer
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[Safety()]
)

Exemple : Juge de pertinence

MLflow 2.x :

from databricks.agents.evals import judges, metric

@metric
def check_relevance(request, response):
    """Check if response is relevant to query."""
    return judges.relevance_to_query(
        request=request,
        response=response
    )

MLflow 3.x :

from mlflow.genai.scorers import RelevanceToQuery

# Use predefined scorer
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[RelevanceToQuery()]
)

Exemple : Juge de l’ancrage

MLflow 2.x :

from databricks.agents.evals import judges, metric

@metric
def check_groundedness(response, retrieved_context):
    """Check if response is grounded in context."""
    context_text = '\n'.join([c['content'] for c in retrieved_context])
    return judges.groundedness(
        response=response,
        context=context_text
    )

MLflow 3.x :

from mlflow.genai.scorers import RetrievalGroundedness

# Use predefined scorer (automatically extracts context from trace)
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[RetrievalGroundedness()]
)

Migration de la conformité aux directives vers meets_guidelines

Le guideline_adherence juge a été renommé meets_guidelines avec une API mieux organisée.

MLflow 2.x :

from databricks.agents.evals import judges, metric

@metric
def check_tone(request, response):
    """Check if response follows tone guidelines."""
    return judges.guideline_adherence(
        request=request,
        response=response,
        guidelines=["The response must be professional and courteous."]
    )

@metric
def check_policies(request, response, retrieved_context):
    """Check if response follows company policies."""
    context_text = '\n'.join([c['content'] for c in retrieved_context])

    return judges.guideline_adherence(
        request=request,
        guidelines=["Response must comply with return policy in context."],
        guidelines_context={
            "response": response,
            "retrieved_context": context_text
        }
    )

MLflow 3.x (Option 1 : Utilisation du score de recommandations prédéfini) :

from mlflow.genai.scorers import Guidelines

# For simple guidelines that only need request/response
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[
        Guidelines(
            name="tone",
            guidelines="The response must be professional and courteous."
        )
    ]
)

MLflow 3.x (Option 2 : scoreur personnalisé avec meets_guidelines) :

from mlflow.genai.scorers import scorer
from mlflow.genai import judges

@scorer
def check_policies(inputs, outputs, traces):
    """Check if response follows company policies."""
    # Extract retrieved context from trace
    retrieved_context = traces.data.spans[0].attributes.get("retrieved_context", [])
    context_text = '\n'.join([c['content'] for c in retrieved_context])

    return judges.meets_guidelines(
        name="policy_compliance",
        guidelines="Response must comply with return policy in context.",
        context={
            "request": inputs,
            "response": outputs,
            "retrieved_context": context_text
        }
    )

Exemple : Migration de ExpectationsGuidelines

Lorsque vous souhaitez définir des instructions pour chaque exemple de votre jeu d’évaluation, par exemple exiger que certaines rubriques soient abordées, ou que la réponse suit un style spécifique, utilisez le ExpectationsGuidelines scoreur dans MLflow 3.x.

MLflow 2.x :

Dans MLflow 2.x, vous devez implémenter des instructions comme suit :

import pandas as pd

eval_data = {
    "request": "What is MLflow?",
    "response": "MLflow is an open-source platform for managing ML lifecycle.",
    "guidelines": [
        ["The response must mention these topics: platform, observability, testing"]
    ],
}

eval_df = pd.DataFrame(eval_data)

mlflow.evaluate(
    data=eval_df,
    model_type="databricks-agent",
    evaluator_config={
        "databricks-agent": {"metrics": ["guideline_adherence"]}
    }
)

MLflow 3.x :

Dans MLflow 3.x, vous organisez les données d’évaluation différemment. Chaque entrée de vos données d’évaluation doit avoir une expectations clé et, à l’intérieur, vous pouvez inclure des champs comme guidelines.

Voici à quoi ressemblent vos données d’évaluation :

eval_data = [
    {
        "inputs": {"input": "What is MLflow?"},
        "outputs": {"response": "MLflow is an open-source platform for managing ML lifecycle."},
        "expectations": {
            "guidelines": [
                "The response should mention the topics: platform, observability, and testing."
            ]
        }
    }
]

Ensuite, utilisez le ExpectationsGuidelines scoreur :

import mlflow
from mlflow.genai.scorers import ExpectationsGuidelines

expectations_guideline = ExpectationsGuidelines()

# Use predefined scorer
results = mlflow.genai.evaluate(
    data=eval_data,  # Make sure each row has expectations.guidelines
    predict_fn=my_app,
    scorers=[
        expectations_guideline
    ]
)

Réplication du comportement de juge automatique MLflow 2.x

Pour répliquer le comportement de MLflow 2.x consistant à exécuter tous les évaluateurs applicables, incluez explicitement tous les scoreurs.

MLflow 2.x (automatique) :

# Automatically runs all applicable judges based on data
results = mlflow.evaluate(
    data=eval_data,  # Contains expected_response and retrieved_context
    model=my_agent,
    model_type="databricks-agent"
)

MLflow 3.x (explicite) :

from mlflow.genai.scorers import (
    Correctness, RetrievalSufficiency,  # Require ground truth
    RelevanceToQuery, Safety, RetrievalGroundedness, RetrievalRelevance  # No ground truth
)

# Manually specify all judges you want to run
results = mlflow.genai.evaluate(
    data=eval_data,
    predict_fn=my_agent,
    scorers=[
        # With ground truth judges
        Correctness(),
        RetrievalSufficiency(),
        # Without ground truth judges
        RelevanceToQuery(),
        Safety(),
        RetrievalGroundedness(),
        RetrievalRelevance(),
    ]
)

Utilisation directe du juge

Vous pouvez toujours appeler des juges directement pour les tests :

from mlflow.genai import judges

# Test a judge directly (same in both versions)
result = judges.correctness(
    request="What is MLflow?",
    response="MLflow is an open-source platform for ML lifecycle.",
    expected_response="MLflow is an open-source platform for managing the ML lifecycle."
)
print(f"Judge result: {result.value}")
print(f"Rationale: {result.rationale}")

Migration des commentaires humains

Étiquetage des sessions et des schémas

La fonctionnalité de revue d'application a été déplacée de databricks.agents à mlflow.genai.labeling.

Modifications de l’espace de noms :

Exemple : création d’une session d’étiquetage

MLflow 2.x :

from databricks.agents import review_app
import mlflow

# Get review app

my_app = review_app.get_review_app()

# Create custom label schema
quality_schema = my_app.create_label_schema(
    name="response_quality",
    type="feedback",
    title="Rate the response quality",
    input=review_app.label_schemas.InputCategorical(
        options=["Poor", "Fair", "Good", "Excellent"]
    )
)

# Create labeling session
session = my_app.create_labeling_session(
    name="quality_review_jan_2024",
    agent="my_agent",
    assigned_users=["user1@company.com", "user2@company.com"],
    label_schemas=[
        review_app.label_schemas.EXPECTED_FACTS,
        "response_quality"
    ]
)

# Add traces for labeling
traces = mlflow.search_traces(run_id=run_id)
session.add_traces(traces)

MLflow 3.x :

import mlflow
import mlflow.genai.labeling as labeling
import mlflow.genai.label_schemas as schemas

# Create custom label schema
quality_schema = schemas.create_label_schema(
    name="response_quality",
    type=schemas.LabelSchemaType.FEEDBACK,
    title="Rate the response quality",
    input=schemas.InputCategorical(
        options=["Poor", "Fair", "Good", "Excellent"]
    ),
    overwrite=True
)

# Previously built in schemas must be created before use
# However, constant for their names are provided to ensure your schemas work with built-in scorers
expected_facts_schema = schemas.create_label_schema(
    name=schemas.EXPECTED_FACTS,
    type=schemas.LabelSchemaType.EXPECTATION,
    title="Expected facts",
    input=schemas.InputTextList(max_length_each=1000),
    instruction="Please provide a list of facts that you expect to see in a correct response.",
    overwrite=True
)

# Create labeling session
session = labeling.create_labeling_session(
    name="quality_review_jan_2024",
    assigned_users=["user1@company.com", "user2@company.com"],
    label_schemas=[
        schemas.EXPECTED_FACTS,
        "response_quality"
    ]
)

# Add traces for labeling
traces = mlflow.search_traces(
    run_id=session.mlflow_run_id
)
session.add_traces(traces)

# Get review app URL
app = labeling.get_review_app()
print(f"Review app URL: {app.url}")

Synchronisation des commentaires sur les jeux de données

MLflow 2.x :

# Sync expectations back to dataset
session.sync(to_dataset="catalog.schema.eval_dataset")

# Use dataset for evaluation
dataset = spark.read.table("catalog.schema.eval_dataset")
results = mlflow.evaluate(
    data=dataset,
    model=my_agent,
    model_type="databricks-agent"
)

MLflow 3.x :

from mlflow.genai import datasets
import mlflow

# Sample agent function
@mlflow.trace
def my_agent(request: str):
    """Simple mock agent for testing - MLflow 3 expects dict input"""
    responses = {
        "What is MLflow?": "MLflow is an open-source platform for managing ML lifecycle.",
        "What is Databricks?": "Databricks is a unified analytics platform.",
    }
    return {"response": responses.get(request, "I don't have information about that.")}


# Sync expectations back to dataset
session.sync(to_dataset="catalog.schema.eval_dataset")

# Use dataset for evaluation
dataset = datasets.get_dataset("catalog.schema.eval_dataset")
results = mlflow.genai.evaluate(
    data=dataset,
    predict_fn=my_agent
)

Ressources supplémentaires

• Guide d’évaluation de MLflow 3 GenAI
• Documentation sur les évaluateurs personnalisés
• Feedback humain avec des sessions d’étiquetage
• Évaluateurs prédéfinis pour juges
• Guide de suivi MLflow

Pour obtenir un support supplémentaire pendant la migration, consultez la documentation MLflow ou contactez votre équipe de support Databricks.