Comment évaluer des agents IA : jeux de test, évaluateurs et tests de régression

Derrière chaque excellent produit d’IA se cache un solide processus d’évaluation des agents IA, appelé evals, qui détecte les erreurs en amont et garantit le bon fonctionnement de l’agent. Les evals sont essentielles pour les agents IA qui exécutent des actions à haut risque, comme des remboursements pour le compte d’un tiers.

Mettre en place ce processus demande quelques connaissances techniques et des compétences en analyse de données. Mais c’est loin d’être aussi intimidant ou inaccessible qu’on pourrait le croire. Pour vous aider à démarrer, nous présentons six étapes pratiques pour évaluer les agents IA, ainsi que les idées reçues courantes qui font échouer le processus.

Que signifie évaluer un agent IA ?

Évaluer un agent IA consiste à mesurer sa capacité à accomplir correctement des tâches et à vérifier si ses décisions répondent aux exigences de l’organisation. Concrètement, les évaluations d’agents IA, ou evals, sont des métriques spécifiques qui aident les organisations à déterminer si l’agent fonctionne de manière suffisamment fiable pour le rôle qui lui est destiné.

Prenons l’exemple d’un agent IA chargé des achats dans une usine de production, qui vérifie le stock de pièces détachées et prépare les demandes de réapprovisionnement. Si une pièce homologuée n’est pas disponible ou si les informations sur les fournisseurs sont obsolètes, l’agent signalera-t-il le problème ou recommandera-t-il un substitut non homologué ?

Et si vous modifiez son prompt système pour corriger ce problème, comment savoir que vous n’en avez pas introduit un autre ?

Sans évaluation, les chefs de produit en sont réduits à deviner. Les evals fournissent ainsi un signal de retour pour mesurer les performances, repérer les problèmes récurrents et tester les modifications avec davantage de confiance.

Cela dit, une évaluation d’agent peut examiner plusieurs aspects d’une exécution :

• La qualité du résultat final
• Les informations utilisées par l’agent
• Les outils qu’il a appelés
• Le respect des règles qui encadrent son comportement

Métriques courantes d’évaluation des agents IA

Les evals s’appuient sur des données qualitatives et quantitatives. L’évaluation qualitative vous aide à comprendre ce qui se passe et pourquoi, notamment grâce à l’examen manuel des décisions de l’agent. L’évaluation quantitative transforme ces observations en signaux mesurables, par exemple en comptant la fréquence de certains modes de défaillance ou en calculant les taux de réussite des tâches.

Voici la liste des métriques fondamentales d’évaluation des agents IA :

• La réussite de la tâche indique si l’agent a atteint le résultat visé ; elle s’exprime généralement en pourcentage d’exécutions produisant des résultats valides.
• La justesse des actions indique si l’agent a utilisé les outils de manière appropriée, choisi des arguments valides et respecté les autorisations.
• La qualité des réponses évalue si le résultat final est exact, complet et utile. Elle peut inclure l’exactitude factuelle, le respect des instructions et la capacité de l’agent à étayer ses décisions à l’aide des informations disponibles.
• La fiabilité mesure la constance des résultats sur des essais répétés, avec des entrées variées et dans des cas limites.
• Le coût et la latence mesurent les ressources nécessaires pour obtenir un résultat satisfaisant, notamment le temps d’exécution, la consommation de tokens et les appels d’outils.

Selon ce que vous mesurez, les evals peuvent porter sur les performances de bout en bout d’un agent, sur sa trajectoire d’exécution ou sur des composants individuels, comme les appels d’outils et les étapes de récupération d’informations.

Étape 1 : définir à quoi ressemble une exécution réussie de l’agent

Commencez par décrire explicitement ce que l’agent est censé accomplir — les exigences produit. Cela semble évident, et pourtant l’exercice peut s’avérer étonnamment difficile. Le phénomène porte même un nom : l’écart de spécification.

Voici comment l’aborder, selon Andrey Khomutov, notre data scientist senior :

« Commencez par deux questions : “Qu’est-ce qui permettrait de considérer que le travail est fait ?” et “Qu’est-ce qui rendrait inacceptable une exécution apparemment réussie ?”

Pour les agents, d’un point de vue technique, cela signifie vérifier à la fois le résultat et la manière dont ils y sont parvenus. »

Un agent peut produire la bonne réponse en accédant à un corrigé ayant fuité, ou effectuer des actions non autorisées pendant l’exécution de sa tâche. Khomutov souligne que la fuite de réponses et les actions dangereuses pendant les évaluations sont des raisons concrètes de ne pas juger uniquement la réponse finale.

