Aller au contenu principal
Dernière mise à jour le

Évaluer les conversations

L'évaluation des conversations vous permet d'évaluer des sessions de conversation entières plutôt que des tours individuels. Ceci est essentiel pour évaluer les systèmes d'IA conversationnels où la qualité émerge au fil de multiples interactions, tels que les schémas de frustration des utilisateurs, l'exhaustivité de la conversation ou la cohérence globale du dialogue.

Les juges multi-tours peuvent être utilisés à la fois pour l'évaluation hors ligne pendant le développement (comme décrit sur cette page) et pour le monitoring continu en production.

remarque

L’évaluation multi-tours est expérimentale. L'API et le comportement pourraient changer dans les futures versions.

Prérequis​

Installez MLflow 3.10.0 ou version ultérieure :

Bash
pip install --upgrade 'mlflow[databricks]>=3.10'

Votre agent doit être instrumenté pour suivre les ID de session sur les traces. Consultez Suivre les utilisateurs et les sessions pour savoir comment définir les ID de session sur vos traces.

Deux approches​

MLflow prend en charge deux approches pour l'évaluation des conversations :

  • Évaluer les conversations pré-générées : Évaluez les conversations existantes qui ont déjà été tracées. Utilisez cette approche lorsque vous avez :

    • Données de conversation de production à analyser
    • Conversations de test préenregistrées issues d'études QA ou d'utilisateurs
    • Conversations d'une version précédente de l'agent pour comparaison

  • Simuler des conversations pendant l'évaluation : générez de nouvelles conversations en simulant les interactions des utilisateurs avec votre agent. Utilisez cette approche lorsque vous souhaitez :

    • Testez systématiquement une nouvelle version d'agent avec des scénarios cohérents
    • Générer des scénarios de test diversifiés à grande échelle
    • Mettez à l'épreuve votre agent avec des comportements d'utilisateur spécifiques et des cas limites.

Pourquoi évaluer au niveau de la session ?​

L'évaluation traditionnelle à un tour évalue chaque réponse d'agent indépendamment. Cependant, les agents conversationnels nécessitent une évaluation au niveau de la session pour capturer :

  • Frustration de l'utilisateur : L'utilisateur est-il devenu frustré ? A-t-il été résolu ?
  • Exhaustivité de la conversation : toutes les questions des utilisateurs ont-elles été répondues à la fin de la conversation ?
  • **Rétention des connaissances** : L'agent se souvient-il des informations des conversations précédentes ?
  • Cohérence du dialogue : la conversation est-elle fluide ?

L'évaluation multi-tour répond à ces besoins en regroupant les traces en sessions de conversation et en appliquant des juges qui analysent l'historique complet de la conversation.

Évaluer les conversations pré-générées​

Évaluez les conversations qui ont déjà été tracées. Ceci est utile pour évaluer les données de production ou les conversations de test pré-enregistrées.

Étape 1 : Baliser les traces avec des identifiants de session​

Lors de la création de votre agent, définissez les ID de session sur les traces pour les regrouper en conversations :

Python
import mlflow

@mlflow.trace
def my_chatbot(question, session_id):
    mlflow.update_current_trace(
        tags={"mlflow.trace.session": session_id}
    )
    # ... your chatbot logic

Pour une documentation complète sur le suivi des sessions, consultez Suivre les utilisateurs et les sessions.

Étape 2 : récupérer et évaluer les sessions​

Obtenez les traces de votre Expérimentation et transmettez-les à mlflow.genai.evaluate. MLflow regroupe automatiquement les traces par ID de session :

Python
from mlflow.genai.scorers import ConversationCompleteness, UserFrustration

# Get traces from your experiment
traces = mlflow.search_traces(
    filter_string="attributes.status = 'OK'",
    return_type="list",
)

# Evaluate the conversations
# MLflow automatically groups traces by their session ID tag
results = mlflow.genai.evaluate(
    data=traces,
    scorers=[
        ConversationCompleteness(),  # Did the agent answer all questions?
        UserFrustration(),           # Did the user become frustrated?
    ],
)

Vous pouvez également récupérer des sessions complètes directement à l'aide de mlflow.search_sessions:

Python
import mlflow

# Get complete sessions (each session is a list of traces)
sessions = mlflow.search_sessions(
    locations=["<your-experiment-id>"],
    max_results=50,
)

