Erstellen und Verwalten von Bezeichnungsschemas

Beschriftungsschemata definieren die spezifischen Fragen, die Domänenexperten beim Bezeichnen vorhandener Traces in der Review-App beantworten. Sie strukturieren den Feedbacksammlungsprozess und stellen konsistente und relevante Informationen für die Auswertung Ihrer GenAI-App sicher.

Kennzeichnungsschemata gelten nur, wenn die Überprüfungs-App zum Bezeichnen vorhandener Ablaufverfolgungen verwendet wird. Sie werden nicht für Stimmungstests in der Review-App-Chat-Benutzeroberfläche verwendet.

Funktionsweise von Bezeichnungsschemas

Wenn Sie eine Bezeichnungssitzung erstellen, ordnen Sie sie einem oder mehreren Bezeichnungsschemas zu. Jedes Schema stellt eine Bewertung dar, die einem Trace zugeordnet ist. Bewertungen sind entweder Feedback oder Expectation. Ausführliche Informationen finden Sie unter Label während der Entwicklung.

Die Schemakontrolle:

• Die Frage, die den Prüfern angezeigt wird.
• Die Eingabemethode (z. B. Dropdown- oder Textfeld).
• Gültigkeitsprüfungsregeln und Einschränkungen.
• Optionale Anweisungen und Kommentare.

Bezeichnungsschemas für integrierte LLM-Richter

MLflow bietet vordefinierte Schemanamen für die eingebauten LLM-Evaluatoren, die Erwartungen verwenden. Sie können benutzerdefinierte Schemas mithilfe dieser Namen erstellen, um die Kompatibilität mit der integrierten Auswertungsfunktionalität sicherzustellen.

Die folgende Tabelle zeigt die vordefinierten Bezeichnungsschemas und deren Verwendung.

Beispiele für Bezeichnungsschemas für integrierte LLM-Richter

Ausführliche Informationen finden Sie in der API-Referenz.

import mlflow.genai.label_schemas as schemas
from mlflow.genai.label_schemas import LabelSchemaType, InputTextList, InputText

# Schema for collecting expected facts
expected_facts_schema = schemas.create_label_schema(
    name=schemas.EXPECTED_FACTS,
    type=LabelSchemaType.EXPECTATION,
    title="Expected facts",
    input=InputTextList(max_length_each=1000),
    instruction="Please provide a list of facts that you expect to see in a correct response.",
    overwrite=True
)

# Schema for collecting guidelines
guidelines_schema = schemas.create_label_schema(
    name=schemas.GUIDELINES,
    type=LabelSchemaType.EXPECTATION,
    title="Guidelines",
    input=InputTextList(max_length_each=500),
    instruction="Please provide guidelines that the model's output is expected to adhere to.",
    overwrite=True
)

# Schema for collecting expected response
expected_response_schema = schemas.create_label_schema(
    name=schemas.EXPECTED_RESPONSE,
    type=LabelSchemaType.EXPECTATION,
    title="Expected response",
    input=InputText(),
    instruction="Please provide a correct agent response.",
    overwrite=True
)

Erstellen von benutzerdefinierten Bezeichnungsschemas

Um mehr Kontrolle über das gesammelte Feedback zu haben, erstellen Sie ein benutzerdefiniertes Bezeichnungsschema mithilfe der MLflow-BEnutzeroberfläche oder -API.

Schemas sind auf Experimente festgelegt, daher müssen Schemanamen innerhalb Ihres MLflow-Experiments eindeutig sein.

Schemas sind eines von zwei Typen:

• feedback: Subjektive Einschätzungen wie Bewertungen, Präferenzen oder Meinungen.
• expectation: Objektive Wahrheit wie richtige Antworten oder erwartetes Verhalten.

Ausführliche Informationen finden Sie unter Label während der Entwicklung. Parameterdefinitionen finden Sie in der API-Referenz.

