Migrar para o MLflow 3 a partir de Avaliação de Agente

A Avaliação de Agentes 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 mlflow[databricks]>=3.1 SDK, sob o mlflow.genai namespace. O MLflow 3 introduz:

• Interface do usuário atualizada que espelha todas as funcionalidades do SDK
• Novo SDKmlflow.genai com APIs simplificadas para executar avaliação, rotulagem humana e gerenciar conjuntos de dados de avaliação
• Rastreamento aprimorado com um back-end de ingestão de rastros em escala de produção que fornece observabilidade em tempo real
• Recolha simplificada de feedback humano
• Juízes LLM melhorados como pontuadores 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 formato de referência rápida .

Lista de verificação de migração

Comece usando esta lista de verificação. Cada item contém links para detalhes nas seções abaixo.

API de avaliação

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

Juízes de LLM

• [ ] Substitua as chamadas diretas de juízes por avaliadores predefinidos sempre que possível
• [ ] Atualizar judges.guideline_adherence() para judges.meets_guidelines() ou Guidelines() marcador
• [ ] Atualize os nomes dos parâmetros da função do juiz para corresponder à nova API
• [ ] Considere o uso ExpectationsGuidelines() de diretrizes baseadas na verdade fundamentada

Retorno humano

• [ ] Atualizar a sessão de rotulagem e rever importações de aplicações para mlflow.genai.labeling
• [ ] Atualizar as importações do esquema de rótulo para mlflow.genai.label_schemas
• [ ] Lógica de atualização para sincronizar comentários com conjuntos de dados

Armadilhas comuns a evitar

• Lembre-se de atualizar os nomes dos campos de dados em seus DataFrames
• Lembre-se que model_type="databricks-agent" isso não é mais necessário
• Garantir que os pontuadores personalizados retornem valores válidos ("sim"/"não" para passar/falhar)
• Use search_traces() em vez de acessar tabelas de resultados diretamente
• Atualize quaisquer referências de namespace codificadas em seu código
• Lembre-se de especificar explicitamente todos os avaliadores - o MLflow 3 não processa automaticamente os juízes
• Converter global_guidelines de configuração para pontuadores explícitos Guidelines()

Migração da API de avaliação

Importar atualizações

A lista abaixo 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 GenAI dedicado com nomes de parâmetros mais limpos.

Principais alterações da 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,
)

Acesso aos resultados da avaliação

No MLflow 3, os resultados da avaliação são armazenados como registos com análises. 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 registado no MLflow

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

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

A função predict 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: Sistema 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}"
    )

LLM avalia a migração

Principais diferenças no comportamento dos juízes

Seleção automática de juízes:

MLflow 2.x seleção automática de juízes:

• Sem verdade de base: corre chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• Com verdade fundamental: também corre context_sufficiency, correctness

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

• Tem que listar de forma explícita os indicadores que pretende executar
• Mais controlo, 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. Pontuadores predefinidos - Pontuadores prontos a usar que envolvem os juízes com análise automática de rastreio
2. Chamadas diretas de juízes - Ligue para juízes diretamente dentro de pontuadores personalizados para ter mais controle

Controlar quais juízes participam

Exemplo: Especificando juízes a serem executados

MLflow 2.x (limitando os 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 explícita do marcador):

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 abrangente de migração

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

Migração para marcadores de juízes predefinidos

O MLflow 3 fornece pontuadores predefinidos que envolvem os juízes de LLM, facilitando o seu uso com mlflow.genai.evaluate().

Exemplo: Juiz de exatidã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 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 critérios de avaliação):

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: Juiz 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 o cumprimento 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 marcador de diretrizes 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 (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 expectativasDiretrizes

Quando você quiser definir diretrizes para cada exemplo em seu conjunto de avaliação, como exigir que certos 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 os dados de avaliação de forma diferente. Cada entrada em seus dados de avaliação deve ter uma expectations chave e, dentro dela, você pode incluir campos como guidelines.

Veja como podem ser os dados da sua avaliação:

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 ExpectationsGuidelines avaliador:

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 MLflow 2.x

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

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 direto do juiz

Você ainda pode chamar os juízes diretamente para o 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}")

Transferência de feedback humano

Rotulando sessões e esquemas

A funcionalidade de Rever Aplicaçã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 Pontuadores Personalizados
• Feedback humano com sessões de etiquetagem
• Juízes Pontuadores Predefinidos
• Guia de rastreamento 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.