Démonstration de 10 minutes : Collecter des commentaires humains

Ce tutoriel montre comment collecter des commentaires des utilisateurs finaux, ajouter des annotations de développeur, créer des sessions de révision d’experts et utiliser ces commentaires pour évaluer la qualité de votre application GenAI.

Ce que vous réaliserez

À la fin de ce tutoriel, vous allez :

• Instrumenter une application GenAI en utilisant le suivi MLflow
• Collecter les commentaires des utilisateurs finaux, simulés à l’aide du Kit de développement logiciel (SDK) dans cet exemple
• Ajouter des commentaires de développeur de manière interactive via l’interface utilisateur
• Afficher les commentaires en même temps que vos traces
• Collecter des avis d'experts en créant une session de classification pour une analyse structurée par des experts.

Configuration de l’environnement

Installez les packages requis :

• mlflow[databricks]: Utilisez la dernière version de MLflow pour obtenir plus de fonctionnalités et d’améliorations.
• openai: cette application utilise le client d’API OpenAI pour appeler des modèles hébergés par Databricks.

%pip install -q --upgrade "mlflow[databricks]>=3.1.0" openai
dbutils.library.restartPython()

Créez une expérience MLflow. Si vous utilisez un notebook Databricks, vous pouvez ignorer cette étape et utiliser l'expérience par défaut du notebook. Sinon, suivez le guide de démarrage rapide de l’installation de l’environnement pour créer l’expérience et vous connecter au serveur MLflow Tracking.

Étape 1 : Créer et suivre une application simple

Commencez par créer une application GenAI simple à l’aide d’un LLM avec le suivi MLflow. L’application utilise l’API OpenAI pour appeler un point de terminaison Foundation Model hébergé par Databricks.

from databricks.sdk import WorkspaceClient
import mlflow

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

# Create an OpenAI client that is connected to Databricks-hosted LLMs.
w = WorkspaceClient()
client = w.serving_endpoints.get_open_ai_client()

# 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-3-7-sonnet",  # 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 an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for experiment tracking, model packaging, and deployment."
    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}")

Response: MLflow is an open-source platform designed to manage the complete machine learning lifecycle. It provides tools and functionality for tracking experiments, packaging models, and deploying machine learning solutions. As a comprehensive platform, MLflow helps data scientists and machine learning engineers organize their work, compare results, and streamline the process of moving models from development to production.
Trace ID: tr-88989bb65dcb9bf49e0d03a3d5a302c9

Étape 2 : Collecter 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 haut/bas. Ce guide de démarrage rapide simule un utilisateur final qui donne des commentaires négatifs directement à l’aide du Kit de développement logiciel (SDK).

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

End-user feedback recorded!

Étape 3 : Afficher les commentaires dans l’interface utilisateur

Lancez l’interface utilisateur MLflow pour afficher vos traces avec des commentaires :

1. Accédez à votre expérience MLflow.
2. Accédez à l’onglet Journaux .
3. Cliquez sur votre trace.
4. La boîte de dialogue Détails de la trace s’affiche. Sous Évaluations sur le côté droit de la fenêtre de dialogue, l’indicateur user_feedback montre false, indiquant que l’utilisateur a donné une réaction négative à la réponse.

Étape 4 : Ajouter 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 Journaux, cliquez sur une trace pour l’ouvrir.
2. Cliquez sur toute étendue. (Choisissez l’étendue racine pour les commentaires au niveau de la trace.)
3. Dans l’onglet Évaluations à droite, cliquez sur Ajouter une nouvelle évaluation et renseignez les éléments 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.

Une fois la page actualisée, les colonnes des nouvelles évaluations apparaissent dans la table Journaux.

Étape 5 : Envoyer la trace pour l’examen d’experts

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

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

Les réviseurs experts peuvent désormais effectuer les opérations suivantes :

1. Ouvrez l’URL de l’application de révision.

2. Consultez votre trace avec la question et la réponse (y compris les commentaires des utilisateurs finaux).

3. Évaluez si la réponse est réellement exacte.

4. Fournissez la réponse correcte à expected_response la question « Qu’est-ce que MLflow ? » :

   MLflow is an open-source platform for managing the machine learning lifecycle, including experiment tracking, model registry, packaging, deployment, and evaluation. It supports classical ML, deep learning, and generative AI workflows. On Databricks, MLflow provides managed, secure, and scalable integration for easy collaboration and governance
   

5. Soumettez leurs évaluations d’experts en tant que vérité terrain.

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

1. Sur la page Expérience, cliquez sur l’onglet Étiquetage.
2. À gauche, utilisez les onglets Sessions et Schémas pour ajouter un nouveau schéma d’étiquette et créer une session.

Étape 6 : Utiliser les commentaires pour évaluer votre application

Une fois que les experts fournissent des commentaires, utilisez leurs expected_response étiquettes pour évaluer votre application avec le scorer de Correctness MLflow :

Cet exemple utilise directement les traces pour l’évaluation. Dans votre application, Databricks recommande d’ajouter des traces étiquetées à un jeu de données d’évaluation MLflow qui fournit le suivi des versions et la traçabilité. Découvrez comment créer des jeux de données d’évaluation.

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 d'exactitude compare les résultats de votre application aux résultats fournis par les experts expected_response, vous donnant ainsi des commentaires quantitatifs sur l'alignement avec les attentes des experts.

Étapes suivantes

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

• Étiquette pendant le développement - Découvrir les techniques avancées d’annotation pour le développement
• Vibe check with domain experts - Tester votre application de manière interactive avec des experts
• Collecter des commentaires d’experts de domaine - Configurer des processus de révision systématique d’experts

Exemple de notebook

Démonstration de 10 minutes : Collecter des commentaires humains

Obtenir un ordinateur portable