Migrar para o MLflow 3 da Avaliação do Agente

A Avaliação do Agente agora está integrada ao MLflow 3 no Databricks. Os métodos do SDK de Avaliação do Agente agora são expostos por meio do SDK mlflow[databricks]>=3.1, no namespace mlflow.genai. O MLflow 3 apresenta:

• Interface do usuário atualizada que espelha todas as funcionalidades do SDK
• Novo SDKmlflow.genai com APIs simplificadas para execução de avaliação, rotulagem humana e gerenciamento de conjuntos de dados de avaliação
• Rastreamento aprimorado com um back-end de ingestão de rastreamento em escala de produção que fornece observabilidade em tempo real
• Coleção simplificada de comentários humanos
• Avaliadores de LLM aprimorados como marcadores integrados

Este guia ajuda você a migrar da Avaliação do Agente (MLflow 2.x com databricks-agents<1.0) para o MLflow 3. Este guia detalhado também está disponível em um formato de referência rápida .

Lista de verificação de migração

Comece usando essa lista de verificação. Cada item é vinculado a detalhes nas seções abaixo.

API de avaliação

• [ ] Atualizar importações de databricks.agents para mlflow.genai.*
• [ ] Converter decoradores @metric em @scorer
  • [ ] Atualizar assinaturas de métrica personalizada/função de pontuação
• [ ] Substituir mlflow.evaluate() por mlflow.genai.evaluate()
  • [ ] Atualizar nomes de parâmetro (model → predict_fn, extra_metrics → scorers)
  • [ ] Atualizar nomes de campo de dados (request → inputs, response → outputs, expected* → expectations)
  • [ ] Substituir evaluator_config pela configuração no nível do marcador
  • [ ] Atualizar o acesso ao resultado para usar mlflow.search_traces()

Juízes LLM

• [ ] Substituir consultas diretas ao juiz por pontuadores predefinidos quando possível
• [ ] Atualizar judges.guideline_adherence() para o marcador judges.meets_guidelines() ou Guidelines()
• [ ] Atualizar nomes de parâmetro de função do juiz para corresponder à nova API
• [ ] Considere usar ExpectationsGuidelines() para diretrizes baseadas em dados reais

Comentários humanos

• [ ] Atualizar a sessão de etiquetagem e revisar as importações do aplicativo para mlflow.genai.labeling
• [ ] Atualizar importações de esquema de rótulo para mlflow.genai.label_schemas
• [ ] Atualizar lógica para sincronizar comentários com conjuntos de dados

Armadilhas comuns a serem evitadas

• Lembre-se de atualizar nomes de campo de dados em seus DataFrames
• Lembre-se de que model_type="databricks-agent" não é mais necessário.
• Verifique se os marcadores personalizados retornam valores válidos ("sim"/"não" para aprovação/reprovação)
• Usar search_traces() em vez de acessar tabelas de resultados diretamente
• Atualizar todas as referências de namespace codificadas em seu código
• Lembre-se de especificar explicitamente todos os pontuadores – o MLflow 3 não executa automaticamente os juízes
• Converter global_guidelines de configuração em marcadores explícitos Guidelines()

Migração da API de avaliação

Importar atualizações

A lista a seguir resume as importações a serem atualizadas, com detalhes e exemplos em cada subseção abaixo.

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

A API de avaliação principal foi movida para um namespace de GenAI dedicado com nomes de parâmetros mais limpos.

Principais alterações de API:

Mapeamento de campo de dados:

Exemplo: avaliação 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,
)

Acessando os resultados da avaliação

No MLflow 3, os resultados da avaliação são armazenados como rastreamentos com avaliações. Use mlflow.search_traces() para acessar resultados detalhados:

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

Avaliando um Modelo Registrado no MLflow

No MLflow 2.x, você pode passar um modelo de MLflow registrado (como um modelo PyFunc ou um registrado pelo Agent Framework) diretamente para mlflow.evaluate(). No MLflow 3.x, você precisa encapsular o modelo em uma função de previsão para lidar com o mapeamento de parâmetros.