Erstellen benutzerdefinierter Schemas mithilfe der Benutzeroberfläche

So erstellen Sie ein benutzerdefiniertes Schema in der MLflow-Benutzeroberfläche:

1. Klicken Sie im Arbeitsbereich "Databricks" in der linken Randleiste auf "Experimente".

2. Klicken Sie auf den Namen Ihres Experiments, um es zu öffnen.

3. Klicken Sie in der Randleiste auf Kennzeichnungsschemata.

4. Wenn ein vorhandenes Bezeichnungsschema angezeigt wird, können Sie es bearbeiten. Wenn Sie ein neues Bezeichnungsschema erstellen oder hinzufügen möchten, klicken Sie auf "Bezeichnungsschema hinzufügen", und bearbeiten Sie die Felder.

   

   Wenn Sie den Eingabetyp auswählen, ändern sich die darunter liegenden Felder, um detaillierte Anforderungen anzugeben, z. B. Längenbeschränkungen für Text, Optionen für kategorisierte Auswahlmöglichkeiten oder einen numerischen Bereich.

   Wenn Sie Informationen in die Felder eingeben, wird das Feld rechts aktualisiert, um das schema widerzuspiegeln, das Sie erstellen.

5. Klicken Sie abschließend auf Speichern.

Das folgende Video zeigt den Prozess.

Erstellen von benutzerdefinierten Schemas mithilfe der API

Sie können Schemas mit mlflow.genai.label_schemas.create_label_schema() erstellen. Für alle Schemas ist ein Name, Typ, Titel und Eingabespezifikation erforderlich.

Beispiel für ein einfaches Schema

import mlflow.genai.label_schemas as schemas
from mlflow.genai.label_schemas import InputCategorical, InputText

# Create a feedback schema for rating response quality
quality_schema = schemas.create_label_schema(
    name="response_quality",
    type="feedback",
    title="How would you rate the overall quality of this response?",
    input=InputCategorical(options=["Poor", "Fair", "Good", "Excellent"]),
    instruction="Consider accuracy, relevance, and helpfulness when rating."
)

Beispiel für benutzerdefiniertes Schemafeedback

import mlflow.genai.label_schemas as schemas
from mlflow.genai.label_schemas import InputCategorical, InputTextList

# Feedback schema for subjective assessment
tone_schema = schemas.create_label_schema(
    name="response_tone",
    type="feedback",
    title="Is the response tone appropriate for the context?",
    input=InputCategorical(options=["Too formal", "Just right", "Too casual"]),
    enable_comment=True  # Allow additional comments
)

Beispiel für eine benutzerdefinierte Schemaerwartung

# Expectation schema for ground truth
facts_schema = schemas.create_label_schema(
    name="required_facts",
    type="expectation",
    title="What facts must be included in a correct response?",
    input=InputTextList(max_count=5, max_length_each=200),
    instruction="List key facts that any correct response must contain."
)

Verwalten von Bezeichnungsschemas

Mithilfe der API können Sie Bezeichnungsschemas auflisten, aktualisieren und löschen.

Listenschemas

Verwenden Sie die API get_label_schema, um Informationen zu einem vorhandenen Schema abzurufen. Sie müssen den Namen des Schemas angeben. wie im folgenden Beispiel gezeigt. Ausführliche Informationen finden Sie in der API-Referenz: get_label_schema.

import mlflow.genai.label_schemas as schemas

# Get an existing schema
schema = schemas.get_label_schema("response_quality")
print(f"Schema: {schema.name}")
print(f"Type: {schema.type}")
print(f"Title: {schema.title}")

Aktualisieren von Schemas

Um ein vorhandenes Schema zu aktualisieren, verwenden Sie die API create_label_schema , und legen Sie den overwrite Parameter auf True. Ausführliche Informationen finden Sie in der API-Referenz: create_label_schema.

import mlflow.genai.label_schemas as schemas
from mlflow.genai.label_schemas import InputCategorical

