Migrieren Sie zu MLflow 3 von der Agentenauswertung

Agent Evaluation ist jetzt in MLflow 3 auf Databricks integriert. Die Agent Evaluation SDK-Methoden werden nun über das mlflow[databricks]>=3.1 SDK unter dem mlflow.genai Namespace verfügbar gemacht. MLflow 3 führt Folgendes ein:

• Aktualisierte Benutzeroberfläche , die alle SDK-Funktionen widerspiegelt
• Neues SDKmlflow.genai mit vereinfachten APIs für die Durchführung von Bewertungen, manuelle Kennzeichnung und Verwaltung von Bewertungsdatensätzen
• Erweiterte Ablaufverfolgung mit einem Produktion-Skala Back-End zur Erfassung von Abläufen, das Echtzeit-Beobachtbarkeit bietet
• Optimierte Erfassung von menschlichem Feedback
• Verbesserte LLM bewertet als integrierte Wertungsrichter

Dieses Handbuch hilft Ihnen bei der Migration von Agent Evaluation (MLflow 2.x mit databricks-agents<1.0) zu MLflow 3. Diese ausführliche Anleitung steht auch in einem Kurzübersichtsformat zur Verfügung.

Migrationscheckliste

Beginnen Sie mit dieser Checkliste. Jedes Element verweist auf Details in den folgenden Abschnitten.

Auswertungs-API

• [ ] Aktualisierung der Importe von databricks.agents zu mlflow.genai.*
• [ ] Konvertieren Sie @metric Decorator-Elemente in @scorer
  • [ ] Aktualisieren benutzerdefinierter Metrik-/Scorerfunktionssignaturen
• [ ] Ersetzen durch mlflow.evaluate()mlflow.genai.evaluate()
  • [ ] Parameternamen aktualisieren (model → predict_fn, extra_metrics → scorers)
  • [ ] Aktualisieren von Datenfeldnamen (request → inputs, response → outputs, expected* → expectations)
  • [ ] Ersetzen Sie evaluator_config durch eine Konfiguration auf Scorer-Ebene
  • [ ] Ergebnisse zugreifen auf Nutzung aktualisieren mlflow.search_traces()

LLM-Richter

• [ ] Ersetzen Sie direkte Richteranrufe nach Möglichkeit durch vordefinierte Scorer
• [ ] Update judges.guideline_adherence() auf judges.meets_guidelines() oder Guidelines() Scorer-R-Skript aktualisieren
• [ ] Aktualisieren der Parameternamen der Richterfunktion, damit sie mit der neuen API übereinstimmen
• [ ] Erwägen Sie die Verwendung von ExpectationsGuidelines() für Pfad-basierte Führungslinien

Menschliches Feedback

• [ ] Aktualisierung der Labelierungssitzung und Überprüfung der App-Importe in mlflow.genai.labeling
• [ ] Bezeichnungsschemaimporte aktualisieren zu mlflow.genai.label_schemas
• [ ] Updatelogik zum Synchronisieren von Feedback mit Datasets

Häufige Fallstricke, die vermieden werden sollen

• Denken Sie daran, Datenfeldnamen in Ihren DataFrames zu aktualisieren.
• Denken Sie daran, dass model_type="databricks-agent" nicht mehr benötigt wird.
• Stellen Sie sicher, dass benutzerdefinierte Scorer gültige Werte zurückgeben ("ja"/"nein" für Pass/Fail)
• Verwenden Sie search_traces() statt direkt auf Ergebnistabellen zuzugreifen.
• Aktualisieren aller hartcodierten Namespaceverweise in Ihrem Code
• Denken Sie daran, alle Scorer explizit anzugeben – MLflow 3 führt nicht automatisch Richter aus
• Konvertieren Sie global_guidelines von der Konfiguration zu expliziten Guidelines()-Scorern

Migration der Auswertungs-API

Importieren von Updates

In der folgenden Liste werden Importe zusammengefasst, die aktualisiert werden sollen, mit Details und Beispielen in den einzelnen Unterabschnitten unten.

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

Von mlflow.evaluate() bis mlflow.genai.evaluate()

Die Kernauswertungs-API wurde in einen dedizierten GenAI-Namespace mit saubereren Parameternamen verschoben.

Wichtige API-Änderungen:

Datenfeldzuordnung:

Beispiel: Grundlegende Auswertung

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

Zugreifen auf Auswertungsergebnisse

In MLflow 3 werden Auswertungsergebnisse als Abläufe mit Bewertungen gespeichert. Verwendung mlflow.search_traces() für den Zugriff auf detaillierte Ergebnisse:

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

Auswertung eines in MLflow protokollierten Modells

In MLflow 2.x können Sie ein protokolliertes MLflow-Modell (z. B. ein PyFunc-Modell oder ein vom Agent Framework protokolliertes Modell) direkt an mlflow.evaluate()übergeben. In MLflow 3.x müssen Sie das Modell in eine Vorhersagungsfunktion umschließen, um die Parameterzuordnung zu verarbeiten.

