Aller au contenu principal
Dernière mise à jour le

Démo de 10 minutes : Collecter le feedback humain

Ouvrir dans Databricks

Ce tutoriel montre comment recueillir le feedback de l'utilisateur final, ajouter des annotations de développeur, créer des sessions d'évaluation par des experts et utiliser ce feedback pour évaluer la qualité de votre application GenAI.

Ce que vous réaliserez​

À la fin de ce tutoriel, vous serez en mesure de :

  • Instrumenter une application GenAI avec le traçage MLflow
  • Recueillir les commentaires des utilisateurs finaux, simulés à l'aide du SDK dans cet exemple
  • Ajoutez les retours des développeurs de manière interactive via l'interface utilisateur.
  • Afficher les retours à côté de vos traces
  • Recueillez les retours d'experts en créant une session d'étiquetage pour un examen structuré par un expert.

Configuration de l'environnement​

Installez les packages requis :

  • mlflow[databricks]Utilisez la dernière version de MLflow pour obtenir davantage de fonctionnalités et d'améliorations.
  • openai: Cette application utilisera le client de l'API OpenAI pour appeler les modèles hébergés par Databricks.
Python
%pip install -q --upgrade "mlflow[databricks]>=3.1.0" databricks-openai
dbutils.library.restartPython()

Créez une Experimentation MLflow. Si vous utilisez un Notebook Databricks, vous pouvez ignorer cette étape et utiliser l'Experimentation Notebook par default. Sinon, suivez le guide de démarrage rapide de la configuration de l'environnement pour créer l'Experimentation et vous connecter au serveur MLflow Tracking.

Étape 1 : créer et tracer une application simple​

Tout d'abord, créez une application GenAI simple à l'aide d'un LLM avec le traçage MLflow. L’application utilise l’API OpenAI pour appeler un endpoint de modèle de fondation hébergé par Databricks.

Python
from databricks_openai import DatabricksOpenAI
import mlflow

# Enable automatic tracing for the OpenAI client
mlflow.openai.autolog()

# Create an OpenAI client that is connected to Databricks-hosted LLMs.
client = DatabricksOpenAI()

# Create a RAG app with tracing
@mlflow.trace
def my_chatbot(user_question: str) -> str:
    # Retrieve relevant context
    context = retrieve_context(user_question)

    # Generate response using LLM with retrieved context
    response = client.chat.completions.create(
        model="databricks-claude-sonnet-4",  # If using OpenAI directly, use "gpt-4o" or "gpt-3.5-turbo"
        messages=[
            {"role": "system", "content": "You are a helpful assistant. Use the provided context to answer questions."},
            {"role": "user", "content": f"Context: {context}\n\nQuestion: {user_question}"}
        ],
        temperature=0.7,
        max_tokens=150
    )
    return response.choices[0].message.content

@mlflow.trace(span_type="RETRIEVER")
def retrieve_context(query: str) -> str:
    # Simulated retrieval. In production, this could search a vector database
    if "mlflow" in query.lower():
        return "MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models. MLflow enables teams of all sizes to debug, evaluate, monitor, and optimize their AI applications while controlling costs and managing access to models and data. With over 30 million monthly downloads, thousands of organizations rely on MLflow each day to ship AI to production with confidence."
    return "General information about machine learning and data science."

# Run the app to generate a trace
response = my_chatbot("What is MLflow?")
print(f"Response: {response}")

# Get the trace ID for the next step
trace_id = mlflow.get_last_active_trace_id()
print(f"Trace ID: {trace_id}")

Étape 2 : Recueillir les commentaires des utilisateurs finaux​

Lorsque les utilisateurs interagissent avec votre application, ils peuvent fournir des commentaires via des éléments d’interface utilisateur tels que des boutons J'aime/Je n'aime pas. Ce démarrage rapide simule un utilisateur final donnant des commentaires négatifs en utilisant directement le SDK.

Python
from mlflow.entities.assessment import AssessmentSource, AssessmentSourceType

# Simulate end-user feedback from your app
# In production, this could be triggered when a user clicks thumbs down in your UI
mlflow.log_feedback(
    trace_id=trace_id,
    name="user_feedback",
    value=False,  # False for thumbs down - user is unsatisfied
    rationale="Missing details about MLflow's key features like Projects and Model Registry",
    source=AssessmentSource(
        source_type=AssessmentSourceType.HUMAN,
        source_id="enduser_123",  # In production, this is the actual user ID
    ),
)

print("End-user feedback recorded!")

# In a real app, you could:
# 1. Return the trace_id with your response to the frontend
# 2. When user clicks thumbs up/down, call your backend API
# 3. Your backend calls mlflow.log_feedback() with the trace_id

Étape 3 : Afficher les commentaires dans l'interface utilisateur​

Lancez l’interface utilisateur MLflow pour consulter vos traces avec les retours :

  1. Accédez à votre expérience MLflow.
  2. Accédez à l'onglet Logs .
  3. Cliquez sur votre trace.
  4. La boîte de dialogue des détails de la trace s'affiche. Sous Évaluations , sur le côté droit de la boîte de dialogue, le user_feedback affiche false, indiquant que l'utilisateur a marqué la réponse d'un pouce vers le bas.

