Migración a MLflow 3 desde Agent Evaluation

La evaluación del agente ahora está integrada con MLflow 3 en Databricks. Los métodos de evaluación del agente del SDK ahora se exponen a través del SDK mlflow[databricks]>=3.1, en el espacio de nombres mlflow.genai. MLflow 3 presenta:

• Interfaz de usuario actualizada que refleja toda la funcionalidad del SDK
• Nuevo SDKmlflow.genai con API simplificadas para ejecutar la evaluación, el etiquetado humano y la administración de conjuntos de datos de evaluación
• Seguimiento mejorado con un backend de ingesta de seguimiento a escala de producción que proporciona observabilidad en tiempo real.
• Recopilación de comentarios humanos simplificada
• Evaluadores LLM mejorados como jueces integrados

Esta guía le ayuda a migrar de La evaluación del agente (MLflow 2.x con databricks-agents<1.0) a MLflow 3. Esta guía detallada también está disponible en formato de referencia rápida .

Lista de comprobación para la migración

Empiece a usar esta lista de comprobación. Cada elemento vincula a los detalles de las secciones siguientes.

API de evaluación

• [ ] Actualizar las importaciones de databricks.agents a mlflow.genai.*
• [ ] Convertir @metric decoradores en @scorer
  • [ ] Actualizar firmas de función de métricas o puntuadores personalizados
• [ ] Reemplazar mlflow.evaluate() por mlflow.genai.evaluate()
  • [ ] Actualizar nombres de parámetro (model → predict_fn, extra_metrics → scorers)
  • [ ] Actualizar nombres de campo de datos (request → inputs, response → outputs, expected* → expectations)
  • [ ] Reemplazar evaluator_config por la configuración de nivel de puntuación
  • [ ] Actualizar el acceso a los resultados para su uso mlflow.search_traces()

Jueces de LLM

• [ ] Sustituya las llamadas directas al juez con los puntuadores predefinidos siempre que sea posible.
• [ ] Actualizar judges.guideline_adherence() para judges.meets_guidelines() o Guidelines() Actualizar puntuador
• [ ] Actualizar los nombres de parámetros de función de juez para que coincidan con la nueva API
• [ ] Considere la posibilidad de usar ExpectationsGuidelines() para obtener directrices basadas en datos reales

Comentarios humanos

• [ ] Actualizar la sesión de etiquetado y revisar las importaciones de aplicaciones a mlflow.genai.labeling
• [ ] Actualizar las importaciones de esquema de etiqueta a mlflow.genai.label_schemas
• [ ] Actualizar la lógica para sincronizar los comentarios con los conjuntos de datos

Problemas comunes que se deben evitar

• Recuerde actualizar los nombres de campo de datos en los dataFrames.
• Recuerde que model_type="databricks-agent" ya no es necesario
• Asegúrese de que los puntuadores personalizados devuelven valores válidos ("sí"/"no" para pass/fail)
• Usar search_traces() en lugar de acceder directamente a las tablas de resultados
• Actualice las referencias de espacio de nombres codificadas de forma rígida en su código
• Recuerde especificar explícitamente todos los puntuadores : MLflow 3 no ejecuta automáticamente los jueces.
• Convierte global_guidelines de la configuración a jueces Guidelines() explícitos

Migración de api de evaluación

Importar actualizaciones

En la lista siguiente se resumen las importaciones que se van a actualizar, con detalles y ejemplos en cada subsección siguiente.

# 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() a mlflow.genai.evaluate()

La API de evaluación principal se ha movido a un espacio de nombres de GenAI dedicado con nombres de parámetros más limpios.

Cambios clave en la API:

Asignación de campos de datos:

Ejemplo: Evaluación básica

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

Acceso a los resultados de la evaluación

En el MLflow 3, los resultados de la evaluación se almacenan como seguimientos junto con las evaluaciones. Use mlflow.search_traces() para acceder a los resultados detallados:

# 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}")

Evaluación de un modelo registrado de MLflow

En MLflow 2.x, puede pasar un modelo de MLflow registrado (por ejemplo, un modelo PyFunc o uno registrado por Agent Framework) directamente a mlflow.evaluate(). En MLflow 3.x, debe encapsular el modelo en una función predict para manejar la asignación de parámetros.