Dieser Wrapper ist notwendig, da mlflow.genai.evaluate() eine Vorhersagefunktion erwartet, die die Schlüssel im inputs Wörterbuch aus Ihrem Datensatz als Schlüsselwortargumente akzeptiert, während die meisten protokollierten Modelle einen einzelnen Eingabeparameter akzeptieren (z. B. model_inputs für PyFunc-Modelle oder ähnliche Schnittstellen für LangChain-Modelle).

Die Vorhersagefunktion dient als Übersetzungsebene zwischen den benannten Parametern des Auswertungsframeworks und dem erwarteten Eingabeformat des Modells.

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

Benutzerdefinierte Metrik zur Scorer-Migration

Benutzerdefinierte Auswertungsfunktionen (@metric) verwenden jetzt den @scorer Dekorateur mit einer vereinfachten Signatur.

Wichtige Änderungen:

Beispiel: Bestanden/Fehler-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 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]
)

Beispiel: Numerischer Bewerter mit Bewertung

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 beurteilt Migration

Wichtige Unterschiede beim Richterverhalten

Automatische Richterauswahl:

MLflow 2.x automatische Richterauswahl:

• Ohne Bodenwahrheit: ausführen chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• Mit Bodenwahrheit: führt auch context_sufficiency aus, correctness

MLflow 3.x explizite Auswahl des Scorers

• Sie müssen die Scorer, die Sie ausführen möchten, explizit in der Liste aufführen
• Mehr Kontrolle, erfordert jedoch explizite Bewertungsanforderungen

Migrationspfade

MLflow 3 bietet zwei Möglichkeiten, LLM-Richter zu verwenden:

1. Vordefinierte Bewerter - Einsatzbereite Bewerter, die Richter mit automatischer Ablaufverfolgungsanalyse umschließen
2. Direkte Richteranrufe – Rufen Sie Richter direkt in benutzerdefinierten Scorern an, um mehr Kontrolle zu erzielen

Kontrolle darüber, welche Richter ausführen

Beispiel: Festlegen der Richter zur Ausführung

MLflow 2.x (Standard-Grenzwerte für Richter einschränken):

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 (explizite Auswahl des Scorers):

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

Umfassendes Migrationsbeispiel

Dieses Beispiel zeigt die Migration einer Auswertung, die mehrere Richter mit benutzerdefinierter Konfiguration verwendet:

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

Migrieren zu vordefinierten Bewertungsrichtern

MLflow 3 bietet vordefinierte Bewertungsfunktionen, die die LLM-Richter umschließen, was ihre Nutzung mit „mlflow.genai.evaluate()“ erleichtert.

Beispiel: Korrektheitsrichter

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 (Option 1: Verwenden vordefinierter Scorer):

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 (Option 2: Benutzerdefinierter Scorer mit Richter):

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

Beispiel: Sicherheitsrichter

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

Beispiel: Relevanzrichter

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

Beispiel: Urteilsfähigkeit in Bezug auf Bodenständigkeit

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

Migrieren der Durchschnittsprämieneinhaltung zu meets_guidelines

Der guideline_adherence-Richter wurde in meets_guidelines umbenannt und verfügt nun über eine klarere 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 (Option 1: Verwendung eines vordefinierten Richtlinien-Skorers):

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 (Option 2: Benutzerdefinierter Scorer mit 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
        }
    )

Beispiel: Migrieren von ErwartungenGuidelines

Wenn Sie Richtlinien für jedes Beispiel in Ihrem Auswertungssatz festlegen möchten, z. B. dass bestimmte Themen behandelt werden oder dass die Antwort einem bestimmten Stil folgt, verwenden Sie den ExpectationsGuidelines Scorer in MLflow 3.x.

MLflow 2.x:

In MLflow 2.x würden Sie Richtlinien wie folgt implementieren:

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:

In MLflow 3.x organisieren Sie Auswertungsdaten unterschiedlich. Jeder Eintrag in Ihren Auswertungsdaten sollte über einen expectations Schlüssel verfügen, und darin können Sie Felder wie guidelinesz. B. einschließen.

Hier sehen Sie, wie Ihre Auswertungsdaten aussehen können:

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

Verwenden Sie dann den ExpectationsGuidelines scorer:

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

Replizieren des automatischen Beurteilungsverhaltens von MLflow 2.x

Um das Verhalten von MLflow 2.x zu replizieren, bei dem alle geltenden Bewerter ausgeführt werden, schließen Sie alle Bewerter explizit ein:

MLflow 2.x (automatisch):

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

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

Direkte Richternutzung

Sie können weiterhin direkt Richter zu Testzwecken anrufen.

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

Migration von menschlichem Feedback

Bezeichnungssitzungen und Schemas

Die Funktion "App überprüfen" wurde von databricks.agents zu mlflow.genai.labeling" verschoben.

Namespaceänderungen:

Beispiel: Erstellen einer Bezeichnungssitzung

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

Synchronisieren von Feedback mit Datasets

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
)

Weitere Ressourcen

• MLflow 3 GenAI Evaluation Guide
• Benutzerdefinierte Scorer-Dokumentation
• Menschliches Feedback mit Bezeichnungssitzungen
• Vordefinierte Richterbewerter
• Leitfaden für die MLflow-Ablaufverfolgung

Weitere Unterstützung während der Migration finden Sie in der MLflow-Dokumentation oder wenden Sie sich an Ihr Databricks-Supportteam.