Évaluer les jeux de données de conversation avec Microsoft Foundry SDK

Évaluez des conversations complètes issues de jeux de données, à l’échelle du tour ou de la conversation.

Prerequisites

Les exemples utilisent le client sdk configuré dans Configurer le client sdk.

Évaluer les jeux de données de conversation

Évaluez les conversations complètes pour évaluer la qualité de l’agent dans l’ensemble des interactions utilisateur , pas seulement les réponses individuelles. Utilisez l’évaluation à l’échelle de la conversation pour identifier des problèmes de qualité tels que la résolution incomplète des tâches, la frustration des utilisateurs et les régressions dans les appels aux outils, qui échappent à l’évaluation au niveau des tours.

Par exemple, prenons le cas d’un agent d’assistance où l’utilisateur se montre de plus en plus frustré au fil de plusieurs échanges :

Tour 1 — Utilisateur : « J’ai besoin de réinitialiser mon mot de passe ». Agent : « J’ai trouvé votre compte. Je vais envoyer un lien de réinitialisation.

Tour 2 — Utilisateur : « Je n’ai pas reçu l’e-mail. » Agent : « J’ai renvoyé le lien. » Vérifiez le courrier indésirable.

Tour 3 — Utilisateur : « Toujours rien. Pouvez-vous simplement le réinitialiser directement ? Agent : « J’ai envoyé un autre lien de réinitialisation ».

Un évaluateur au niveau du tour n’attribue une note qu’à la dernière réponse (qui est polie et exécute une action), si bien qu’elle obtient une bonne note. Un évaluateur à l’échelle de l’ensemble de la conversation, chargé d’évaluer la satisfaction client sur l’ensemble de la conversation, signale que l’agent a répété trois fois la même action inefficace sans tenter d’autre approche, laissant le problème de l’utilisateur sans solution.

L’évaluation à l’échelle de la conversation diffère de l’évaluation à l’échelle du tour de parole à plusieurs égards :

Aspect Au niveau du tour Niveau de la conversation
Étendue Paires requête-réponse individuelles Mener à bien des conversations avec plusieurs échanges
Metrics Qualité et sécurité pour chaque réponse Résultats au niveau de la conversation et satisfaction des utilisateurs
Format de données JSONL avec query et response champs JSONL avec messages tableau contenant la conversation complète
Cas d’utilisation Test des réponses de modèle individuel Test des expériences des agents de bout en bout

Choisissez le flux de travail de conversation qui correspond à votre source de données :

Workflow Quand utiliser Type de source de données
À partir d’un jeu de données ou d’une ligne Vous disposez de traces de conversation locales ou de données de test jsonl avec file_id ou file_content
Conversations publiées Vous souhaitez évaluer des conversations spécifiques ou un trafic de production échantillonné à partir d’Application Insights azure_ai_trace_data_source_preview avec trace_source
Conversations simulées Vous souhaitez générer des conversations de test synthétiques azure_ai_user_conversation_simulation

Choisir un niveau d’évaluation

Le paramètre evaluation_level du run détermine si les évaluateurs évaluent des tours de dialogue individuels ou des conversations complètes :

Value Behavior
"turn" Les évaluateurs notent chaque tour indépendamment.
"conversation" Les évaluateurs notent toute la conversation dans son ensemble.
(omis) La valeur par défaut est "turn".

Important

Compatibilité de l’évaluateur : chaque évaluateur prend en charge des niveaux d’évaluation spécifiques. Vérifiez le champ supported_evaluation_levels de l’évaluateur dans les niveaux d’évaluation.

  • Les évaluateurs limités au tour (par exemple, builtin.fluency, builtin.relevance) ne s’exécutent pas avec evaluation_level="conversation". Si un évaluateur ne prend pas en charge l’évaluation au niveau de la conversation, le service ignore cet évaluateur au lieu de faire échouer l’exécution de l’évaluation.

  • Évaluateurs qui prennent en charge l’évaluation au niveau de la conversation : les évaluateurs intégrés suivants prennent en charge à la fois l’évaluation au niveau du tour (à tour unique) et l’évaluation au niveau de la conversation (multitour) :

    • builtin.output_quality
    • builtin.tool_use_quality
    • builtin.deflection_rate
    • builtin.customer_satisfaction
    • builtin.task_completion
    • builtin.coherence
    • builtin.groundedness

    builtin.output_quality et builtin.tool_use_quality sont des évaluateurs composites, qui évaluent plusieurs dimensions de qualité.

  • Pour l’évaluation au niveau du tour, tous les évaluateurs intégrés, sauf builtin.document_retrieval et le builtin.quality_grader déconseillé, prennent en charge le format d’entrée messages. Les évaluateurs Azure OpenAI label_model, python_grader, score_model, string_check et text_similarity ne prennent pas en charge le format d’entrée messages.

