Créer et gérer des schémas d’étiquetage

Les schémas d'étiquetage définissent les questions spécifiques auxquelles les experts du domaine répondent lors de l'étiquetage des traces existantes dans l'application d'évaluation. Ils structurent le processus de collecte de feedback, garantissant des informations cohérentes et pertinentes pour l'évaluation de votre application GenAI.

Les schémas d'étiquetage s'appliquent uniquement lors de l'utilisation de l'application d'évaluation pour étiqueter les traces existantes. Ils ne sont pas utilisés pour les vérifications d'ambiance dans l'interface utilisateur de discussion de l'application d'évaluation.

Fonctionnement des schémas d'étiquetage

Lorsque vous créez une session d'étiquetage, vous l'associez à un ou plusieurs schémas d'étiquetage. Chaque schéma représente une évaluation attachée à une trace. Les évaluations sont soit Feedback, soit Expectation. Pour plus de détails, consultez Étiqueter pendant le développement.

Les schémas contrôlent :

La question présentée aux réviseurs.
La méthode de saisie (par exemple, menu déroulant ou zone de texte).
Règles de validation et contraintes.
Instructions et commentaires facultatifs.

Schémas d'étiquetage pour les juges LLM intégrés

MLflow fournit des noms de schémas prédéfinis pour les juges LLM intégrés qui utilisent des attentes. Vous pouvez créer des schémas personnalisés à l'aide de ces noms pour garantir la compatibilité avec la fonctionnalité d'évaluation intégrée.

Le tableau suivant présente les schémas d'étiquetage prédéfinis et leur utilisation.

Nom du schéma	Utilisation	Utilisé par ces juges intégrés
`GUIDELINES`	Recueille les instructions idéales que l'application GenAI doit suivre pour une demande.	`ExpectationGuidelines`
`EXPECTED_FACTS`	Recueille les déclarations factuelles qui doivent être incluses pour l'exactitude.	`Correctness`, `RetrievalSufficiency`
`EXPECTED_RESPONSE`	Collecte la réponse complète de vérité de terrain.	`Correctness`, `RetrievalSufficiency`

Nom du schéma	Utilisation	Utilisé par ces juges intégrés
`GUIDELINES`	Recueille les instructions idéales que l'application GenAI doit suivre pour une demande.	`ExpectationGuidelines`
`EXPECTED_FACTS`	Recueille les déclarations factuelles qui doivent être incluses pour l'exactitude.	`Correctness`, `RetrievalSufficiency`
`EXPECTED_RESPONSE`	Collecte la réponse complète de vérité de terrain.	`Correctness`, `RetrievalSufficiency`

Exemples de schémas d'étiquetage pour les juges LLM intégrés

Pour plus de détails, consultez la référence de l'API.

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

Créer des schémas d'étiquetage personnalisés

Pour un meilleur contrôle sur les commentaires que vous collectez, créez un schéma d'étiquetage personnalisé en utilisant l'interface utilisateur ou l'API de MLflow.

Les schémas sont limités aux Experimentation, les noms de schéma doivent donc être uniques au sein de votre Experimentation MLflow.

Les schémas sont de deux types :

feedback : Évaluations subjectives telles que les notes, les préférences ou les opinions.
expectation: Vérité terrain objective telle que des réponses correctes ou un comportement attendu.

Pour plus de détails, consultez Étiqueter pendant le développement. Pour les définitions des parameters, consultez la référence de l'API.

Créer des schémas personnalisés à l'aide de l'interface utilisateur

Pour créer un schéma personnalisé dans l'interface utilisateur MLflow :

Dans le Workspace Databricks, dans la barre latérale gauche, cliquez sur Expériences .
Cliquez sur le nom de votre Experimentation pour l'ouvrir.
Cliquez sur Schémas d’étiquetage dans la barre latérale.
Si un schéma d'étiquetage existant apparaît, vous pouvez le modifier. Pour créer ou ajouter un nouveau schéma d'étiquetage, cliquez sur Ajouter un schéma d'étiquetage et modifiez les champs.

Lorsque vous sélectionnez le **type d'entrée**, les champs situés en dessous changent pour vous permettre de spécifier des exigences détaillées, telles que les limites de longueur pour le texte, les options pour les choix catégoriques ou une plage numérique.

Au fur et à mesure que vous saisissez des informations dans les champs, le cadre à droite se met à jour pour refléter le schéma que vous créez.
Lorsque vous avez terminé, cliquez sur **Enregistrer**.

La vidéo suivante montre le processus.

Vidéo : Créer un schéma d'étiquetage dans l'interface utilisateur.

Créez des schémas personnalisés à l'aide de l'API

Vous pouvez créer des schémas en utilisant mlflow.genai.label_schemas.create_label_schema(). Tous les schémas requièrent un nom, un type, un titre et une spécification d'entrée.

Exemple de schéma de base

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