« Je m’attends à ce que l’inspection de la trajectoire devienne un élément standard des suites d’évaluation d’agents, plutôt qu’une pratique réservée aux cas où un résultat paraît suspect », ajoute-t-il.

Faites ensuite appel à un expert du domaine pour valider vos critères de réussite. Les personnes ayant une connaissance pratique du domaine peuvent déterminer si les conditions que nous fixons à un agent IA correspondent bien à un résultat réussi.

Étape 2. Constituer un jeu de test à partir de tâches et d’échecs réels

Examinez le comportement réel de l’agent pour comprendre à quoi ressemblent de bonnes et de mauvaises performances. Résistez à la tentation de commencer par générer des dizaines de tests fondés uniquement sur ce qui, selon vous, pourrait mal tourner.

Hamel Husain, ingénieur ML chez Parlance Lab, et Shreya Shankar, chercheuse en systèmes ML et en evals d’IA appliquée, recommandent de commencer par l’analyse des erreurs, une technique empruntée à l’apprentissage automatique et à la data science. Le processus commence par une analyse qualitative des traces d’exécution de l’agent — des enregistrements montrant l’entrée de l’utilisateur, les appels d’outils, les informations récupérées et la sortie de l’agent.

1. Examinez les traces une par une et annotez les erreurs (codage ouvert). Demandez à un expert du domaine d’inspecter les exécutions de l’agent et de rédiger de courtes observations sur ce qui n’a pas fonctionné. Concentrez-vous sur la première erreur significative.
2. Regroupez les observations en modes de défaillance (codage axial). Une fois que vous disposez de suffisamment de notes, utilisez un LLM pour suggérer des catégories d’erreurs similaires. Il peut s’agir, par exemple, de recommandations de pièces incompatibles, d’erreurs de récupération des données d’inventaire ou d’échecs de transfert vers un opérateur humain.
3. Comptez les occurrences. Attribuez chaque observation à une catégorie, puis utilisez une feuille de calcul ou un tableau croisé dynamique pour calculer la fréquence d’apparition de chaque mode de défaillance.
4. Hiérarchisez les problèmes à traiter, en tenant compte à la fois de leur fréquence et de leur gravité.
5. Transformez les échecs importants en cas de test. Enregistrez l’entrée concernée, les conditions de départ, le résultat attendu et les critères de notation afin de pouvoir tester à nouveau l’agent sur le même scénario.

Combien de traces faut-il examiner ? Environ 100, mais il n’existe pas de chiffre magique. Arrêtez-vous plus tôt dès que vous atteignez la saturation théorique : le point à partir duquel l’examen de traces supplémentaires ne révèle plus de nouveaux schémas de défaillance significatifs.

Vous n’avez pas encore lancé l’application ? Des exemples synthétiques peuvent vous aider à constituer un premier jeu de test, mais les données réelles des utilisateurs devraient l’alimenter dès qu’elles sont disponibles.

L’utilisation des benchmarks dans l’évaluation des agents IA

Au-delà de la création de vos propres cas de test, vous pouvez utiliser des collections existantes de tâches d’évaluation standardisées, appelées benchmarks, pour évaluer les capacités des agents.

Mais les benchmarks ne sont pas infaillibles. Les audits de SWE-bench, les analyses de benchmarks d’Epoch AI et les bonnes réponses initialement rejetées dans TheoPhysEval montrent comment des tâches ou des réponses attendues erronées peuvent fausser les résultats d’évaluation.

Comme le conseille Khomutov, choisissez des benchmarks à jour et adaptés à votre domaine, et examinez les réussites ou les échecs surprenants avant de considérer les scores comme une preuve fiable des performances de l’agent.

Étape 3. Exécuter l’agent dans un environnement de test reproductible

Un environnement de test reproductible est un dispositif contrôlé dans lequel vous pouvez exécuter un agent IA sur les mêmes cas de test, dans les mêmes conditions de départ, et comparer les résultats. Il peut comprendre un dossier de cas de test, un script Python qui exécute l’agent ou un ensemble de vérifications qui évaluent les résultats.

Vous pouvez commencer par stocker des entrées représentatives sous forme de fichiers JSON et utiliser un script Python pour exécuter le flux de travail de votre agent et vérifier ses sorties à l’aide d’assertions. Pour l’agent de gestion des stocks de notre usine de fabrication, un environnement de test reproductible pourrait ressembler à ceci :