Erreurs courantes

Error Cause Solution
L’évaluateur est ignoré Utilisation evaluation_level="conversation" avec un évaluateur qui ne prend pas en charge l’évaluation au niveau de la conversation Utiliser un évaluateur au niveau de la conversation, ou passer à evaluation_level="turn" si vous en avez besoin

Préparer les données de conversation

Créez un fichier JSONL dans lequel chaque ligne contient une conversation complète dans le messages champ. Chaque message doit inclure un role (utilisateur, assistant ou système) et content. Pour obtenir un exemple complet, consultez les exemples d’évaluation conversation dans le Kit de développement logiciel (SDK).

 {"messages": [{"role": "user", "content": "What's my account balance?"}, {"role": "assistant", "content": "Your current balance is $1,234.56."}, {"role": "user", "content": "Thanks!"}, {"role": "assistant", "content": "You're welcome! Is there anything else?"}]}

Vous pouvez également inclure des définitions d’outils et des appels d’outils si votre agent utilise des outils :

{"messages": [{"role": "user", "content": "What is the capital/major city of France?"}, {"role": "assistant", "content": "Paris"}]}
{"messages": [{"role": "user", "content": "How do I reverse a string in Python?"}, {"role": "assistant", "content": "You can reverse a string in Python by using slicing: string[::-1]"}]}
{"messages": [{"role": "user", "content": "What are the main causes of climate change?"}, {"role": "assistant", "content": "The main causes of climate change are the increase in greenhouse gases in the atmosphere, primarily due to human activities such as burning fossil fuels and deforestation."}]}
{"messages": [{"role": "user", "content": "What's my account balance?"}, {"role": "assistant", "content": null, "tool_calls": [{"id": "call_abc123", "type": "function", "function": {"name": "get_account_balance", "arguments": "{\"account_id\": \"ACCT-7890\"}"}}]}, {"role": "tool", "tool_call_id": "call_abc123", "content": "{ \"balance\": 1234.56, \"currency\": \"USD\" }"}, {"role": "assistant", "content": "Your current balance is 1,234.56."}, {"role": "user", "content": "Thanks!"}, {"role": "assistant", "content": "You're welcome! Is there anything else?"}], "tool_definitions": [{"name": "get_account_balance", "description": "Retrieves the current balance for a customer account", "parameters": {"type": "object", "properties": {"account_id": {"type": "string"}}, "required": ["account_id"]}}]}
{"messages": [{"role": "user", "content": "Explain the theory of relativity in simple terms."}, {"role": "assistant", "content": "Einstein's theory of relativity shows that space and time are interconnected and relative to the observer's frame of reference."}]}
{"messages": [{"role": "user", "content": "What's the weather in Seattle?"}, {"role": "assistant", "content": null, "tool_calls": [{"id": "call_002", "type": "function", "function": {"name": "get_weather", "arguments": "{\"location\": \"Seattle, WA\"}"}}]}, {"role": "tool", "tool_call_id": "call_002", "content": "{ \"temperature\": 55, \"condition\": \"Cloudy\" }"}, {"role": "assistant", "content": "It's currently 55F and cloudy in Seattle."}], "tool_definitions": [{"name": "get_weather", "description": "Get the current weather for a location", "parameters": {"type": "object", "properties": {"location": {"type": "string"}}, "required": ["location"]}}]}
{"messages": [{"role": "user", "content": "What is the tallest mountain in the world?"}, {"role": "assistant", "content": "Mount Everest is the tallest mountain in the world."}]}
{"messages": [{"role": "user", "content": "Is 4 x 2 = 16?"}, {"role": "assistant", "content": "No, 4 x 2 = 8."}]}
{"messages": [{"role": "user", "content": "What is the best Italian desert?"}, {"role": "assistant", "content": "Tiramisu is a popular Italian dessert."}]}
{"messages": [{"role": "user", "content": "What is the chemical formula for water?"}, {"role": "assistant", "content": "The chemical formula for water is H2O."}]}

