Переход на MLflow 3 из оценки агента

Оценка агента теперь интегрирована с MLflow 3 в Databricks. Теперь методы SDK для оценки агента доступны через mlflow[databricks]>=3.1 SDK, в пространстве имен mlflow.genai. В MLflow 3 представлено:

• Обновленный пользовательский интерфейс , который отражает все функциональные возможности пакета SDK
• Новый пакет SDKmlflow.genai с упрощенными API для выполнения оценки, метки человека и управления наборами данных оценки
• Улучшенный анализ трассировки с серверной частью для приема трассировки производственного масштаба, обеспечивающей наблюдаемость в режиме реального времени
• Упрощенная коллекция отзывов о людях
• Улучшены судьи LLM в качестве встроенных показателей

Это руководство поможет вам перейти от оценки агента (MLflow 2.x с помощью databricks-agents<1.0) на MLflow 3. Это подробное руководство также доступно в формате быстрого справочника .

Контрольный список действий по миграции

Начните с этого контрольного списка. Каждый элемент ссылается на подробные сведения в разделах ниже.

API оценки

• [ ] Обновление импорта из databricks.agents в mlflow.genai.*
• [ ] Преобразование @metric декораторов в @scorer
  • [ ] Обновление пользовательских подписей функции метрик и показателей
• [ ] Замена mlflow.evaluate() на mlflow.genai.evaluate()
  • [ ] Обновление имен параметров (model → predict_fn, extra_metrics → scorers)
  • [ ] Обновление имен полей данных (request→inputs, response →, outputs → expected*expectations)
  • [ ] Замена evaluator_config конфигурацией оценочного уровня
  • [ ] Обновите способ доступа к результатам, используя mlflow.search_traces()

Судьи (LLM)

• [ ] Замените прямые вызовы судьи предопределенными бомбардирами, где это возможно
• [ ] Обновить judges.guideline_adherence() до judges.meets_guidelines() или Guidelines() оценщика
• [ ] Обновление имен параметров функции судьи для соответствия новому API
• [ ] Рекомендуется использовать ExpectationsGuidelines() для достоверных рекомендаций

Отзывы о людях

• [ ] Обновление сеанса маркировки и проверка импорта приложений в mlflow.genai.labeling
• [ ] Обновление импорта схемы меток до mlflow.genai.label_schemas
• [ ] Обновление логики синхронизации отзывов с наборами данных

Распространенные ловушки, которых следует избегать

• Не забудьте обновить имена полей данных в DataFrame.
• Помните, что model_type="databricks-agent" больше не требуется
• Убедитесь, что пользовательские оценки возвращают допустимые значения ("да"/"нет" для pass/fail)
• Используйте search_traces() вместо прямого доступа к таблицам результатов
• Обновите все ссылки на жестко закодированное пространство имен в вашем коде.
• Не забудьте явно указать всех оценщиков — MLflow 3 не запускает оценщиков автоматически
• Преобразование global_guidelines из конфигурации в явные Guidelines() оценки

Миграция API для оценки

Импорт обновлений

В приведенном ниже списке перечислены импорты для обновления с подробными сведениями и примерами в каждом подразделе ниже.

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

От mlflow.evaluate() до mlflow.genai.evaluate()

Основной API оценки перемещен в выделенное пространство имен GenAI с более чистыми именами параметров.

Основные изменения API:

Сопоставление полей данных:

Пример. Базовая оценка

MLflow 2.x:

import mlflow
import pandas as pd