Agrandir

Pour mettre en place un environnement de test reproductible, procédez comme suit :

1. Enregistrez des entrées représentatives. Stockez des événements réels ou des cas de test dans la même structure que celle que votre application reçoit en production. Dans notre scénario, vous enregistreriez sous forme de fichier JSON une demande de maintenance contenant l’identifiant de la machine, la pièce détachée requise et la date de maintenance, accompagnée d’un instantané des données d’inventaire et des pièces homologuées.
2. Exécutez le flux de travail. Faites passer chaque entrée par l’agent, y compris ses étapes de récupération d’informations, ses appels d’outils et la génération de sa réponse.
3. Enregistrez le résultat et la trace. Capturez la sortie finale et les actions intermédiaires pertinentes (comme les consultations d’inventaire) afin de voir non seulement si l’agent a échoué, mais aussi à quel endroit.
4. Répétez les cas en fonction de la gravité et de la fréquence des échecs, ainsi que de la difficulté à corriger le problème. Les applications LLM sont non déterministes (elles peuvent produire des résultats différents à partir d’entrées identiques) : une exécution réussie ne garantit donc pas que la suivante réussira. Indiquez la proportion d’essais réussis et examinez les échecs.

Pour ce dernier point, Khomutov conseille de mesurer le pass@1 (la fréquence à laquelle l’agent réussit en une seule tentative) et le pass@k (la probabilité de réussir au moins une fois sur un nombre donné de tentatives). Si vous indiquez le pass@k, précisez le nombre de tentatives, car produire une bonne réponse parmi plusieurs ne signifie pas que l’agent sait laquelle choisir.

À mesure que votre application se développe, utilisez un framework de test comme pytest pour organiser et exécuter les tests, et envisagez de stocker les grands jeux de données de test et leurs résultats dans une base de données.

Étape 4. Choisir le bon correcteur pour chaque vérification

Un correcteur (aussi souvent appelé évaluateur) est un mécanisme — un morceau de code, un LLM guidé par une grille de notation ou un relecteur humain — qui vérifie la sortie ou l’action d’un agent par rapport à un critère défini. Un correcteur renvoie un verdict de réussite ou d’échec ainsi qu’une explication indiquant les éléments probants pertinents.

Info : Une grille de notation est un ensemble de critères et d’instructions qui définissent ce qui constitue un résultat correct ou acceptable.

Le type de correcteur adapté dépend de ce que vous cherchez à vérifier. Voici comment se comparent les trois approches :

Différents aspects d’une même exécution peuvent parfois nécessiter des méthodes d’évaluation distinctes : vous devrez donc peut-être combiner plusieurs correcteurs.

Comment combiner les correcteurs ?

Posez-vous la question : « Le résultat peut-il être vérifié par rapport à une règle connue ou à une valeur attendue, ou nécessite-t-il un jugement de type humain ? »

• Si vous pouvez vérifier le résultat de manière exacte, commencez par un correcteur basé sur le code. Les correcteurs basés sur le code peuvent également vérifier des sorties structurées, la validité des valeurs de champs, les arguments d’outils ou l’état final d’une base de données.
• Si la vérification nécessite d’interpréter le contexte, recourez à l’approche LLM-as-a-judge.
• Faites appel à des relecteurs humains pour les décisions propres à un domaine ou contestées.

Important ! Un correcteur LLM peut mal interpréter les éléments probants ou appliquer une grille de manière incorrecte. Il nécessite donc une étape d’évaluation supplémentaire : le calibrage par rapport aux jugements humains.

Calibrez le correcteur LLM par rapport aux jugements humains.

Concrètement, le calibrage nécessite qu’un expert du domaine évalue des exécutions réelles de l’agent. L’expert compare ensuite ses jugements à ceux du LLM et affine la grille de notation en fonction des désaccords.

Voici un processus de calibrage du correcteur en cinq étapes :

1. Rassemblez des exemples d’entrées, de sorties et de traces pertinentes de l’agent.
2. Demandez à un expert du domaine d’évaluer de manière indépendante si chaque exemple satisfait au critère d’évaluation.
3. Exécutez le correcteur LLM sur ces exemples.
4. Comparez les jugements humains et ceux du modèle.
5. Analysez les désaccords et affinez la grille du correcteur avant de le tester sur de nouveaux exemples.

