Migrar para o MLflow 3 a partir da Avaliação do agente

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

Interface de usuário atualizada que reflete todas as funcionalidades do SDK
Novo SDK mlflow.genai com APIs simplificado para executar avaliação, rótulo humano e gerenciar conjunto de dados de avaliação
Rastreamento aprimorado com um backend de ingestão de rastreamento em escala de produção que oferece observabilidade em tempo real
Coleta simplificada de feedback humano
Melhoria do site LLM juízes como avaliadores integrados

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

important

MLflow 3 com Agent Evaluation só funciona em gerenciar MLflow, não em código aberto MLflow. Veja a página gerenciar vs. código aberto MLflow para entender mais detalhadamente as diferenças entre gerenciar e código aberto MLflow.

Lista de verificação de migração

Para começar, use esta lista de verificação. Cada item tem links para detalhes nas seções abaixo.

Armadilhas comuns a serem evitadas

Lembre-se de atualizar os nomes dos campos de dados em seus DataFrames
Lembre-se de que model_type="databricks-agent" não é mais necessário
Garanta que pontuadores personalizados retornem valores válidos (" yes "/" no " para aprovação/reprovação)
Use search_traces() em vez de acessar as tabelas de resultados diretamente
Atualize todas as referências de namespace codificadas em seu código
Lembre-se de especificar explicitamente todos os avaliadores - MLflow 3 não executa automaticamente os juízes
Converta global_guidelines da configuração em marcadores Guidelines() explícitos

Avaliação da migração da API

Importar atualizações

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

Python
# 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, ExpectationGuidelines,
    RelevanceToQuery, Safety, RetrievalGroundedness,
    RetrievalRelevance, RetrievalSufficiency
)

De `mlflow.evaluate()` a `mlflow.genai.evaluate()`

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

chave API mudanças:

MLflow 2.x	MLflow 3.x	Notas
`mlflow.evaluate()`	`mlflow.genai.evaluate()`	Novo namespace
`model` Parâmetro	`predict_fn` Parâmetro	Nome mais descritivo
`model_type="databricks-agent"`	Não é necessário	Detectado automaticamente
`extra_metrics=[...]`	`scorers=[...]`	Terminologia mais clara
`evaluator_config={...}`	Não é necessário	Parte dos marcadores

Mapeamento do campo de dados:

Campo do MLflow 2.x	Campo do MLflow 3.x	Descrição
`request`	`inputs`	Entrada do agente
`response`	`outputs`	Saída do agente
`expected_response`	`expectations`	Verdade fundamental
`retrieved_context`	Acessado por meio de rastreamentos	Contexto a partir do rastreamento
`guidelines`	Parte da configuração do marcador	Transferido para o nível de marcador

Exemplo: Avaliação básica

MLflow 2.x:

Python
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:

Python
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 traços com avaliações. Use mlflow.search_traces() para acessar resultados detalhados:

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

Avaliação de um LoggedModel do MLflow

Em MLflow 2.x, o senhor poderia passar um modelo de registro MLflow (como um modelo PyFunc ou um registro da Estrutura de Agente) diretamente para mlflow.evaluate(). No MLflow 3.x, o senhor precisa envolver o modelo em uma função de previsão para lidar com o mapeamento de parâmetros.

Esse wrapper é necessário porque o mlflow.genai.evaluate() espera uma função de previsão que aceite a chave no inputs dict do seu dataset como argumentos de palavra-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.

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

Migração de métricas personalizadas para marcadores

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

mudanças importantes:

MLflow 2.x	MLflow 3.x	Notas
`@metric` decorador	`@scorer` decorador	Novo nome
`def my_metric(request, response, ...)`	`def my_scorer(inputs, outputs, expectations, traces)`	Simplificado
Vários parâmetros esperados_*	Parâmetro `expectations` único que é um ditado	Consolidado
`custom_expected`	Parte do ditado `expectations`	Simplificado
`request` Parâmetro	`inputs` Parâmetro	Nomenclatura consistente
`response` Parâmetro	`outputs` Parâmetro	Nomenclatura consistente

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