Définir le schéma de données et les évaluateurs

Spécifiez le schéma de vos données de conversation et sélectionnez les évaluateurs conçus pour l’évaluation au niveau de la conversation. Associez messages à chaque évaluateur. Pour les évaluateurs qui évaluent le comportement de l’outil, associez également tool_definitions. Les évaluateurs au niveau de la conversation évaluent l’ensemble de l’interaction plutôt que les tournures individuelles.

pip install "azure-ai-projects>=2.2.0"

import os
from openai.types.eval_create_params import DataSourceConfigCustom
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import TestingCriterionAzureAIEvaluator

endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]
model_deployment_name = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):
    data_source_config = DataSourceConfigCustom(
        type="custom",
        item_schema={
            "type": "object",
            "properties": {
                "messages": {"type": "array"},
                "tool_definitions": {"type": "array"},
            },
            "required": ["messages"],
        },
        include_sample_schema=False,
    )

    testing_criteria = [
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="output_quality",
            evaluator_name="builtin.output_quality",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={
                "messages": "{{item.messages}}",
                "tool_definitions": "{{item.tool_definitions}}",
            },
        ),
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="tool_use_quality",
            evaluator_name="builtin.tool_use_quality",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={
                "messages": "{{item.messages}}",
                "tool_definitions": "{{item.tool_definitions}}",
            },
        ),
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="deflection_rate",
            evaluator_name="builtin.deflection_rate",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={
                "messages": "{{item.messages}}",
                "tool_definitions": "{{item.tool_definitions}}",
            },
        ),
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="customer_satisfaction",
            evaluator_name="builtin.customer_satisfaction",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={"messages": "{{item.messages}}"},
        ),
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="task_completion",
            evaluator_name="builtin.task_completion",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={"messages": "{{item.messages}}"},
        ),
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="coherence",
            evaluator_name="builtin.coherence",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={"messages": "{{item.messages}}"},
        ),
        TestingCriterionAzureAIEvaluator(
            type="azure_ai_evaluator",
            name="groundedness",
            evaluator_name="builtin.groundedness",
            initialization_parameters={"model": model_deployment_name},
            data_mapping={"messages": "{{item.messages}}"},
        ),
    ]

Créer une évaluation et exécuter

Téléchargez sample_data_multiturn_conversations.jsonl avant d’exécuter l’exemple.

from openai.types.evals.create_eval_jsonl_run_data_source_param import (
    CreateEvalJSONLRunDataSourceParam,
    SourceFileID,
)

# Upload conversation data
data_id = project_client.datasets.upload_file(
    name="multiturn-conversation-data",
    version="1",
    file_path="./sample_data_multiturn_conversations.jsonl",
).id

# Create the evaluation
eval_object = openai_client.evals.create(
    name="Multi-turn Conversation Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

# Create a run with evaluation_level set to "conversation"
eval_run = openai_client.evals.runs.create(
    eval_id=eval_object.id,
    name="multiturn-conversation-run",
    data_source=CreateEvalJSONLRunDataSourceParam(
        type="jsonl",
        source=SourceFileID(
            type="file_id",
            id=data_id,
        ),
    ),
    extra_body={"evaluation_level": "conversation"},
)

Pour vérifier si l’opération est terminée et interpréter les résultats, consultez Obtenir les résultats de l’évaluation dans le cloud.

Pour obtenir un exemple d’exécution complet, consultez sample_multiturn_conversation_evaluation.py sur GitHub.

Étapes suivantes

  • Dernière mise à jour :