Les évaluateurs d’agents

Les agents IA sont des assistants de productivité puissants qui peuvent créer des flux de travail pour les besoins de l’entreprise. Toutefois, l’observabilité peut être un défi en raison de leurs modèles d’interaction complexes. Les évaluateurs d’agents fournissent une observabilité systématique dans les flux de travail agentiques en mesurant la qualité, la sécurité et les performances.

Un workflow d’agent implique généralement un raisonnement par le biais d’intentions utilisateur, l’appel d’outils pertinents et l’utilisation des résultats des outils pour effectuer des tâches telles que la mise à jour d’une base de données ou la rédaction d’un rapport. Pour créer des applications agentiques prêtes pour la production, vous devez évaluer non seulement la sortie finale, mais également la qualité et l’efficacité de chaque étape du flux de travail.

Foundry fournit des évaluateurs d’agents intégrés qui fonctionnent comme des tests unitaires pour les systèmes agentiques : ils prennent les messages de l’agent en tant que scores de pass/échec binaires d’entrée et de sortie (ou les scores mis à l’échelle convertis en scores binaires en fonction des seuils). Ces évaluateurs prennent en charge deux bonnes pratiques pour l’évaluation de l’agent :

• Évaluation du système : pour examiner les résultats de bout en bout du système agentique.
• Évaluation du processus : pour vérifier l’exécution pas à pas pour obtenir les résultats.

Évaluation du système

L’évaluation système examine la qualité du résultat final de votre flux de travail agentique. Ces évaluateurs s’appliquent aux agents uniques et, dans les systèmes multi-agents, à l’orchestrateur principal ou à l’agent final responsable de l’achèvement des tâches :

• Achèvement de la tâche : l’agent a-t-il entièrement terminé la tâche demandée ?
• Satisfaction des clients - Quelle est la satisfaction d’un utilisateur avec les performances de l’agent ?
• Respect des tâches : l’agent a-t-il suivi les règles et les contraintes dans ses instructions ?
• Efficacité de la navigation des tâches : l’agent a-t-il effectué efficacement les étapes attendues ?
• Résolution des intentions : l’agent a-t-il correctement identifié et traité les intentions de l’utilisateur ?

Plus précisément, pour les sorties textuelles des agents, vous pouvez également appliquer des évaluateurs de qualité RAG tels que Relevance et Groundedness qui prennent des entrées agentiques pour évaluer la qualité de la réponse finale.

Exemples :

• exemple d’achèvement Task (préversion)
• -échantillon d’adhésion au masque
• exemple d’efficacité de navigation Task
• exemple de résolution Intent

Évaluation du processus

L’évaluation des processus examine la qualité et l’efficacité de chaque étape de votre flux de travail agentique. Ces évaluateurs se concentrent sur les appels d’outils exécutés dans un système pour effectuer des tâches :

• Précision des appels de l’outil : l’agent a-t-il effectué les appels d’outil appropriés avec des paramètres corrects sans redondance ?
• Sélection de l’outil : l’agent a-t-il sélectionné les outils appropriés et nécessaires ?
• Précision de l’entrée de l’outil : l’agent a-t-il fourni des paramètres corrects pour les appels d’outil ?
• Utilisation de la sortie de l’outil : l’agent a-t-il correctement utilisé l’appel d’outil entraîne-t-il son raisonnement et sa réponse finale ?
• Réussite de l’appel de l’outil : les appels de l’outil ont-ils réussi sans erreurs techniques ?

Exemples :

• exemple de précision des appels Tool
• exemple de sélection Tool
• exemple de précision d’entrée Tool
• exemple d’utilisation de sortie Util
• exemple de réussite des appels Util

Évaluation de la qualité (déconseillée)

Quality Grader a évalué la qualité globale de la réponse d’un assistant IA au niveau du tour. Il a examiné plusieurs dimensions de la qualité de la réponse :

• Pertinence : la réponse est-elle pertinente pour la requête de l’utilisateur ?
• Abstention - L’agent s’abstene-t-il correctement lorsqu’il ne peut pas ou ne doit pas répondre ?
• Complétivité de la réponse : la réponse répond-elle entièrement à la question de l’utilisateur ?