MLflow 2.x:

Python
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:

Python
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: pontuador numérico com avaliação

MLflow 2.x:

Python
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:

Python
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 juízes do LLM

principais diferenças no comportamento dos juízes

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

MLflow 2.x	MLflow 3.x
Executar automaticamente todos os juízes aplicáveis com base nos dados	Deve especificar explicitamente quais marcadores usar
Use `evaluator_config` para limitar os juízes	Passe os marcadores desejados no parâmetro `scorers`
`global_guidelines` na configuração	Use o marcador `Guidelines()`
Juízes selecionados com base nos campos de dados disponíveis	O senhor controla exatamente a execução dos marcadores

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

Sem verdade fundamental: execução chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
Com a verdade fundamental: também execução context_sufficiency, correctness

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

O senhor deve listar explicitamente os marcadores que deseja executar
Mais controle, mas exige ser explícito sobre as necessidades de avaliação

Caminhos de migração

Caso de uso	MLflow 2.x	MLflow 3.x Recomendado
Verificação básica de exatidão	`judges.correctness()` em `@metric`	`Correctness()` goleador ou juiz do `judges.is_correct()`
Avaliação de segurança	`judges.safety()` em `@metric`	`Safety()` goleador ou juiz do `judges.is_safe()`
Diretrizes globais	`judges.guideline_adherence()`	`Guidelines()` goleador ou juiz do `judges.meets_guidelines()`
Diretrizes por eval-set-row	`judges.guideline_adherence()` com esperado_*	`ExpectationGuidelines()` goleador ou juiz do `judges.meets_guidelines()`
Verifique se há suporte factual	`judges.groundedness()`	`judges.is_grounded()` ou artilheiro `RetrievalGroundedness()`
Verifique a relevância do contexto	`judges.relevance_to_query()`	`judges.is_context_relevant()` ou artilheiro `RelevanceToQuery()`
Verifique a relevância dos trechos de contexto	`judges.chunk_relevance()`	`judges.is_context_relevant()` ou artilheiro `RetrievalRelevance()`
Verifique a integridade do contexto	`judges.context_sufficiency()`	`judges.is_context_sufficient()` ou artilheiro `RetrievalSufficiency()`
Lógica personalizada complexa	O juiz liga diretamente `@metric`	Marcadores predefinidos ou `@scorer` com chamadas de juízes

O MLflow 3 oferece duas maneiras de usar os juízes do LLM:

Pontuadores predefinidos - Pontuadores prontos para usar que agrupam os juízes com análise automática de traços
Chamadas diretas de juízes - Ligue para os juízes diretamente nos marcadores personalizados para obter mais controle

Controle de quais juízes executam

Exemplo: Especificando juízes para execução

MLflow 2.x (limitando os juízes do default ):

Python
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 avaliador):

Python
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:

Python
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:

Python
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 juízes marcadores predefinidos

O MLflow 3 oferece avaliadores predefinidos que envolvem os juízes do LLM, facilitando seu uso com o site mlflow.genai.evaluate().

Exemplo: Juiz de exatidão

MLflow 2.x:

Python
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: usar o avaliador predefinido):

Python
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 juiz):

Python
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:

Python
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:

Python
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:

Python
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:

Python
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 fundamento

MLflow 2.x:

Python
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:

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

Adesão às diretrizes de migração para meets_guidelines

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

MLflow 2.x:

Python
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: usar o avaliador de diretrizes predefinido):

Python
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: avaliador personalizado com meets_guidelines):

Python
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: Diretrizes de expectativa de migração

Para diretrizes contidas em um conjunto de avaliação, use ExpectationGuidelines:

MLflow 2.x:

Python
from databricks.agents.evals import judges, metric

# Define `guidelines` as a key in your evaluation set

@metric
def check_completeness(request, response, expected_facts):
    """Check if response includes all expected facts."""
    facts_text = '\n'.join(expected_facts)

    return judges.guideline_adherence(
        request=request,
        guidelines=[f"Response must include all of these facts: {facts_text}"],
        guidelines_context={"response": response}
    )