Khomutov souligne également l’importance de tester séparément la cohérence du correcteur LLM :

« Soumettez-lui plusieurs fois exactement la même exécution enregistrée et les mêmes fichiers, sans relancer l’agent. Cela permet de distinguer la variation dans le travail de l’agent de la variation dans la notation. »

Si une même sortie obtient des verdicts différents, ne partez pas du principe que chaque variation de score provient de l’agent. Examinez plutôt une matrice de confusion indiquant quand le correcteur a correctement identifié des erreurs, quand il les a manquées et quand il a signalé à tort des sorties acceptables.

La relecture humaine reste indispensable pour établir des jugements de référence, trancher les cas contestés et découvrir de nouveaux modes de défaillance que les correcteurs existants n’ont pas été conçus pour détecter.

Étape 5. Comparer les versions et effectuer des tests de non-régression

Supposons que l’analyse des erreurs révèle que votre agent de gestion des stocks recommande fréquemment des pièces de remplacement non homologuées. Vous modifiez son prompt système pour exiger une vérification explicite de la compatibilité. Le cas qui échouait initialement réussit désormais. Mais comment savoir que la modification n’a pas affecté d’autres tâches ?

C’est là qu’interviennent les tests de non-régression.

Les tests de non-régression consistent à réexécuter des cas de test précédemment réussis après avoir modifié le prompt, le modèle ou le flux de travail d’un agent, afin de vérifier que la modification n’a pas introduit de nouveaux échecs.

1. Reproduisez l’échec initial à l’aide d’une entrée enregistrée du jeu de test.
2. Apportez une modification ciblée au prompt, au modèle ou au flux de travail.
3. Réexécutez le test en échec pour vérifier si le problème est résolu.
4. Exécutez les autres tests pour vérifier que la modification n’a pas altéré des comportements qui fonctionnaient auparavant.
5. Examinez les résultats et analysez toute nouvelle défaillance.

Comparez l’agent de référence et l’agent mis à jour à l’aide des mêmes cas de test et des mêmes critères de notation pour obtenir des résultats fiables.

Étape 6 : surveiller les performances de l’agent IA en production

L’évaluation d’un agent ne s’arrête pas une fois votre application déployée. Comme l’expliquent Husain et Shankar, les évaluateurs que vous utilisez pendant le développement peuvent également s’exécuter sur des données de production réelles pour mesurer l’évolution des performances de votre agent au fil du temps.

C’est ce qu’on appelle l’évaluation en ligne. Elle s’inscrit dans un processus plus large de surveillance en production, qui permet de mettre au jour des défaillances récurrentes ou jusque-là inconnues.

Ce processus itératif repose sur quatre activités complémentaires :

• Exécutez des juges LLM calibrés sur les traces de production. Échantillonnez des interactions réelles avec l’agent et appliquez les évaluateurs que vous avez déjà validés par rapport à des jugements humains.
• Suivez l’évolution des taux d’échec. Utilisez les catégories de défaillances établies lors de l’analyse des erreurs pour quantifier les problèmes récurrents.
• Continuez à examiner les traces manuellement. Les évaluateurs automatisés ne détectent que les problèmes qu’ils ont été conçus pour identifier. Inspectez manuellement des échantillons d’interactions réelles avec l’agent pour découvrir de nouvelles erreurs ou des demandes inhabituelles des utilisateurs.
• Utilisez des tests A/B pour mesurer les résultats métier (uniquement lorsque c’est pertinent). Comparez différents prompts, modèles ou flux de travail à l’aide d’indicateurs tels que le taux d’achèvement des tâches, la satisfaction des utilisateurs et le délai de résolution. Cette démarche permet de déterminer si une modification améliore réellement l’expérience produit, au-delà de la réussite de tests individuels.

Une remarque importante : les évaluations n’ont pas besoin d’être parfaites. Il suffit qu’elles soient assez bonnes pour améliorer votre produit.

Idées reçues courantes sur l’évaluation des agents IA