Lorsque le contexte a été fourni, le gradeur de qualité a également évalué :

• Fondement - La réponse est-elle fondée dans le contexte fourni ?
• Couverture du contexte : la réponse utilise-t-elle les informations pertinentes dans le contexte ?

Évaluateurs composites (préversion)

Les évaluateurs composites mesurent plusieurs dimensions de qualité dans un appel de juge LLM. Utilisez-les pour réduire le coût et la latence d’exécution des évaluateurs intégrés correspondants séparément tout en conservant un score et une raison pour chaque dimension de qualité.

Qualité de sortie

L’évaluateur de qualité de sortie (builtin.output_quality) évalue la qualité de la réponse d’un agent et sa réussite dans la résolution de la tâche de l’utilisateur. Il traite les évaluateurs suivants en un appel de juge LLM :

Utilisation de l’outil Qualité

L’évaluateur Tool Use Quality (builtin.tool_use_quality) évalue le processus d’utilisation de l’outil d’un agent à partir de la sélection de l’outil à l’aide du résultat retourné. Il traite les évaluateurs suivants en un appel de juge LLM :

Résultats composites

Le résultat principal output_quality ou tool_use_quality le résultat passe uniquement lorsque chaque composant applicable passe. Un composant qui n’est pas applicable est ignoré et ne provoque pas l’échec du résultat principal. Si tous les composants sont ignorés, le résultat principal est not_applicable.

Chaque évaluateur composite retourne un résultat binaire principal et les résultats de ses évaluateurs de composants. Utilisez le résultat principal pour une porte de qualité stricte et utilisez les résultats du composant pour identifier la dimension de qualité qui a provoqué une défaillance.

Par exemple, un résultat de qualité de sortie échoue lorsque la fluidité, la cohérence, la résolution des intentions, l’adhésion aux tâches et la saisie semi-automatique des tâches échouent, mais échouent. L’identification output_quality_reason groundedness est le composant ayant échoué et explique groundedness_reason son score.

Configurer des évaluateurs composites

Les évaluateurs composites prennent en charge l’évaluation au niveau du tour et de la conversation. La forme d’entrée détermine le niveau d’évaluation par défaut :

• Mapper query et response pour l’évaluation au niveau du tour.
• Mapper messages pour l’évaluation au niveau de la conversation.

Définissez le paramètre turn d’initialisation evaluation_level sur ou conversation pour remplacer ce comportement.

La configuration suivante exécute les deux évaluateurs composites au niveau du tour. La réponse contient des messages d’agent avec des appels d’outils et des résultats d’outil, et les définitions d’outils décrivent les outils disponibles pour l’agent.

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "output_quality",
        "evaluator_name": "builtin.output_quality",
        "initialization_parameters": {
            "deployment_name": model_deployment,
            "evaluation_level": "turn",
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
            "tool_definitions": "{{item.tool_definitions}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "tool_use_quality",
        "evaluator_name": "builtin.tool_use_quality",
        "initialization_parameters": {
            "deployment_name": model_deployment,
            "evaluation_level": "turn",
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
            "tool_definitions": "{{item.tool_definitions}}",
        },
    },
]

Référence : Exécuter des évaluations à partir du Kit de développement logiciel (SDK)

Pour évaluer une conversation complète, mappez la conversation complète et messages omettez-la evaluation_level ou définissez-la sur conversation:

"initialization_parameters": {
    "deployment_name": model_deployment,
    "evaluation_level": "conversation",
},
"data_mapping": {
    "messages": "{{item.messages}}",
    "tool_definitions": "{{item.tool_definitions}}",
},

Référence : Messages avec appels d’outil

Prise en charge des modèles et des outils

Pour les évaluateurs assistés par l’IA, vous pouvez utiliser Azure modèles OpenAI ou OpenAI création et non-raisonnement pour le juge LLM.

Outils pris en charge

Les évaluateurs d’agent prennent en charge les outils suivants :

• Recherche de fichiers
• Outil de fonction (outils définis par l’utilisateur)
• MCP
• MCP basé sur les connaissances