MLflow 3.x:

Python
from mlflow.genai.scorers import ExpectationGuidelines

# Define `guidelines` as a key `expectations` in your evaluation set

# Use predefined scorer
results = mlflow.genai.evaluate(
    data=eval_data,  # eval_data must include expectations.expected_facts
    predict_fn=my_agent,
    scorers=[
        ExpectationGuidelines()
    ]
)

Replicação do comportamento do juiz automático do MLflow 2.x

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

MLflow 2.x (automático):

Python
# 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):

Python
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 ligar diretamente para os juízes para fazer o teste:

Python
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 feedback humano

rótulo sessions and schemas

A funcionalidade do Review App mudou de databricks.agents para mlflow.genai.labeling.

Mudanças no namespace:

MLflow 2.x	MLflow 3.x
`databricks.agents.review_app`	`mlflow.genai.labeling`
`databricks.agents.datasets`	`mlflow.genai.datasets`
`review_app.label_schemas.*`	`mlflow.genai.label_schemas.*`
`app.create_labeling_session()`	`labeling.create_labeling_session()`

Exemplo: Criando uma sessão de rótulo

MLflow 2.x:

Python
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:

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

Sincronização do feedback com o conjunto de dados

MLflow 2.x:

Python
# 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:

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

Recurso adicional

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

Lista de verificação de migração​

API de avaliação​

Juízes do LLM​

Feedback humano​

Armadilhas comuns a serem evitadas​

Avaliação da migração da API​

Importar atualizações​

De mlflow.evaluate() a mlflow.genai.evaluate()​

Exemplo: Avaliação básica​

Acessando os resultados da avaliação​

Avaliação de um LoggedModel do MLflow​

Migração de métricas personalizadas para marcadores​

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

Exemplo: pontuador numérico com avaliação​

Migração de juízes do LLM​

principais diferenças no comportamento dos juízes​

Caminhos de migração​

Controle de quais juízes executam​

Exemplo: Especificando juízes para execução​

Exemplo abrangente de migração​

Migração para juízes marcadores predefinidos​

Exemplo: Juiz de exatidão​

Exemplo: juiz de segurança​

Exemplo: juiz de relevância​

Exemplo: Juiz de fundamento​

Adesão às diretrizes de migração para meets_guidelines​

Exemplo: Diretrizes de expectativa de migração​

Replicação do comportamento do juiz automático do MLflow 2.x​

Uso direto do juiz​

Migração de feedback humano​

rótulo sessions and schemas​

Exemplo: Criando uma sessão de rótulo​

Sincronização do feedback com o conjunto de dados​

Recurso adicional​

Lista de verificação de migração

API de avaliação

Juízes do LLM

Feedback humano

Armadilhas comuns a serem evitadas

Avaliação da migração da API

Importar atualizações

De `mlflow.evaluate()` a `mlflow.genai.evaluate()`

Exemplo: Avaliação básica

Acessando os resultados da avaliação

Avaliação de um LoggedModel do MLflow

Migração de métricas personalizadas para marcadores

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

Exemplo: pontuador numérico com avaliação

Migração de juízes do LLM

principais diferenças no comportamento dos juízes

Caminhos de migração

Controle de quais juízes executam

Exemplo: Especificando juízes para execução

Exemplo abrangente de migração

Migração para juízes marcadores predefinidos

Exemplo: Juiz de exatidão

Exemplo: juiz de segurança

Exemplo: juiz de relevância

Exemplo: Juiz de fundamento

Adesão às diretrizes de migração para meets_guidelines

Exemplo: Diretrizes de expectativa de migração

Replicação do comportamento do juiz automático do MLflow 2.x

Uso direto do juiz

Migração de feedback humano

rótulo sessions and schemas

Exemplo: Criando uma sessão de rótulo

Sincronização do feedback com o conjunto de dados

Recurso adicional