Migrowanie do platformy MLflow 3 z wersji ewaluacyjnej agenta

Ocena agenta jest teraz zintegrowana z platformą MLflow 3 w usłudze Databricks. Metody SDK do oceny agenta są teraz udostępniane poprzez SDK mlflow[databricks]>=3.1 w przestrzeni nazw mlflow.genai. MLflow 3 wprowadza:

• Odświeżony interfejs użytkownika , który odzwierciedla wszystkie funkcje zestawu SDK
• Nowy zestaw SDKmlflow.genai z uproszczonymi interfejsami API do uruchamiania oceny, etykietowania przez człowieka i zarządzania zestawami danych oceny
• Ulepszone śledzenie przy użyciu zaplecza pozyskiwania śledzenia w skali produkcyjnej, które zapewnia możliwość obserwowania w czasie rzeczywistym
• Usprawniona kolekcja opinii ludzkich
• Ulepszeni sędziowie LLM jako wbudowani oceniający

Ten przewodnik ułatwia migrację z Ewaluacji Agenta (MLflow 2.x z databricks-agents<1.0) do MLflow 3. Ten szczegółowy przewodnik jest również dostępny w formacie krótkiej instrukcji.

Lista kontrolna migracji

Rozpocznij pracę, korzystając z tej listy kontrolnej. Każdy element łączy się ze szczegółami w poniższych sekcjach.

Interfejs API ewaluacji

• [ ] Aktualizuj importy z databricks.agents do mlflow.genai.*
• [ ] Konwertuj @metric dekoratory na @scorer
  • [ ] Aktualizowanie sygnatur funkcji metryki niestandardowej/scorer
• [ ] Zastąp ciąg mlflow.evaluate() ciągiem mlflow.genai.evaluate()
  • [ ] Aktualizowanie nazw parametrów (model → predict_fn, extra_metrics → scorers)
  • [ ] Aktualizowanie nazw pól danych (request → inputs, response → outputs, expected* → expectations)
  • [ ] Zastąp element evaluator_config konfiguracją na poziomie wskaźnika
  • [ ] Aktualizowanie dostępu do wyników do użycia mlflow.search_traces()

Sędziowie LLM

• [ ] Zastąp bezpośrednie wywołania sędziego wstępnie zdefiniowanymi punktatorami, jeśli to możliwe
• [ ] Zaktualizuj judges.guideline_adherence() do judges.meets_guidelines() lub Guidelines() licznika
• [ ] Aktualizowanie nazw parametrów funkcji sędziego w celu dopasowania do nowego interfejsu API
• [ ] Rozważ użycie ExpectationsGuidelines() wytycznych opartych na danych referencyjnych

Opinie użytkowników

• [ ] Zaktualizuj sesję etykietowania i przeglądaj importy aplikacji do mlflow.genai.labeling
• [ ] Aktualizowanie importów schematów etykiet do mlflow.genai.label_schemas
• [ ] Aktualizacja logiki synchronizowania opinii z zestawami danych

Typowe pułapki do unikania

• Pamiętaj, aby zaktualizować nazwy pól danych w ramkach danych
• Pamiętaj, że model_type="databricks-agent" nie jest już potrzebne
• Upewnij się, że niestandardowe moduły oceniające zwracają prawidłowe wartości ("tak"/"nie" dla zaliczenia/niepowodzenia)
• Użyj search_traces() zamiast bezpośrednio uzyskiwać dostęp do tabel wyników
• Zaktualizuj hardkodowane odwołania do przestrzeni nazw w kodzie.
• Pamiętaj, aby jawnie określić wszystkie osoby oceniające — narzędzie MLflow 3 nie uruchamia automatycznie sędziów
• Konwertowanie global_guidelines z konfiguracji na jawne Guidelines() oceniacze

Migracja interfejsu API ewaluacji

Importowanie aktualizacji

Poniższa lista zawiera podsumowanie importów do aktualizacji wraz ze szczegółami i przykładami w każdej podsekcji poniżej.

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

Z mlflow.evaluate() do mlflow.genai.evaluate()

Podstawowy interfejs API oceny został przeniesiony do dedykowanej przestrzeni nazw GenAI z czystszymi nazwami parametrów.

Kluczowe zmiany interfejsu API:

Mapowanie pól danych:

Przykład: ocena podstawowa

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

Uzyskiwanie dostępu do wyników oceny

W środowisku MLflow 3 wyniki oceny są przechowywane jako ślady z ocenami. Użyj mlflow.search_traces(), aby uzyskać dostęp do szczegółowych wyników.

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

Ocena modelu o nazwie MLflow LoggedModel

W środowisku MLflow 2.x można przekazać zarejestrowany model MLflow (taki jak model PyFunc lub zarejestrowany przez platformę Agent) bezpośrednio do usługi mlflow.evaluate(). W środowisku MLflow 3.x należy opakowować model w funkcji predict w celu obsługi mapowania parametrów.

Ta otoczka jest niezbędna, ponieważ mlflow.genai.evaluate() oczekuje funkcji predict, która akceptuje klucze w słowniku inputs z twojego zestawu danych jako argumenty słów kluczowych, podczas gdy większość zarejestrowanych modeli akceptuje pojedynczy parametr wejściowy (np. model_inputs w przypadku modeli PyFunc lub podobnych interfejsów dla modeli LangChain).