# Update by recreating with overwrite=True
updated_schema = schemas.create_label_schema(
    name="response_quality",
    type="feedback",
    title="Rate the response quality (updated question)",
    input=InputCategorical(options=["Excellent", "Good", "Fair", "Poor", "Very Poor"]),
    instruction="Updated: Focus on factual accuracy above all else.",
    overwrite=True  # Replace existing schema
)

Löschen von Schemas

Das folgende Beispiel zeigt, wie Sie ein Bezeichnungsschema löschen. Ausführliche Informationen finden Sie in der API-Referenz: delete_label_schema.

import mlflow.genai.label_schemas as schemas

# Remove a schema that's no longer needed
schemas.delete_label_schema("old_schema_name")

Eingabetypen für benutzerdefinierte Schemas

MLflow unterstützt die in der Tabelle angezeigten Eingabetypen zum Sammeln verschiedener Arten von Feedback. Die folgenden Abschnitte zeigen Beispiele für jeden Typ.

InputCategorical

from mlflow.genai.label_schemas import InputCategorical

# Rating scale
rating_input = InputCategorical(
    options=["1 - Poor", "2 - Below Average", "3 - Average", "4 - Good", "5 - Excellent"]
)

# Binary choice
safety_input = InputCategorical(options=["Safe", "Unsafe"])

# Multiple categories
error_type_input = InputCategorical(
    options=["Factual Error", "Logical Error", "Formatting Error", "No Error"]
)

InputCategoricalList

from mlflow.genai.label_schemas import InputCategoricalList

# Multiple error types can be present
errors_input = InputCategoricalList(
    options=[
        "Factual inaccuracy",
        "Missing context",
        "Inappropriate tone",
        "Formatting issues",
        "Off-topic content"
    ]
)

# Multiple content types
content_input = InputCategoricalList(
    options=["Technical details", "Examples", "References", "Code samples"]
)

InputText

from mlflow.genai.label_schemas import InputText

# General feedback
feedback_input = InputText(max_length=500)

# Specific improvement suggestions
improvement_input = InputText(
    max_length=200  # Limit length for focused feedback
)

# Short answers
summary_input = InputText(max_length=100)

InputTextList

from mlflow.genai.label_schemas import InputTextList

# List of factual errors
errors_input = InputTextList(
    max_count=10,        # Maximum 10 errors
    max_length_each=150  # Each error description limited to 150 chars
)

# Missing information
missing_input = InputTextList(
    max_count=5,
    max_length_each=200
)

# Improvement suggestions
suggestions_input = InputTextList(max_count=3)  # No length limit per item

InputNumeric

from mlflow.genai.label_schemas import InputNumeric

# Confidence score
confidence_input = InputNumeric(
    min_value=0.0,
    max_value=1.0
)

# Rating scale
rating_input = InputNumeric(
    min_value=1,
    max_value=10
)

# Cost estimate
cost_input = InputNumeric(min_value=0)  # No maximum limit

Vollständige Beispiele

Bewertung des Kundenservices

Hier ist ein umfassendes Beispiel für die Auswertung von Antworten auf den Kundenservice:

import mlflow.genai.label_schemas as schemas
from mlflow.genai.label_schemas import (
    InputCategorical,
    InputCategoricalList,
    InputText,
    InputTextList,
    InputNumeric
)

# Overall quality rating
quality_schema = schemas.create_label_schema(
    name="service_quality",
    type="feedback",
    title="Rate the overall quality of this customer service response",
    input=InputCategorical(options=["Excellent", "Good", "Average", "Poor", "Very Poor"]),
    instruction="Consider helpfulness, accuracy, and professionalism.",
    enable_comment=True
)