Les outils suivants disposent actuellement d’une prise en charge limitée. Évitez d’utiliser tool_call_accuracy, tool input accuracy, tool_output_utilization, tool_call_successou groundedness évaluateurs si votre conversation de l’agent inclut des appels à ces outils :

• Recherche Azure AI
• Bing Grounding
• Recherche personnalisée Bing
• Fondamentaux de SharePoint
• Interpréteur de code
• Agent de données Fabric
• Web Search

Utilisation des évaluateurs d’agent

Les évaluateurs d’agents évaluent la façon dont les agents IA effectuent des tâches, suivent des instructions et utilisent efficacement des outils. Chaque évaluateur nécessite des mappages et des paramètres de données spécifiques :

L’évaluation au niveau du tour note une réponse individuelle de l’agent ; l’évaluation au niveau de la conversation note l’interaction complète. Permet evaluation_level de sélectionner le niveau lorsque l’évaluateur prend en charge les deux. Pour la structure des messages, consultez Messages avec des appels d’outil.

Exemple d’entrée

Votre jeu de données de test doit contenir les champs référencés dans vos mappages de données. Exemples pour le format ci-dessous :

{"query": "What's the weather in Seattle?", "response": "The weather in Seattle is rainy, 14°C."}
{"query": "Book a flight to Paris for next Monday", "response": "I've booked your flight to Paris departing next Monday at 9:00 AM."}
{"messages": [{"role": "user", "content": "Book a flight to Paris."}, {"role": "assistant", "content": "I booked your flight to Paris."}]}

Pour les interactions d’agent plus complexes avec les appels d’outils, utilisez des tableaux de messages pour query et response. Ces tableaux utilisent la même structure de messages OpenAI que le schéma préféré messages . Consultez le format de requête et de réponse distincts. Le message système est facultatif mais utile pour les évaluateurs qui évaluent le comportement de l’agent par rapport aux instructions, notamment task_adherence, , task_completiontool_call_accuracy, tool_selection, tool_input_accuracy, , tool_output_utilization, et groundedness:

{
    "query": [
        {"role": "system", "content": "You are a travel booking agent."},
        {"role": "user", "content": "Book a flight to Paris for next Monday"}
    ],
    "response": [
        {"role": "assistant", "content": [{"type": "tool_call", "tool_call_id": "call_123", "name": "search_flights", "arguments": {"destination": "Paris", "date": "next Monday"}}]},
        {"role": "tool", "tool_call_id": "call_123", "content": [{"type": "tool_result", "tool_result": {"flight": "AF123", "time": "9:00 AM"}}]},
        {"role": "assistant", "content": "I've booked flight AF123 to Paris departing next Monday at 9:00 AM."}
    ]
}

Format des définitions d’outils

Le tool_definitions champ décrit les outils disponibles pour l’agent. Il contient une liste d’objets d’outil avec un namedescriptionobjet , et JSON Schema parameters :

[
  {
    "name": "search_flights",
    "description": "Search for available flights to a destination on a given date.",
    "parameters": {
      "type": "object",
      "properties": {
        "destination": { "type": "string", "description": "The destination city." },
        "date": { "type": "string", "description": "The travel date in YYYY-MM-DD format." }
      },
      "required": ["destination", "date"]
    }
  }
]

Incluez cette liste en tant que champ dans votre jeu de données de test en même temps tool_definitions que query .response

Exemple de configuration

Syntaxe de mappage des données :

• {{item.field_name}}référence les champs de votre jeu de données de test (par exemple). {{item.query}}
• {{sample.output_items}} fait référence à la sortie structurée de l’agent, y compris les appels d’outils et les résultats. Utilisez-la pour les évaluateurs qui ont besoin d’un contexte d’interaction complet (task_adherence, tool_call_accuracy, tool_selection, tool_input_accuracy, tool_output_utilization).
• {{sample.output_text}} fait référence à la réponse de texte brut de l’agent. Utilisez-la pour les évaluateurs qui attendent une réponse de chaîne (par exemple, coherence, violence).

Voici un exemple de configuration pour l’adhésion aux tâches :

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "task_adherence",
        "evaluator_name": "builtin.task_adherence",
        "initialization_parameters": {"deployment_name": model_deployment},
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
]