Exemple de retour d'information pour le schéma personnalisé

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

Exemple d'attente de schéma personnalisé

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

Gérer les schémas d’étiquetage

À l'aide de l'API, vous pouvez lister, mettre à jour et supprimer des schémas d'étiquetage.

Lister les schémas

Pour obtenir des informations sur un schéma existant, utilisez l'API get_label_schema. Vous devez fournir le nom du schéma. comme indiqué dans l'exemple suivant. Pour plus de détails, consultez la référence de l'API : get_label_schema.

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

Mettre à jour les schémas

Pour mettre à jour un schéma existant, utilisez l'API create_label_schema et définissez le paramètre overwrite sur True. Pour plus de détails, consultez la référence de l'API : create_label_schema.

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

Supprimer les schémas

L'exemple suivant montre comment supprimer un schéma d'étiquetage. Pour plus de détails, consultez la référence de l'API : delete_label_schema.

Python
import mlflow.genai.label_schemas as schemas

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

Types d'entrée pour les schémas personnalisés

MLflow prend en charge les types d'entrée indiqués dans le tableau pour la collecte de différents types de feedback. Les sections suivantes affichent des exemples pour chaque type.

Type d’entrée	Description et utilisation
`InputCategorical`	Un menu déroulant à sélection unique. Utilisez pour des options mutuellement exclusives, telles que les évaluations ou les classifications.
`InputCategoricalList`	Un menu déroulant à sélection multiple. Utiliser lorsque plusieurs options peuvent être sélectionnées.
`InputText`	Zone de texte libre. À utiliser lorsque la réponse est ouverte, comme pour des explications détaillées ou des commentaires personnalisés.
`InputTextList`	Plusieurs zones de texte de forme libre. À utiliser pour les listes d'éléments de texte, tels que des faits ou des exigences.
`InputNumeric`	Une plage numérique. Utilisez pour les évaluations ou les scores numériques.

Type d’entrée	Description et utilisation
`InputCategorical`	Un menu déroulant à sélection unique. Utilisez pour des options mutuellement exclusives, telles que les évaluations ou les classifications.
`InputCategoricalList`	Un menu déroulant à sélection multiple. Utiliser lorsque plusieurs options peuvent être sélectionnées.
`InputText`	Zone de texte libre. À utiliser lorsque la réponse est ouverte, comme pour des explications détaillées ou des commentaires personnalisés.
`InputTextList`	Plusieurs zones de texte de forme libre. À utiliser pour les listes d'éléments de texte, tels que des faits ou des exigences.
`InputNumeric`	Une plage numérique. Utilisez pour les évaluations ou les scores numériques.

`InputCategorical`

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

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

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

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

Python
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

Exemples complets

Évaluation du service client

Voici un exemple complet d'évaluation des réponses du service clients :

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

Examen des informations médicales

Exemple d'évaluation des réponses d'informations médicales :

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

Intégration avec les sessions d'étiquetage

L’exemple suivant montre comment utiliser vos schémas dans une session d’étiquetage :

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

Bonnes pratiques

Conception de schéma

Rédigez des questions sous forme de prompts clairs et spécifiques.
Fournir le contexte pour guider les relecteurs.
Définissez des limites raisonnables pour la longueur du texte et le nombre de listes.
Pour les entrées catégorielles, assurez-vous que les options sont mutuellement exclusives et exhaustives.

Gestion des schémas

Utilisez des noms descriptifs et cohérents pour tous vos schémas.
Lors de la mise à jour des schémas, tenez compte de l'impact sur les sessions existantes.
Supprimez les schémas inutilisés pour garder votre Workspace organisé.

Ressources supplémentaires

Étiqueter les traces existantes — appliquez vos schémas pour recueillir des commentaires structurés
Créer des sessions d'étiquetage – Organiser les workflows de révision à l'aide de vos schémas
Créez des datasets d'évaluation – Transformez les données étiquetées en datasets de test

Fonctionnement des schémas d'étiquetage​

Schémas d'étiquetage pour les juges LLM intégrés​

Exemples de schémas d'étiquetage pour les juges LLM intégrés​

Créer des schémas d'étiquetage personnalisés​

Créer des schémas personnalisés à l'aide de l'interface utilisateur​

Créez des schémas personnalisés à l'aide de l'API​

Exemple de schéma de base​

Exemple de retour d'information pour le schéma personnalisé​

Exemple d'attente de schéma personnalisé​

Gérer les schémas d’étiquetage​

Lister les schémas​

Mettre à jour les schémas​

Supprimer les schémas​

Types d'entrée pour les schémas personnalisés​

InputCategorical​

InputCategoricalList​

InputText​

InputTextList​

InputNumeric​

Exemples complets​

Évaluation du service client​

Examen des informations médicales​

Intégration avec les sessions d'étiquetage​

Bonnes pratiques​

Conception de schéma​

Gestion des schémas​

Ressources supplémentaires​