# Issues identification
issues_schema = schemas.create_label_schema(
    name="response_issues",
    type="feedback",
    title="What issues are present in this response? (Select all that apply)",
    input=InputCategoricalList(options=[
        "Factually incorrect information",
        "Unprofessional tone",
        "Doesn't address the question",
        "Too vague or generic",
        "Contains harmful content",
        "No issues identified"
    ]),
    instruction="Select all issues you identify. Choose 'No issues identified' if the response is problem-free."
)

# Expected resolution steps
resolution_schema = schemas.create_label_schema(
    name="expected_resolution",
    type="expectation",
    title="What steps should be included in the ideal resolution?",
    input=InputTextList(max_count=5, max_length_each=200),
    instruction="List the key steps a customer service rep should take to properly resolve this issue."
)

# Confidence in assessment
confidence_schema = schemas.create_label_schema(
    name="assessment_confidence",
    type="feedback",
    title="How confident are you in your assessment?",
    input=InputNumeric(min_value=1, max_value=10),
    instruction="Rate from 1 (not confident) to 10 (very confident)"
)

Überprüfung medizinischer Informationen

Beispiel für die Auswertung medizinischer Informationsantworten:

import mlflow.genai.label_schemas as schemas
from mlflow.genai.label_schemas import InputCategorical, InputTextList, InputNumeric

# Safety assessment
safety_schema = schemas.create_label_schema(
    name="medical_safety",
    type="feedback",
    title="Is this medical information safe and appropriate?",
    input=InputCategorical(options=[
        "Safe - appropriate general information",
        "Concerning - may mislead patients",
        "Dangerous - could cause harm if followed"
    ]),
    instruction="Assess whether the information could be safely consumed by patients."
)

# Required disclaimers
disclaimers_schema = schemas.create_label_schema(
    name="required_disclaimers",
    type="expectation",
    title="What medical disclaimers should be included?",
    input=InputTextList(max_count=3, max_length_each=300),
    instruction="List disclaimers that should be present (e.g., 'consult your doctor', 'not professional medical advice')."
)

# Accuracy of medical facts
accuracy_schema = schemas.create_label_schema(
    name="medical_accuracy",
    type="feedback",
    title="Rate the factual accuracy of the medical information",
    input=InputNumeric(min_value=0, max_value=100),
    instruction="Score from 0 (completely inaccurate) to 100 (completely accurate)"
)

Integration mit Labeling-Sitzungen

Das folgende Beispiel zeigt, wie Sie Ihre Schemas in einer Bezeichnungssitzung verwenden:

import mlflow.genai.label_schemas as schemas

# Schemas are automatically available when creating labeling sessions
# The Review App will present questions based on your schema definitions

# Example: Using schemas in a session (conceptual - actual session creation
# happens through the Review App UI or other APIs)
session_schemas = [
    "service_quality",      # Your custom schema
    "response_issues",      # Your custom schema
    schemas.EXPECTED_FACTS  # Built-in schema
]

Bewährte Methoden

Schemaentwurf

• Schreiben Sie Fragen als klare, spezifische Eingabeaufforderungen.
• Stellen Sie kontextbezogene Anleitungen für Prüfer bereit.
• Legen Sie angemessene Grenzwerte für textlängen und Listenanzahl fest.
• Stellen Sie für kategorisierte Eingaben sicher, dass Optionen sich gegenseitig ausschließen und umfassend sind.

Schemaverwaltung

• Verwenden Sie beschreibende, konsistente Namen in Ihren Schemas.
• Berücksichtigen Sie beim Aktualisieren von Schemas die Auswirkungen auf vorhandene Sitzungen.
• Löschen Sie nicht verwendete Schemas, um den Arbeitsbereich zu organisieren.

Nächste Schritte

• Vorhandene Spuren beschriften – Wenden Sie Ihre Schemata an, um strukturiertes Feedback zu sammeln.
• Erstellen von Beschriftungssitzungen – Organisieren von Überprüfungsworkflows mithilfe Ihrer Schemata
• Erstellen von Auswertungsdatensätzen – Transformieren von beschrifteten Daten in Testdatensätze