Évaluer une fonctionnalité d’IA : les evals expliquées aux Product Managers
Les evals IA prouvent qu’une fonctionnalité LLM est prête : jeu de cas, grille, LLM-juge, seuils et suivi en production. Méthode pour PM et modèle gratuit.
Guide rédigé par Alex Dionisio, Senior Product Manager. Mis à jour le 13 novembre 2026.
En bref
Une eval IA est un test répétable qui mesure si une fonctionnalité qui s’appuie sur un LLM répond correctement, sur un jeu de cas choisis et selon des critères posés avant le test. Pour un Product Manager, les evals remplacent « ça a l’air bien » par une décision argumentée : sortir, corriger ou renoncer. Elles reposent sur trois éléments : des cas réels et difficiles, une grille de notation, et des seuils fixés avant de regarder les résultats.
Qu’est-ce qu’une eval IA ?
Une eval IA est une batterie de cas de test, chacun associé à un critère de réussite, que l’on rejoue sur une fonctionnalité bâtie sur un LLM pour mesurer sa qualité. Elle produit un score comparable entre deux versions, au lieu d’une impression formée sur quelques essais.
Les evals IA jouent pour une fonctionnalité d’IA le rôle que jouent les tests pour du code classique : elles disent si le produit remplit son rôle, et si une modification l’a abîmé. La différence tient à ce qu’on vérifie. Un test classique compare une sortie à une valeur exacte. Une eval juge une réponse en langage naturel, qui peut être correcte sous mille formulations.
Concrètement, une eval rassemble trois choses :
- Un jeu de cas : des entrées représentatives (questions d’utilisateurs, documents, tickets), avec, quand c’est possible, la réponse attendue ou les éléments qu’elle doit contenir.
- Des critères : ce qui fait qu’une réponse est acceptable. Exactitude, respect du format, ton, absence d’information inventée, refus quand il le faut.
- Une méthode de notation : un contrôle automatique, une relecture humaine ou un modèle qui note à partir d’une grille.
La documentation d’Anthropic sur les tests propose cette démarche : définir des critères de succès précis et mesurables, puis construire des évaluations qui les vérifient, en automatisant la notation quand c’est possible. Écrire le code de l’eval ne revient pas au PM, mais d’en fixer le contenu : quels cas comptent, ce qui est une bonne réponse, et à partir de quand on sort.
Pourquoi tester un LLM ne ressemble pas à tester du code ?
Tester un LLM diffère de tester du code parce qu’un LLM peut donner des réponses différentes à la même question, que plusieurs réponses peuvent être bonnes, et que ses erreurs sont plausibles. Une poignée d’essais manuels ne dit donc presque rien de sa qualité réelle sur le trafic de vos utilisateurs.
- La variabilité. Le même prompt, envoyé deux fois, peut produire deux réponses distinctes. Un cas réussi une fois n’est pas un cas maîtrisé.
- Plusieurs bonnes réponses. Un résumé correct peut s’écrire de nombreuses façons. Comparer mot à mot avec une réponse de référence ne fonctionne pas ; il faut juger le fond.
- Des erreurs crédibles. Une hallucination de LLM a la forme d’une bonne réponse : phrase fluide, ton assuré, contenu faux. Elle passe facilement une relecture rapide.
- Des effets de bord partout. Changer une phrase du prompt, le modèle ou les documents fournis peut faire progresser certains cas et en abîmer d’autres, sans que rien ne casse visiblement.
Voilà pourquoi la démo réussie est un piège classique : elle montre que la fonctionnalité peut bien répondre, pas qu’elle répond bien assez souvent. Les evals mesurent la seconde chose, sur assez de cas pour que le résultat ait un sens.
Comment construire un jeu de cas pour évaluer une fonctionnalité d’IA ?
Un bon jeu de cas pour évaluer une fonctionnalité d’IA mélange trois familles : des cas réels tirés de l’usage, des cas difficiles où le modèle risque de se tromper, et des cas limites ou malveillants. Chaque cas indique ce qu’une bonne réponse doit contenir ou éviter.
- Partez du réel. Questions de support, recherches, documents envoyés par les utilisateurs : ce sont eux qui représentent le mieux le trafic. Avant le lancement, interrogez l’équipe support ou commerciale pour reconstituer les demandes typiques.
- Ajoutez les cas difficiles. Question ambiguë, information absente des documents, demande hors sujet, formulation maladroite. C’est là que les écarts entre deux versions apparaissent.
- Ajoutez les cas limites et adverses. Entrée vide ou très longue, autre langue, tentative de détourner l’assistant de sa consigne. Ces attaques sont traitées en détail dans la formation sur la sécurité produit IA.
- Écrivez l’attendu. Pour chaque cas, la réponse de référence ou, plus souvent, la liste de ce qu’elle doit contenir, et ce qu’elle ne doit jamais dire.
- Figez une version. Le jeu de cas se versionne comme un document produit : on sait quelle version a servi à quelle décision.
Anthropic conseille de privilégier le volume : beaucoup de cas notés automatiquement apportent souvent plus d’information que quelques cas notés à la main. Commencez petit, puis enrichissez le jeu à chaque erreur découverte. La leçon constituer un jeu de test montre comment doser ces familles selon votre fonctionnalité.
Quels critères et quelle grille pour noter les réponses ?
Les critères d’une eval traduisent l’objectif produit en exigences vérifiables : exactitude, fidélité aux sources, respect du format, ton juste, refus approprié. Une grille décrit, pour chaque critère, ce qui distingue une réponse acceptable d’une réponse ratée, avec un exemple de chaque côté.
Un critère utile se vérifie sans débat. « Réponse pertinente » laisse chacun juger à sa façon ; « la réponse cite uniquement des informations présentes dans la documentation fournie » se tranche par oui ou par non.
- Un critère, une question. Notez l’exactitude et le ton séparément : une réponse polie mais fausse ne doit pas obtenir une note moyenne qui masque l’erreur.
- Un verdict binaire, pas une note sur 10. Un verdict binaire est plus facile à appliquer de façon cohérente, par un humain comme par un modèle.
- Pondérez par la gravité. Une formulation maladroite et un conseil dangereux ne pèsent pas pareil. Distinguez les critères bloquants des critères de confort.
- Des exemples dans la grille. Une réponse validée et une réponse refusée par critère valent mieux qu’une définition abstraite.
Ces critères ressemblent à des critères d’acceptation : le PM les possède, parce qu’ils encodent ce que l’utilisateur attend. Si votre fonctionnalité doit renvoyer un format précis, le guide écrire une spec pour agent IA montre comment écrire ce type d’exigence sans ambiguïté.
Évaluation humaine, automatique ou LLM-juge : laquelle choisir ?
Choisissez la méthode de notation critère par critère : contrôle automatique par code quand la règle est exacte, LLM-juge quand il faut apprécier le sens sur beaucoup de cas, relecture humaine pour calibrer le juge et trancher les cas sensibles. Les trois se combinent dans une même eval.
- Contrôle par code. Le format est-il valide, la catégorie est-elle la bonne, un mot interdit apparaît-il ? Rapide, gratuit, parfaitement reproductible, mais limité aux règles exactes.
- Relecture humaine. La plus souple et la plus fine pour juger une réponse ouverte, mais lente et coûteuse. Elle sert surtout à constituer des références et à contrôler les autres méthodes.
- LLM-juge. Un second modèle note les réponses à partir de votre grille. Il apprécie le sens comme un humain, à la vitesse d’une machine, mais il a ses propres biais.
Le LLM-juge, ou « LLM as a judge », demande quelques précautions que la documentation d’Anthropic résume : une grille détaillée, un verdict normé (correct ou incorrect, ou une échelle de 1 à 5), un raisonnement demandé avant le verdict, et de préférence un autre modèle que celui dont on note les réponses. Les travaux de Zheng et al. (2023) décrivent aussi des biais connus, comme la préférence pour les réponses longues ou, le plus souvent, pour la première réponse présentée dans une comparaison.
Surtout, un juge ne se croit pas sur parole : on compare ses verdicts à ceux d’humains sur un échantillon, et on ne lui confie l’évaluation à grande échelle qu’une fois l’accord jugé suffisant. La leçon concevoir et calibrer un modèle juge détaille cette calibration.
Quels seuils fixer avant la mise en production ?
Fixez un seuil par critère avant de lancer l’eval, jamais après avoir vu les scores. Les critères graves sont bloquants, souvent avec une tolérance proche de zéro, et chaque nouvelle version doit aussi faire au moins aussi bien que la version déjà en production.
Un seuil répond à la question : « à partir de quel résultat accepte-t-on de sortir ? ». Il se discute avec les personnes qui portent le risque : support, juridique, métier. Le PM arbitre et l’écrit.
- Seuils absolus. Par exemple : aucune réponse qui invente une politique commerciale, et une large majorité de réponses jugées exactes. Les valeurs dépendent de votre contexte ; ce qui compte est de les écrire avant.
- Comparaison avec l’existant. Une version candidate se compare aussi avec ce qui tourne déjà. Un gain moyen qui cache une régression sur une catégorie importante n’est pas un gain.
- Règle de décision écrite. Que fait-on si un seuil de confort est raté de peu ? Si la réponse est « on baisse le seuil », l’eval ne protège plus rien.
Les bonnes pratiques d’évaluation d’OpenAI recommandent une évaluation continue : rejouer les evals à chaque changement, y compris un changement de modèle, car une version plus récente n’est pas forcément meilleure pour votre cas. Voir la leçon fixer les seuils et la règle de régression.
Comment suivre la qualité en production et éviter les régressions ?
En production, la qualité d’une fonctionnalité d’IA se suit en échantillonnant des réponses réelles, en les notant avec la même grille, et en surveillant les signaux d’usage. Toute retouche du prompt, du modèle ou des données rejoue le jeu de cas complet avant d’être déployée.
Les evals avant lancement disent si une version peut sortir. Elles ne voient pas les questions que personne n’avait imaginées. La production, si.
- Échantillonnez et notez. Une part des conversations réelles passe chaque semaine par la grille, notée par le juge et contrôlée par des humains.
- Écoutez les signaux faibles. Pouces vers le bas, reformulations, abandons, escalades vers le support : chacun pointe des cas à examiner.
- Nourrissez le jeu de cas. Chaque erreur réelle devient un nouveau cas de test. Le jeu grandit avec le produit et la même erreur ne revient pas sans être vue.
- Rejouez à chaque changement. Prompt, modèle, documents indexés, paramètres : tout changement passe par l’eval complète, comme une suite de tests de non-régression.
La formation consacrée au monitoring en production couvre la journalisation, le déploiement progressif et la gestion des incidents qui complètent ce suivi.
Quel lien entre les evals et le prompt ?
Les evals et le prompt forment une boucle : le prompt est une hypothèse sur la façon d’obtenir de bonnes réponses, et l’eval la vérifie. Sans eval, chaque retouche du prompt corrige le cas qu’on regarde et en casse d’autres en silence.
Le prompt engineering sans mesure revient à ajuster au jugé. Avec un jeu de cas, chaque version du prompt reçoit un score, et l’on garde celle qui progresse sans régresser ailleurs. Anthropic présente d’ailleurs la définition des critères et des tests comme un préalable au travail sur le prompt.
- Écrivez les critères et un premier jeu de cas avant d’optimiser le prompt.
- Mesurez la version actuelle : c’est votre point de départ.
- Modifiez une chose à la fois, puis rejouez l’eval.
- Lisez les échecs, pas seulement le score : ils disent quoi corriger.
Les evals révèlent aussi quand le prompt n’est pas le bon levier : si les réponses échouent parce que l’information manque, le problème relève plutôt de la recherche documentaire. Le guide RAG ou fine-tuning aide à choisir le bon levier, et la formation sur le prompting pour PM donne les bases de l’écriture du prompt lui-même.
Quelles erreurs éviter quand on évalue une fonctionnalité d’IA ?
Les erreurs les plus fréquentes sont de juger sur une démo, de tester uniquement des cas faciles, de noter avec des critères vagues, de faire confiance à un LLM-juge non calibré, de fixer les seuils après coup et d’arrêter d’évaluer une fois la fonctionnalité lancée.
- Décider sur quelques essais. Dix questions bien choisies en réunion ne représentent pas le trafic réel.
- Un jeu de cas trop propre. Si tous les cas sont faciles, toutes les versions semblent excellentes et l’eval ne départage rien.
- Une note globale unique. Une moyenne masque les erreurs graves. Gardez un résultat par critère.
- Un juge non calibré. Un LLM-juge qui n’a jamais été comparé à des humains mesure peut-être tout autre chose que la qualité visée.
- Optimiser pour le jeu de cas. À force de retoucher le prompt pour réussir les mêmes cas, on finit par réussir l’eval sans améliorer le produit. Gardez une partie des cas de côté et renouvelez-les.
- S’arrêter au lancement. Les usages évoluent, les modèles changent : une eval qui n’est plus rejouée ne protège plus.
Pour appliquer cette méthode à votre propre fonctionnalité et repartir avec son plan d’évaluation, ses cas et ses seuils, la formation Évaluer une fonctionnalité IA vous guide étape par étape, sans écrire de code.
Modèle gratuit : PLAN-EVALS.md
Remplissez ce plan pour une fonctionnalité d’IA avant de modifier son prompt ou son modèle, puis partagez-le avec l’équipe qui construira l’eval. Gardez-le versionné à côté de la fonctionnalité.
Télécharger PLAN-EVALS.md# Plan d’évaluation : [nom de la fonctionnalité]
Responsable : [nom]
Version du jeu de cas : v1
Dernière mise à jour : [date]
## Objectif de la fonctionnalité
[Pour quels utilisateurs, quelle tâche, quel résultat attendu. 2 à 3 phrases.]
## Critères
| Critère | Définition (réussite si...) | Gravité | Méthode de notation |
|---|---|---|---|
| Exactitude | ... | bloquant | LLM-juge + contrôle humain |
| Fidélité aux sources | ... | bloquant | LLM-juge |
| Format | ... | confort | code |
| Ton | ... | confort | LLM-juge |
## Jeu de cas
- Cas réels (source : ...) : [nombre]
- Cas difficiles (ambigus, info absente, hors sujet) : [nombre]
- Cas limites et adverses : [nombre]
- Cas gardés de côté (jamais utilisés pour retoucher le prompt) : [nombre]
Pour chaque cas : entrée, attendu (doit contenir / ne doit jamais dire), catégorie.
## LLM-juge
- Modèle juge (autre que celui qu’on évalue) : ...
- Grille utilisée : [lien]
- Calibration : [nombre] cas notés par des humains, accord constaté : ...
## Seuils de sortie (écrits avant de lancer l’eval)
- Critères bloquants : ...
- Critères de confort : ...
- Comparaison avec la version en production : aucune régression sur ...
## Règle de décision
- Tous les seuils atteints : on sort.
- Un critère bloquant raté : on ne sort pas.
- Un critère de confort raté : [qui décide, sur quels arguments]
## Suivi en production
- Échantillon noté chaque [semaine] : [taille]
- Signaux suivis : retours négatifs, reformulations, escalades
- Chaque erreur réelle devient un cas du jeu de test
## Historique
- [date] : [version testée], [résultat], [décision]
Passer à la pratique
La formation « Évaluer une fonctionnalité IA : jeux de test, métriques et LLM-juge » vous guide pas à pas, sur votre propre produit, jusqu’au livrable.
Voir la formationQuestions fréquentes
Faut-il savoir coder pour mettre en place des evals IA ?
Non pour concevoir les evals, oui pour les automatiser. Le PM définit les critères, les cas, la grille et les seuils ; un développeur ou un outil d’évaluation les exécute. Un tableur suffit pour une première eval manuelle.
Combien de cas faut-il dans un jeu de test ?
Il n’existe aucun nombre universel. Commencez avec assez de cas pour couvrir chaque catégorie d’usage et chaque type de risque, puis enrichissez le jeu à chaque erreur observée. Plus une catégorie est critique, plus elle mérite de cas.
Qu’est-ce que « LLM as a judge » ?
« LLM as a judge », ou LLM-juge, désigne l’usage d’un modèle de langage pour noter les réponses d’un autre système à partir d’une grille. C’est utile pour évaluer beaucoup de réponses ouvertes, à condition de calibrer le juge contre des notes humaines.
Les evals remplacent-elles les tests utilisateurs ?
Non. Les evals mesurent la qualité des réponses sur des cas connus ; les tests utilisateurs et les signaux d’usage disent si la fonctionnalité répond au besoin. Les deux se complètent, et les seconds alimentent souvent les premiers en nouveaux cas.
Les evals suffisent-elles à rendre une fonctionnalité d’IA sûre ?
Non. Elles mesurent les erreurs, elles ne les empêchent pas. Il faut aussi des garde-fous en production : filtres, limites d’action, reprise par un humain. Pour un assistant intégré au produit, voir la formation pour concevoir un assistant IA intégré.