eval_data = [
        {
            "request":  "What is MLflow?",
            "response": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
            "expected_response": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
        },
        {
            "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 the largest open source AI engineering platform for agents, LLMs, and ML models."
            },
            "expectations": {
                "expected_response":
                    "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",

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

Доступ к результатам оценки

В MLflow 3 результаты оценивания сохраняются в виде трассировок с оценками. Используйте mlflow.search_traces() для доступа к подробным результатам:

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

Оценка модели LoggedModel в MLflow

В MLflow 2.x можно было передать сохранённую модель MLflow (например, модель PyFunc или модель, сохранённую с помощью Custom Agents) напрямую в mlflow.evaluate(). В MLflow 3.x необходимо упаковать модель в прогнозную функцию для обработки сопоставления параметров.

Эта оболочка необходима, потому что mlflow.genai.evaluate() ожидает функцию прогнозирования, которая принимает ключи словаря inputs из вашего набора данных в качестве аргументов ключевых слов, в то время как большинство зарегистрированных моделей принимают один входной параметр (например, model_inputs для моделей PyFunc или аналогичных интерфейсов для моделей LangChain).

Функция прогнозирования служит уровнем перевода между именованными параметрами платформы оценки и ожидаемым форматом входных данных модели.

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

Миграция пользовательских метрик для показателей

Теперь пользовательские функции оценки (@metric) используют декоратор @scorer с упрощенной сигнатурой.

Ключевые изменения:

Пример: система оценок зачет/незачет

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 the largest open source AI engineering platform for agents, LLMs, and ML models.",
        "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]
)

Пример: числовой оценщик и оценка

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

Основные различия в поведении судьи

Автоматический выбор судьи:

Выбор автоматического судьи MLflow 2.x:

• Без достоверных данных: запуски chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• С эталонными данными: также работает context_sufficiency, correctness

Явный выбор оценщика MLflow 3.x:

• Вы должны явно указать подсчитывающие системы, которые хотите запустить.
• Больше элементов управления, но требует явного выражения потребностей оценки

Пути миграции

MLflow 3 предоставляет два способа использования судей LLM:

1. Предопределенные оценщики — готовые к использованию оценщики, объединяющие судей с автоматизированным анализом трассировки
2. Прямые вызовы функций оценки — вызов судей непосредственно в пользовательских системах оценки для большего контроля

Управление выбором участвующих судей

Пример: Назначение судей для проведения

MLflow 2.x (ограничение судей по умолчанию):

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 (явный выбор показателей):

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

Полный пример миграции

В этом примере показана миграция оценки, которая использует несколько судей с пользовательской конфигурацией:

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

Переход к предопределенным оценщикам судей

MLflow 3 предоставляет предопределенные оценки, которые упаковывают судей LLM, что упрощает их использование.mlflow.genai.evaluate()

Пример: эксперт по правильности

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 (вариант 1: использование предопределённого показателя):

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 (вариант 2: Пользовательский бомбардир с судьей):

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

Пример: судья по безопасности

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

Пример: оценщик релевантности

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

Пример: судья по уравновешенности

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

Перенос соблюдения руководящих принципов в meets_guidelines

Судья guideline_adherence был переименован в meets_guidelines, с более чистым API.

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 (вариант 1. Использование предварительно определенных показателей рекомендаций):

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 (Вариант 2: настраиваемый оценщик с 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
        }
    )

Пример: перенос ожиданийGuidelines

Если вы хотите задать рекомендации для каждого примера в наборе оценки, такие как требование о том, чтобы определенные темы были рассмотрены, или чтобы ответ соответствовал определённому стилю, используйте ExpectationsGuidelines оценщик в MLflow 3.x.

MLflow 2.x:

В MLflow 2.x вы реализуете следующие рекомендации:

import pandas as pd

eval_data = {
    "request": "What is MLflow?",
    "response": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
    "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:

В MLflow 3.x данные оценки упорядочиваются по-разному. Каждая запись в данных оценки должна иметь expectations — это ключ, и внутри его можно включить такие поля, как guidelines.

Вот как выглядят данные оценки:

eval_data = [
    {
        "inputs": {"input": "What is MLflow?"},
        "outputs": {"response": "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models."},
        "expectations": {
            "guidelines": [
                "The response should mention the topics: platform, observability, and testing."
            ]
        }
    }
]

Затем используйте оценщик 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
    ]
)

Репликация поведения автоматического судьи MLflow 2.x

Чтобы реплицировать режим работы MLflow 2.x для выполнения всех применимых оценщиков, явно включите всех оценщиков.

MLflow 2.x (автоматически):

# 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 (явный):

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

Прямое использование судьи

Вы по-прежнему можете вызывать судей непосредственно для тестирования:

from mlflow.genai import judges

# Test a judge directly (same in both versions)
result = judges.correctness(
    request="What is MLflow?",
    response="MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models.",
    expected_response="MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models."
)
print(f"Judge result: {result.value}")
print(f"Rationale: {result.rationale}")

Миграция отзывов пользователей

Создание меток для сеансов и схем

Функциональность приложения "Отзывов" перемещена из databricks.agents в mlflow.genai.labeling.

Изменения пространства имен:

Пример. Создание сеанса маркировки

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

Синхронизация отзывов с наборами данных

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 the largest open source AI engineering platform for agents, LLMs, and ML models.",
        "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
)

Дополнительные ресурсы

• Руководство по оценке MLflow GenAI 3
• Документация по пользовательским оценкам
• Отзывы пользователей с сеансами маркировки
• Предопределённые оценщики-судьи
• Руководство по трассировке MLflow

Дополнительные сведения о поддержке во время миграции см. в документации по MLflow или обратитесь к группе поддержки Databricks.