Funkcja predict służy jako warstwa tłumaczenia między nazwami parametrów platformy oceny a oczekiwanym formatem wejściowym modelu.

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

Migracja metryk niestandardowych do systemu punktacji

Niestandardowe funkcje oceny (@metric) używają teraz dekoratora @scorer z uproszczonym podpisem.

Kluczowe zmiany:

Przykład: oceniający system zdany/niezdany

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

Przykład: wynik liczbowy z oceną/ewaluacją

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

Migracja sędziów LLM

Kluczowe różnice w zachowaniu sędziego

Wybór automatycznego sędziego:

Wybór automatycznego sędziego MLflow 2.x:

• Bez informacji bazowej: działają chunk_relevance, groundedness, relevance_to_query, safety, guideline_adherence
• Z prawdziwym stanem rzeczy: działa także context_sufficiency, correctness

Wybór jawnego klasyfikatora MLflow 3.x:

• Musisz jawnie wyświetlić listę punktów oceny, które chcesz uruchomić
• Większa kontrola, ale wymaga jawnego bycia na temat potrzeb oceny

Ścieżki migracji

Platforma MLflow 3 udostępnia dwa sposoby korzystania z sędziów LLM:

1. Wstępnie zdefiniowane mierniki — gotowe do użycia mierniki, które zawierają sędziów z automatycznym analizowaniem śladów
2. Bezpośrednie połączenia do sędziów — dzwoń do sędziów bezpośrednio w ramach niestandardowych mechanizmów oceniania, aby uzyskać większą kontrolę

Kontrolowanie, którzy sędziowie przeprowadzają

Przykład: wyznaczanie sędziów do zadania

MLflow 2.x (ograniczenie sędziów domyślnych):

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 (wybór jawnego mechanizmu oceny):

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

Kompleksowy przykład migracji

Ten przykład pokazuje, jak wykonać migrację oceny używającej wielu sędziów z niestandardową konfiguracją:

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

Migrowanie do wstępnie zdefiniowanych ocen sędziów

Platforma MLflow 3 udostępnia wstępnie zdefiniowane moduły oceniające, które opakowują sędziów LLM, co ułatwia ich używanie z usługą mlflow.genai.evaluate().

Przykład: Sędzia poprawności

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 (Opcja 1: Używanie wstępnie zdefiniowanego wskaźnika):

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 (Opcja 2: niestandardowy oceniacz z oceniającym):

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

Przykład: Sędzia bezpieczeństwa

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

Przykład: Oceniacz istotności

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

Przykład: Sędzia stabilności

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

Migrowanie przestrzegania wytycznych do statusu meets_guidelines

Nazwa guideline_adherence sędziego została zmieniona na meets_guidelines za pomocą czystszego interfejsu 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 (Opcja 1: Używanie wstępnie zdefiniowanego wskaźnika wytycznych):

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 (Opcja 2: niestandardowy moduł oceny z 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
        }
    )

Przykład: Migrowanie oczekiwańGuidelines

Jeśli chcesz ustawić wytyczne dla każdego przykładu w zestawie oceny, takie jak wymaganie, aby niektóre tematy zostały omówione, lub że odpowiedź jest zgodna z określonym stylem, użyj modułu oceniania w narzędziu ExpectationsGuidelines MLflow 3.x.

MLflow 2.x:

W środowisku MLflow 2.x należy zaimplementować wytyczne w następujący sposób:

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:

W środowisku MLflow 3.x dane ewaluacyjne są organizowane inaczej. Każdy element w danych ewaluacyjnych powinien mieć klucz expectations, a wewnątrz tego można uwzględnić pola, takie jak guidelines.

Oto, jak mogą wyglądać dane oceny:

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

Następnie użyj ExpectationsGuidelines wskaźnika:

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

Replikowanie automatycznego zachowania sędziego MLflow 2.x

Aby replikować zachowanie platformy MLflow 2.x podczas uruchamiania wszystkich odpowiednich sędziów, jawnie uwzględnij wszystkie osoby oceniające:

MLflow 2.x (automatyczne):

# 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 (wyraźne):

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

Bezpośrednie użycie sędziego

Nadal możesz wezwać sędziów bezpośrednio do testowania:

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

Migracja opinii użytkowników

Etykietowanie sesji i schematów

Funkcja aplikacji Przegląd została przeniesiona z databricks.agents do mlflow.genai.labeling.

Zmiany przestrzeni nazw:

Przykład: tworzenie sesji etykietowania

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

Synchronizowanie opinii z zestawami danych

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
)

Dodatkowe zasoby

• Przewodnik oceny MLflow 3 GenAI
• Dokumentacja niestandardowych oceniających
• Opinie użytkowników z sesjami etykietowania
• Wstępnie zdefiniowane oceny sędziów
• Przewodnik śledzenia MLflow

Aby uzyskać dodatkową pomoc techniczną podczas migracji, zapoznaj się z dokumentacją platformy MLflow lub skontaktuj się z zespołem pomocy technicznej usługi Databricks.