• Les évaluations ne sont que des tests unitaires. C’est faux : les tests unitaires sont de petites vérifications automatisées qui ne constituent qu’une partie de l’évaluation. Les évaluations impliquent aussi une analyse qualitative des erreurs, des jugements humains, une surveillance en production et des expérimentations pour mesurer la qualité de l’application.
• Une plateforme d’évaluation peut tout faire à votre place. Les outils prêts à l’emploi peuvent automatiser certaines vérifications, mais ils ne peuvent pas déterminer quels modes de défaillance (types d’erreurs ou comportements indésirables de l’agent) comptent pour votre produit.
• Vous pouvez confier toute l’évaluation à un LLM. C’est un leurre. L’analyse des erreurs menée par des humains et le calibrage des évaluateurs restent essentiels, car les LLM ne disposent pas du contexte métier nécessaire pour détecter tous les problèmes.
• Les tests A/B ou la simple utilisation de l’agent remplacent les évaluations. Faux. Les tests A/B peuvent montrer quelle version obtient les meilleurs résultats selon les indicateurs choisis, mais ils ne peuvent pas, à eux seuls, expliquer les problèmes sous-jacents.

FAQ sur l’évaluation des agents IA

1. Quelle est la différence entre l’évaluation des agents IA et l’évaluation des LLM ?

L’évaluation des LLM mesure la capacité d’un modèle de langage à accomplir une tâche donnée, comme répondre à une question, résumer un document ou extraire des informations. L’évaluation des agents IA porte sur un système qui exécute de manière autonome plusieurs étapes pour accomplir une tâche.

Contrairement à une évaluation classique de LLM, l’évaluation d’un agent examine à la fois le résultat final et la séquence d’actions menées pour y parvenir, notamment les appels d’outils, les décisions et le respect de règles prédéfinies.

2. Principaux indicateurs pour l’évaluation des agents IA

Les indicateurs d’évaluation des agents IA se répartissent en deux grandes catégories :

• Indicateurs de performance technique : taux de réussite des tâches, exactitude des actions, qualité des réponses, fiabilité (pass@1 et pass@k), latence, consommation de tokens et coût par tâche réussie.
• Indicateurs métier et d’expérience utilisateur : satisfaction client (CSAT), taux de résolution des problèmes, taux d’escalade, taux de conversion, temps d’achèvement des tâches et autres résultats propres au rôle de l’agent.

Par exemple, un agent de support client pourrait être évalué sur la résolution effective des problèmes et la satisfaction client, tandis qu’un agent d’achat IA pourrait être mesuré à l’aune de l’exactitude des demandes de réapprovisionnement, des taux d’approbation et de la durée du cycle d’achat.

Les bons indicateurs doivent refléter à la fois la fiabilité de l’agent et la mesure dans laquelle son travail améliore les résultats métier.

3. Quels sont les meilleurs outils pour évaluer les agents IA ?

Parmi les options courantes :

• Frameworks de test : les assertions Python et pytest sont utiles pour exécuter des cas de test reproductibles et vérifier des conditions précises, par exemple si un agent a sélectionné le bon outil ou renvoyé un identifiant de pièce valide.
• Frameworks d’évaluation d’agents IA : DeepEval et la boîte à outils agent-eval de Google prennent en charge des évaluations plus complexes, notamment les traces d’exécution, les évaluateurs basés sur des LLM et les tests de régression automatisés.
• Plateformes d’évaluation et d’observabilité : LangSmith, Arize Phoenix et MLflow aident les équipes à inspecter le comportement des agents, à gérer les jeux de données d’évaluation, à comparer les versions des agents et à surveiller les performances en production.

4. Comment automatiser l’évaluation des agents IA ?

Vous pouvez automatiser l’évaluation des agents IA en créant des tests reproductibles, en appliquant des évaluateurs automatisés et en intégrant ces vérifications à vos flux de travail de développement et de production :

1. Créez un jeu de données d’évaluation : rassemblez des tâches utilisateur représentatives, les résultats attendus, les défaillances connues et les traces d’exécution de l’agent. Incluez des cas limites tels que des appels d’outils en échec, des informations manquantes et des actions non autorisées.
2. Automatisez l’exécution des tests et la notation : utilisez des frameworks comme pytest ou DeepEval pour exécuter les cas de test et appliquer des vérifications basées sur le code ou des évaluateurs LLM. Validez les évaluateurs LLM par rapport à des jugements humains avant de vous fier à leurs scores.
3. Intégrez les évaluations à votre CI/CD : relancez automatiquement les tests de régression lorsque les développeurs modifient les prompts, les modèles, les outils ou le flux de travail d’un agent. Comparez les résultats à une référence et définissez des seuils de qualité qui bloquent les mises en production en cas d’échec des vérifications critiques.
4. Appliquez des évaluateurs calibrés à des échantillons de traces de production, suivez les taux d’échec et les autres indicateurs de performance, et analysez les nouvelles erreurs grâce à une revue manuelle.