Esse wrapper é necessário porque mlflow.genai.evaluate() espera uma função de previsão que aceita as chaves no dicionário inputs do conjunto de dados como argumentos com chave, enquanto a maioria dos modelos registrados aceita um único parâmetro de entrada (por exemplo, model_inputs para modelos PyFunc ou interfaces semelhantes para modelos LangChain).

A função de previsão serve como uma camada de tradução entre os parâmetros nomeados da estrutura de avaliação e o formato de entrada esperado do 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 migração de pontuadores

As funções de avaliação personalizadas (@metric) agora usam o @scorer decorador com uma assinatura simplificada.

Principais alterações:

Exemplo: marcador de aprovação/reprovação

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

Exemplo: marcador numérico com avaliação

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

Migração de avaliadores de LLM

Principais diferenças no comportamento do juiz

Seleção automática do juiz:

Seleção automática de juiz do MLflow 2.x:

• Sem a verdade objetiva: executa chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• Com a verdade objetiva: também executa context_sufficiency, correctness

Seleção de avaliador explícito do MLflow 3.x:

• Você deve listar explicitamente os marcadores que deseja executar
• Mais controle, mas requer ser explícito sobre as necessidades de avaliação

Caminhos de migração

O MLflow 3 fornece duas maneiras de usar juízes LLM:

1. Marcadores predefinidos - Marcadores prontos para uso que encapsulam avaliadores com análise automática de rastreamento
2. Chamadas de juiz direto - Chamar juízes diretamente dentro de pontuadores personalizados para obter mais controle

Controlando quais avaliadores executar

Exemplo: especificando avaliadores para executar

MLflow 2.x (limitando juízes padrão):

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 (seleção de marcador explícito):

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

Exemplo de migração abrangente

Este exemplo mostra a migração de uma avaliação que usa vários juízes com configuração 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
    ]
)

Migrando para marcadores predefinidos

O MLflow 3 fornece marcadores predefinidos que encapsulam os avaliadores de LLM, tornando-os mais fáceis de usar com mlflow.genai.evaluate().

Exemplo: avaliador de correção

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 (Opção 1: Usando o marcador 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 (Opção 2: Avaliador personalizado com classificador):

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

Exemplo: Juiz de segurança

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

Exemplo: Juiz de relevância

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

Exemplo: avaliador de fundamentação

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

Migrando a adesão de diretrizes para meets_guidelines

O guideline_adherence juiz foi renomeado para meets_guidelines, com uma API mais limpa.

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 (opção 1: usando o avaliador de diretrizes predefinidas):

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 (Opção 2: marcador personalizado com 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
        }
    )

Exemplo: Migrando ExpectationsGuidelines

Quando você quiser definir diretrizes para cada exemplo em seu conjunto de avaliação, como exigir que determinados tópicos sejam abordados ou que a resposta siga um estilo específico, use o ExpectationsGuidelines marcador no MLflow 3.x.

MLflow 2.x:

No MLflow 2.x, você implementaria as diretrizes da seguinte maneira:

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:

No MLflow 3.x, você organiza dados de avaliação de forma diferente. Cada entrada em seus dados de avaliação deve ter uma expectations chave e, dentro disso, você pode incluir campos como guidelines.

Eis como seus dados de avaliação podem se parecer:

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

Em seguida, use o marcador 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
    ]
)

Replicando o comportamento do juiz automático do MLflow 2.x

Para replicar o comportamento do MLflow 2.x de executar todos os avaliadores aplicáveis, inclua explicitamente todos os classificadores:

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 de avaliador direto

Você ainda pode chamar juízes diretamente para teste:

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

Migração de comentários humanos

Rotulando sessões e esquemas

A funcionalidade do aplicativo de revisão foi movida de databricks.agents para mlflow.genai.labeling.

Alterações de namespace:

Exemplo: criando uma sessão de rotulagem

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

Sincronizando comentários com conjuntos de dados

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 adicionais

• Guia de avaliação do MLflow 3 GenAI
• Documentação de Marcadores Personalizados
• Feedback humano com sessões de rotulagem
• Marcadores predefinidos do avaliador
• Guia de Rastreamento do MLflow

Para obter suporte adicional durante a migração, consulte a documentação do MLflow ou entre em contato com sua equipe de suporte do Databricks.