Évaluation humaine

Étape 4 : ajoutez des annotations de développeur à l'aide de l'interface utilisateur​

En tant que développeur, vous pouvez également ajouter vos propres commentaires et notes directement dans l'interface utilisateur :

  1. Dans l'onglet **Logs**, cliquez sur une trace pour l'ouvrir.

  2. Cliquez sur n’importe quel span (choisissez le span racine pour les retours au niveau de la trace).

  3. Dans l’onglet Évaluations à droite, cliquez sur Ajouter une nouvelle évaluation et renseignez les champs suivants :

    • Type : Feedback.
    • Nom : accuracy_score.
    • Valeur : .75.
    • Justification : This answer includes the core elements of ML lifecycle management, experiment tracking, packaging, and deployment. However, it does not mention the model registry, project packaging, integration with Generative AI and LLMs, or unique features available in Databricks-managed MLflow, which are now considered essential to a complete description of the platform.

  4. Cliquez sur Créer .

Après avoir refresh la page, les colonnes des nouvelles évaluations apparaissent dans la table Logs.

Étape 5 : Envoyer la trace pour examen par des experts​

Les commentaires négatifs des utilisateurs finaux de l'Étape 2 signalent un problème de qualité potentiel, mais seuls les experts du domaine peuvent confirmer s'il y a réellement un problème et fournir la bonne réponse. Créez une session d’étiquetage pour obtenir un avis d'experts faisant autorité :

Python
from mlflow.genai.label_schemas import create_label_schema, InputCategorical, InputText
from mlflow.genai.labeling import create_labeling_session

# Define what feedback to collect
accuracy_schema = create_label_schema(
    name="response_accuracy",
    type="feedback",
    title="Is the response factually accurate?",
    input=InputCategorical(options=["Accurate", "Partially Accurate", "Inaccurate"]),
    overwrite=True
)

ideal_response_schema = create_label_schema(
    name="expected_response",
    type="expectation",
    title="What would be the ideal response?",
    input=InputText(),
    overwrite=True
)

# Create a labeling session
labeling_session = create_labeling_session(
    name="quickstart_review",
    label_schemas=[accuracy_schema.name, ideal_response_schema.name],
)

# Add your trace to the session
# Get the most recent trace from the current experiment
traces = mlflow.search_traces(
    max_results=1  # Gets the most recent trace
)
labeling_session.add_traces(traces)

# Share with reviewers
print(f"Trace sent for review!")
print(f"Share this link with reviewers: {labeling_session.url}")

Utilisez l'application d'examen.

Les examinateurs experts peuvent désormais faire ce qui suit :

  1. Ouvrez l'URL de l'application d'évaluation.

  2. Consultez votre trace avec la question et la réponse (y compris tout retour d’utilisateur final).

  3. Évaluez si la réponse est réellement précise.

  4. Veuillez fournir la réponse correcte en expected_response à la question « Qu'est-ce que MLflow ? » :

    MLflow is the largest open source AI engineering platform for agents, LLMs, and ML models. MLflow enables teams of all sizes to debug, evaluate, monitor, and optimize their AI applications while controlling costs and managing access to models and data. With over 30 million monthly downloads, thousands of organizations rely on MLflow each day to ship AI to production with confidence.

  5. Soumettez leurs évaluations d'experts comme vérité terrain.

Vous pouvez également utiliser l'interface utilisateur de MLflow 3 pour créer une session d'étiquetage, comme suit :

  1. Sur la page Experimentation, cliquez sur l’onglet tab .
  2. À gauche, utilisez les onglets **Sessions** et **Schemas** pour ajouter un nouveau schéma d'étiquette et créer une nouvelle session.

Comment créer une session d’étiquetage dans l’interface utilisateur

Étape 6 : Utiliser les retours pour évaluer votre application​

Une fois que les experts ont fourni des commentaires, utilisez leurs étiquettes expected_response pour évaluer votre application avec l'évaluateur Correctness de MLflow :

Cet exemple utilise directement les traces pour l'évaluation. Dans votre application, Databricks recommande d'ajouter des traces étiquetées à un dataset d'évaluation MLflow, qui fournit un suivi de version et une lignée. En savoir plus sur la création de datasets d'évaluation.

Python
from mlflow.genai.scorers import Correctness

# Get traces from the labeling session
labeled_traces = mlflow.search_traces(
    run_id=labeling_session.mlflow_run_id,  # Labeling Sessions are MLflow Runs
)

# Evaluate your app against expert expectations
eval_results = mlflow.genai.evaluate(
    data=labeled_traces,
    predict_fn=my_chatbot,  # The app we created in Step 1
    scorers=[Correctness()]  # Compares outputs to expected_response
)

L'évaluateur de justesse compare les sorties de votre application avec le expected_response fourni par les experts, ce qui vous donne un retour quantitatif sur l'alignement avec les attentes des experts.

Réponses attendues de l'évaluation humaine

Étapes suivantes​

En savoir plus sur la collecte de différents types de retours humains :

Exemple de Notebook​

Démo de 10 minutes : Recueillir le feedback humain

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks
Sur cette page