# Flatten for evaluation
all_traces = [trace for session in sessions for trace in session]

results = mlflow.genai.evaluate(
    data=all_traces,
    scorers=[ConversationCompleteness(), UserFrustration()],
)

Simuler des conversations pendant l'évaluation​

Générez de nouvelles conversations en simulant les interactions utilisateur. Cela permet de tester différentes versions d’agent avec des objectifs et des personas cohérents.

Python
import mlflow
from mlflow.genai.simulators import ConversationSimulator
from mlflow.genai.scorers import ConversationCompleteness, Safety

# Define test scenarios
simulator = ConversationSimulator(
    test_cases=[
        {"goal": "Successfully set up experiment tracking"},
        {"goal": "Identify the root cause of a deployment error"},
        {
            "goal": "Understand how to implement model versioning",
            "persona": "You are a beginner who needs detailed explanations",
        },
    ],
    max_turns=5,
)


# Your agent's predict function
def predict_fn(input: list[dict], **kwargs) -> str:
    # input is the conversation history
    response = your_agent.chat(input)
    return response


# Simulate conversations and evaluate
results = mlflow.genai.evaluate(
    data=simulator,
    predict_fn=predict_fn,
    scorers=[
        ConversationCompleteness(),
        Safety(),
    ],
)

Pour une documentation complète sur la simulation de conversation, y compris la définition des cas de test, les interfaces de fonction de prédiction et les options de configuration, consultez Simulation de conversation.

Juges multi-tours​

Juges intégrés​

MLflow fournit des juges multitours intégrés pour évaluer la qualité des conversations. Pour la liste complète et la documentation détaillée, consultez la documentation sur les évaluateurs prédéfinis de MLflow et la page Évaluateurs et juges LLM.

Juges personnalisés​

Créez des juges personnalisés multitours à l’aide de make_judge. Utilisez la variable de template {{ conversation }} pour accéder à l’historique complet de la conversation :

Python
from mlflow.genai.judges import make_judge
from typing import Literal

# Create a custom multi-turn judge
politeness_judge = make_judge(
    name="politeness",
    instructions=(
        "Evaluate whether the assistant maintained a polite and professional "
        "tone throughout this conversation:\n\n{{ conversation }}\n\n"
        "Rate as 'consistently_polite', 'mostly_polite', or 'impolite'."
    ),
    feedback_value_type=Literal["consistently_polite", "mostly_polite", "impolite"],
)

# Get traces from your experiment
traces = mlflow.search_traces(
    filter_string="attributes.status = 'OK'",
    return_type="list",
)

# Use in evaluation
results = mlflow.genai.evaluate(
    data=traces,
    scorers=[politeness_judge],
)

La variable {{ conversation }} injecte l'historique complet de la conversation dans un format lisible pour que le juge l'analyse.

remarque

La variable {{ conversation }} ne peut être utilisée qu'avec {{ expectations }}, et non avec {{ inputs }}, {{ outputs }} ou {{ trace }}.

Comment les évaluations sont stockées​

Les évaluations multi-tours sont stockées sur la première trace (chronologiquement) dans chaque session. Cette conception garantit ce qui suit :

  • Les évaluations restent stables même lorsque de nouveaux tours sont ajoutés à une conversation
  • Vous pouvez facilement trouver les évaluations au niveau de la conversation en examinant les traces de start de session
  • L'interface utilisateur des sessions peut afficher efficacement les métriques de conversation.

Les évaluations incluent des métadonnées les identifiant comme étant de niveau conversationnel :

  • session_id: L'ID de session liant l'évaluation à la conversation complète

Travail avec des sessions spécifiques​

Pour évaluer une session spécifique, utilisez mlflow.search_traces avec une chaîne de filtre :

Python
import mlflow
from mlflow.genai.scorers import ConversationCompleteness, UserFrustration

# Get traces for a specific session using filter
traces = mlflow.search_traces(
    filter_string="tags.`mlflow.trace.session` = '<your-session-id>'",
    return_type="list",
)

# Evaluate the session
results = mlflow.genai.evaluate(
    data=traces,
    scorers=[ConversationCompleteness(), UserFrustration()],
)

Ressources supplémentaires​

Sur cette page