Este contenedor es necesario porque mlflow.genai.evaluate() espera una función predict que acepte las claves del diccionario inputs de su conjunto de datos como argumentos de palabra clave, mientras que la mayoría de los modelos registrados aceptan un único parámetro de entrada (por ejemplo, model_inputs para modelos PyFunc o interfaces similares para los modelos LangChain).

La función predict actúa como una capa de traducción entre los parámetros con nombre del marco de evaluación y el formato de entrada esperado del modelo.

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étricas personalizadas para la migración de los puntuadores

Las funciones de evaluación personalizadas (@metric) ahora usan el @scorer decorador con una firma simplificada.

Cambios clave:

Ejemplo: Puntuador aprobado/suspendido

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

Ejemplo: Puntuador numérico con evaluación

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}"
    )

Migración de jueces de LLM

Diferencias clave en el comportamiento del juez

Selección automática de juez:

Selección automática del juez de MLflow 2.x:

• Sin verdad fundamental: ejecuta chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• Con verdad fundamental: también se ejecutan context_sufficiency, correctness

Selección explícita del puntuador de MLflow 3.x:

• Debe enumerar explícitamente los puntuadores que desea ejecutar.
• Más control, pero requiere ser explícito sobre las necesidades de evaluación

Rutas de migración:

MLflow 3 proporciona dos maneras de usar jueces LLM:

1. Puntuadores predefinidos: listos para usar que envuelven jueces con análisis automático de seguimientos
2. Llamadas directas de juez : llame a jueces directamente dentro de los puntuadores personalizados para obtener más control

Controlar qué jueces se ejecutan

Ejemplo: Especificación de jueces que serán ejecutados

MLflow 2.x (limitando los jueces predeterminados):

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 (selección explícita del puntuador):

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

Ejemplo completo de migración

En este ejemplo se muestra la migración de una evaluación que usa varios jueces con configuración personalizada:

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

Migración a los puntuadores de juez predefinidos

MLflow 3 proporciona puntuadores predefinidos que encapsulan los jueces de LLM, lo que facilita su uso con mlflow.genai.evaluate().

Ejemplo: Juez de corrección

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 (Opción 1: Uso del puntuador predefinido):

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 (Opción 2: marcador personalizado con juez):

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

Ejemplo: Juez de seguridad

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

Ejemplo: Juez de relevancia

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

Ejemplo: juez de solidez

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

Migración del cumplimiento de las directrices a meets_guidelines

Se ha cambiado el nombre del guideline_adherence juez a meets_guidelines con una API más limpia.

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 (Opción 1: Uso del puntuador de directrices predefinido):

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 (opción 2: marcador personalizado con 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
        }
    )

Ejemplo: Migración de expectativasGuidelines

Cuando quiera establecer directrices para cada ejemplo del conjunto de evaluación, como requerir que se tratan determinados temas, o que la respuesta siga un estilo específico, use el ExpectationsGuidelines puntuador en MLflow 3.x.

MLflow 2.x:

En MLflow 2.x, implementaría directrices de la siguiente manera:

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:

En MLflow 3.x, los datos de evaluación se organizan de forma diferente. Cada entrada de los datos de evaluación debe tener una expectations clave y, dentro de eso, puede incluir campos como guidelines.

Este es el aspecto que podrían tener los datos de evaluación:

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."
            ]
        }
    }
]

A continuación, use el puntuador ExpectationsGuidelines:

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

Replicación del comportamiento del juez automático de MLflow 2.x

Para replicar el comportamiento de MLflow 2.x al ejecutar todos los evaluadores aplicables, incluya explícitamente todos los puntuadores:

MLflow 2.x (automático):

# 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 (explícito):

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

Uso directo por parte del juez

Todavía puede llamar a jueces directamente para realizar pruebas:

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}")

Migración de comentarios humanos

Etiquetado de sesiones y esquemas

La funcionalidad de la aplicación de revisión se ha movido de databricks.agents a mlflow.genai.labeling.

Cambios en los espacios de nombres:

Ejemplo: Creación de una sesión de etiquetado

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}")

Sincronización de comentarios con conjuntos de datos

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
)

Recursos adicionales

• Guía de evaluación de MLflow 3 GenAI
• Documentación de puntuadores personalizados
• Retroalimentación humana mediante sesiones de etiquetado
• Jueces Puntuadores Predefinidos
• Guía de seguimiento de MLflow

Para obtener soporte técnico adicional durante la migración, consulte la documentación de MLflow o póngase en contacto con el equipo de soporte técnico de Databricks.