Pour plus d’informations sur l’exécution des évaluations et la configuration des sources de données, consultez Exécuter des évaluations à partir du Kit de développement logiciel (SDK) pour plus d’informations sur l’exécution des évaluations et la configuration des sources de

Exemple de sortie

Les évaluateurs de l’agent retournent les résultats pass/échec avec le raisonnement. Champs de sortie clés :

{
    "type": "azure_ai_evaluator",
    "name": "Task Adherence",
    "metric": "task_adherence",
    "label": "pass",
    "reason": "Agent followed system instructions correctly",
    "threshold": 3,
    "passed": true
}

Pour les évaluateurs qui utilisent une échelle de 1 à 5 avant le seuil (par intent_resolutiontool_call_accuracyexemple), la sortie inclut un champ numérique score en même temps que le résultat de passage/échec :

{
    "type": "azure_ai_evaluator",
    "name": "Intent Resolution",
    "metric": "intent_resolution",
    "label": "pass",
    "score": 4,
    "reason": "Agent correctly identified the user's intent to book a flight to Paris",
    "threshold": 3,
    "passed": true
}

Efficacité de la navigation des tâches

L’efficacité de la navigation des tâches mesure si l’agent a effectué une séquence optimale d’actions en comparant à une séquence attendue (vérité au sol). Utilisez cet évaluateur pour l’optimisation du flux de travail et les tests de régression.

{
    "type": "azure_ai_evaluator",
    "name": "task_navigation_efficiency",
    "evaluator_name": "builtin.task_navigation_efficiency",
    "initialization_parameters": {
        "matching_mode": "exact_match"  # Options: "exact_match", "in_order_match", "any_order_match"
    },
    "data_mapping": {
        "actions": "{{item.actions}}",
        "expected_actions": "{{item.expected_actions}}"
    },
}

Modes correspondants :

Format d’actions :

Mapper ou actionsmessages avec expected_actions. Le actions champ accepte une chaîne ou une liste d’objets de message. Le messages champ accepte l’interaction complète en tant que tableau d’objets de message. Chaque message d’action représente une étape que l’agent a effectuée pendant la conversation :

actions = [
    {
        "role": "assistant",
        "content": [
            {"type": "function_call", "name": "call_tool_A", "arguments": "{\"param\": \"value\"}"}
        ]
    },
    {
        "role": "assistant",
        "content": [
            {"type": "function_call", "name": "call_tool_B", "arguments": "{}"}
        ]
    },
]

Pour fournir l’interaction de l’agent en tant que messages au lieu de actions, mapper messages et expected_actions:

"data_mapping": {
    "messages": "{{item.messages}}",
    "expected_actions": "{{item.expected_actions}}",
}

Format d’actions attendues :

Il expected_actions peut s’agir d’une liste simple des étapes attendues :

expected_actions = ["identify_tools_to_call", "call_tool_A", "call_tool_B", "response_synthesis"]

Ou un tuple avec des noms d’outils et des paramètres pour une validation plus détaillée :

expected_actions = (
    ["func_name1", "func_name2"],
    {
        "func_name1": {"param_key": "param_value"},
        "func_name2": {"param_key": "param_value"},
    }
)

Output:

Retourne un résultat de réussite/échec binaire, ainsi que des scores de précision, de rappel et de F1 :

{
    "type": "azure_ai_evaluator",
    "name": "task_navigation_efficiency",
    "passed": true,
    "details": {
        "precision_score": 0.85,
        "recall_score": 1.0,
        "f1_score": 0.92
    }
}

Schéma de message de l’agent

Les évaluateurs d’agents utilisent des tableaux de messages lorsqu’ils ont besoin d’instructions, d’appels d’outils et de résultats d’outils. Pour connaître la structure de messages canoniques, les définitions de rôles et les exemples de données, consultez Messages avec des appels d’outils et un format de requête et de réponse distincts.

Contenu connexe

• exemples More pour l’évaluateur de qualité de l’agent
• Évaluer vos agents IA
• Comment exécuter l’évaluation par lots
• Comment optimiser le RAG agentique