Évaluation et tests Mesurer avant de livrer

Réponse rapide

L'évaluation est ce qui fait passer « ce prompt est meilleur » du statut d'opinion à celui d'affirmation reproductible. Les sorties d'un LLM étant stochastiques, la justesse est une propriété de la distribution des sorties, pas d'une exécution isolée — l'évaluation mesure cette distribution au lieu des quelques exemples que vous avez vérifiés au hasard.

  • Un dispositif mature comporte trois couches : évaluations unitaires, d'intégration et système — chacune répondant à une question différente.
  • Un prompt de juge ne vaut que sa grille. « Notez de 1 à 5 » n'est pas une grille.
  • L'erreur de livraison la plus fréquente n'est pas de livrer trop tôt — c'est de livrer sans avoir défini ce que « prêt » veut dire.

Chaque leçon précédente de cette série reposait sur une version de la même affirmation implicite : ce prompt est meilleur que celui-là. Meilleur en quoi ? Mesuré comment ? Sur quelles entrées ? Comparé à quelle référence ? Si vous ne pouvez pas répondre à ces questions par un chiffre issu d'un test reproductible, l'affirmation est une opinion — et les opinions sur la qualité des systèmes d'IA ont un bilan remarquablement mauvais en production.

L'évaluation est la discipline qui rend cette affirmation rigoureuse. C'est aussi la partie la plus systématiquement négligée du travail de prompt engineering. Des équipes itèrent sur leurs prompts face à trois ou quatre exemples vérifiés à la main, livrent en production, et découvrent les modes de défaillance trois mois plus tard dans les réclamations des utilisateurs. S'en passer, ce n'est pas faire de l'ingénierie ; c'est deviner à grande échelle.

1. Pourquoi l'évaluation est la discipline manquante

Dans le logiciel traditionnel, la justesse est une propriété d'une exécution donnée — les tests d'une fonction passent ou non. Le prompt engineering pratiqué sans évaluations n'a pas d'équivalent : le prompt « semble bon » ou non, et ce n'est pas une fondation sur laquelle bâtir un système fiable.

La difficulté de fond, c'est que les sorties d'un modèle de langage sont stochastiques et de grande dimension. Un même prompt peut produire des sorties différentes d'une exécution à l'autre. Dans les systèmes LLM, la justesse est une propriété de la distribution des sorties — la question n'est pas « est-ce que cela renvoie la bonne valeur ? » mais « est-ce que ce système produit des sorties dans la bande de qualité acceptable, de façon fiable, sur une distribution représentative d'entrées ? ». Un prompt excellent sur 80 % des entrées et catastrophiquement faux sur 20 % n'est pas un bon prompt — c'est un incident en latence.

Une raison secondaire à cette négligence : l'évaluation oblige à expliciter le niveau de qualité. « La sortie doit être utile et exacte » n'est pas une spécification — c'est un souhait. Écrire une évaluation force à rendre la qualité opérationnelle : exacte au regard de quelle vérité terrain, utile selon quelle grille, évaluée sur quelle distribution d'entrées. Cet exercice fait remonter les désaccords sur ce que le système est censé faire avant qu'ils ne remontent en production.

Shankar et al. (2024) en montrent une dimension dans leur étude sur la façon dont les équipes calibrent l'évaluation assistée par LLM face aux préférences humaines — mettant en évidence une divergence systématique quand les pipelines de juge ne sont pas alignés. En pratique, les équipes dépourvues de pipeline d'évaluation structuré surestiment souvent la qualité de leur système, imputent les défaillances aux mauvais composants, et régressent sur des capacités qui fonctionnaient en itérant sur les prompts sans tests de régression. Ce sont des schémas d'échec récurrents contre lesquels il faut concevoir.

2. La pile d'évaluation

Un dispositif d'évaluation mature comporte trois couches, chacune répondant à une question différente. N'exécuter que la couche supérieure — l'évaluation humaine de bout en bout — coûte cher, prend du temps et ne dit rien de l'origine d'une défaillance. N'exécuter que la couche inférieure ne dit rien du fonctionnement du pipeline complet. Il vous faut les trois.

Évaluations unitaires

Un prompt unique confronté à des paires entrée-sortie fixes. Assez peu coûteuses pour tourner à chaque commit.

Évaluations d'intégration

Le pipeline complet, de bout en bout. De dizaines à centaines d'appels d'API par exécution.

Évaluations système

Des évaluateurs humains suivant une grille définie — la vérité terrain qui calibre L1 et L2.

L1 et L2 s'exécutent automatiquement à chaque changement de prompt — c'est votre pipeline d'intégration continue. L3 tourne périodiquement, chaque semaine ou avant une version majeure, et ses résultats calibrent les couches automatiques : si un prompt de juge note haut des sorties que les évaluateurs humains notent systématiquement bas, c'est le prompt du juge qu'il faut revoir. Concevez le pipeline pour que L1 attrape la plupart des régressions avant L2, et que L2 attrape les défaillances avant L3.

3. Construire le jeu d'évaluation

Un jeu d'évaluation est une collection de triplets entrée, sortie attendue et métadonnées, face auxquels votre système est mesuré. Un jeu qui ne représente pas votre véritable distribution d'entrées produit des scores dénués de sens, ou pire, trompeurs.

Le jeu de référence

Commencez par 50 à 100 exemples vérifiés à la main — assez peu pour les annoter avec soin, assez pour détecter des écarts significatifs entre versions de prompt, tirés de votre distribution d'entrées réelle ou attendue. Un bon jeu de référence comporte quatre parties par exemple : l'entrée, la réponse de vérité terrain, une grille définissant ce qu'est une réponse correcte, et une étiquette de catégorie. Cette étiquette compte — un score agrégé de 82 % masque si le système échoue uniformément ou catastrophiquement sur une seule sous-catégorie.

Entrée

Doit représenter de vrais profils de requêtes, pas seulement les cas faciles ou évidents.

Référence

C'est votre plafond de qualité. Si la référence est fausse, votre métrique mesure la mauvaise chose.

Grille

Sans grille, les évaluateurs humains divergent et les juges automatiques ne sont pas calibrés.

Catégorie

Par exemple : recherche factuelle, raisonnement à plusieurs sauts, requête ambiguë, demande hors périmètre, entrée hostile. Permet l'analyse par tranches : quels types d'entrées échouent, et à quelle fréquence.

Cas hostiles et cas limites

Un jeu de référence tiré uniquement d'entrées représentatives passera à côté des modes de défaillance qui comptent le plus. Consacrez au moins 20 % du jeu à des entrées conçues pour sonder la fiabilité : entrées frontières en limite de périmètre, requêtes ambiguës à plusieurs interprétations, contexte contradictoire qui infirme la bonne réponse, et variantes reformulées d'une même question. À mesure que le système mûrit, les ajouts les plus précieux sont les cas issus d'échecs — de vraies entrées de production sur lesquelles le système a produit une mauvaise sortie. Chaque défaillance en production devrait donner lieu à au moins un nouveau cas d'évaluation.

Ce que chaque catégorie teste réellement

  • Entrées frontières. Le système décline-t-il correctement les demandes hors périmètre, ou tente-t-il une réponse sans fondement ?
  • Requêtes ambiguës. Le système demande-t-il une clarification, ou s'engage-t-il sur une interprétation sans signaler l'ambiguïté ?
  • Contexte contradictoire. Le modèle reproduit-il fidèlement le mauvais contexte, ou y résiste-t-il ?
  • Variantes reformulées. Une forte variance de qualité entre reformulations révèle des prompts fragiles.

4. Taxonomie des métriques

Aucune métrique unique ne capture la qualité des sorties sur toutes les tâches. Trois niveaux couvrent l'éventail, de la moins coûteuse à la plus expressive.

Correspondance exacte et métriques à règles

La correspondance exacte de chaînes, les expressions régulières et la validation de schéma sont les métriques les moins coûteuses et les plus fiables — quand elles s'appliquent. Elles conviennent lorsque le format de sortie est entièrement contraint : un schéma JSON précis, une étiquette de classification issue d'un vocabulaire fixe, un booléen, un nombre. Le mode de défaillance est évident : la correspondance exacte est trop stricte pour la génération en langue naturelle. Réservez les métriques à règles à la structure et aux clés factuelles, pas au contenu du texte généré.

La similarité sémantique

Les métriques à référence comparent la sortie générée à une référence, par embeddings ou par recouvrement de n-grammes. ROUGE mesure le recouvrement de n-grammes et fait référence pour le résumé. BERTScore calcule une similarité cosinus au niveau des tokens à partir d'embeddings contextuels, plus robuste à la reformulation que les méthodes par n-grammes. La limite de toutes les métriques à référence : elles exigent une référence, et pénalisent les reformulations correctes qui emploient d'autres mots. Un ROUGE élevé ne signifie pas une haute qualité ; un ROUGE faible ne signifie pas une basse qualité.

Le LLM comme juge

L'approche la plus expressive, et de plus en plus dominante : un second modèle de langage, généralement plus puissant, lit l'entrée, la sortie et éventuellement une référence, puis la note selon une grille. Zheng et al. (2023) formalisent cela dans le cadre MT-Bench, montrant que GPT-4 en juge atteint plus de 80 % d'accord avec des évaluateurs humains experts sur des tâches ouvertes — comparable au taux d'accord entre deux annotateurs humains indépendants.

Métrique → coût → usage privilégié

  • Correspondance exacte / à règles. Coût quasi nul. Sorties structurées, étiquettes, schémas. Trop stricte pour du texte libre.
  • ROUGE / recouvrement de n-grammes. Coût quasi nul. Résumé, traduction. Pénalise les reformulations correctes.
  • BERTScore. Coût faible (modèle local). Toute tâche disposant d'une chaîne de référence. Exige une référence ; rate les erreurs factuelles.
  • LLM comme juge. Coût moyen (appel d'API). Génération ouverte, réponses de RAG. Biais du juge ; exige un calibrage.
  • Évaluation humaine. Coût élevé (temps d'annotation). Vérité terrain et calibrage du juge. Lente, coûteuse, non extensible.

5. Concevoir le prompt du juge

Un juge LLM ne vaut que son prompt de juge. Un prompt vague produit des scores bruités et irréguliers, qui ajoutent de la variance sans ajouter de signal.

Quatre principes de conception

  • Notez, ne comparez pas. Demander au juge de choisir la meilleure de deux sorties introduit un biais de position — il favorise systématiquement celle présentée en premier. Une notation absolue selon une grille est plus régulière et plus facile à interpréter.
  • Définissez chaque niveau de note. « Notez de 1 à 5 » n'est pas une grille. Dites précisément au juge ce qui distingue un 3 d'un 4, sinon les notes se massent au milieu par défaut.
  • Raisonnez avant de noter. Forcer le juge à expliquer avant de s'engager sur une note réduit l'ancrage positionnel et laisse une trace inspectable — le principe de la chaîne de pensée appliqué à l'évaluation.
  • Testez trois biais connus. Le biais de verbosité (plus long est mieux noté, indépendamment de la qualité — pénalisez explicitement la longueur inutile) ; le biais d'auto-complaisance (un modèle qui juge sa propre sortie la surnote — employez une autre famille de modèles) ; le biais de format (le Markdown et les titres sont mieux notés qu'une prose simple de qualité égale — normalisez la mise en forme avant de noter).
LLM comme juge — grille de fidélité System prompt
# Role: faithfulness judge.
You will read a set of source passages and a generated
response. Score how faithfully the response is grounded
in the passages, from 1 to 5.

1 — Response contains claims that directly contradict
    the passages.
2 — Response contains claims not supported by the
    passages, but not directly contradicting them.
3 — Response is mostly grounded, with one unsupported
    but plausible claim.
4 — Response is fully grounded, with minor imprecision
    in phrasing.
5 — All claims are directly traceable to specific
    sentences in the passages.

Reason step by step before scoring. Return JSON:
{"reasoning": "...", "score": 1-5, "issues": [...]}

Shen et al. (2023) ont trouvé les évaluateurs LLM irréguliers et dépendants de la dimension évaluée sur le résumé abstractif — un avertissement précoce : des pipelines de juge non calibrés produisent des signaux peu fiables. Calibrez votre juge sur des annotations humaines avant de lui faire confiance à l'échelle. Si juge et évaluateurs humains divergent sur plus de 25 % des exemples, le correctif est une meilleure grille, pas un modèle plus puissant — c'est presque toujours la précision de la grille qui fait goulot, pas la capacité du modèle.

6. Évaluer les pipelines RAG

Un pipeline RAG comporte deux composants à évaluer indépendamment : la récupération et la génération. N'évaluer que la sortie finale rend impossible la localisation des défaillances — une mauvaise réponse peut signifier que les bons fragments ont été récupérés puis ignorés, ou que les mauvais ont été récupérés puis fidèlement reproduits — les huit fragments hors sujet diluent le signal et peuvent déclencher les défaillances de sur-récupération décrites en leçon 05. Es et al. (2023) introduisent RAGAS, un cadre largement sans référence qui décompose la qualité d'un RAG en quatre métriques indépendantes.

Les quatre métriques RAGAS

  • Rappel du contexte. Les fragments récupérés contiennent-ils de quoi répondre à la question ? Référence nécessaire : oui. Un rappel faible pointe vers le découpage ou la configuration de récupération, pas vers le prompt de génération.
  • Précision du contexte. Quelle proportion des fragments récupérés est réellement pertinente ? Référence nécessaire : non — calculable avec un juge qui note indépendamment la pertinence de chaque fragment.
  • Fidélité. Chaque affirmation de la réponse est-elle étayée par le contexte récupéré ? Référence nécessaire : non. Il ne s'agit pas de savoir si la réponse est correcte, mais si elle est ancrée. Une réponse fidèle bâtie sur un mauvais contexte reste une réussite de fidélité ; c'est un problème de récupération, pas de génération.
  • Pertinence de la réponse. La réponse traite-t-elle réellement la question posée ? Référence nécessaire : non. Calculée en demandant à un juge si la question est entièrement traitée, partiellement traitée ou esquivée — et elle attrape ce schéma d'esquive que les scores de fidélité manquent complètement.

Exécutez les quatre à chaque mise à jour du jeu d'évaluation et suivez-les comme des séries temporelles distinctes. Un changement de prompt qui améliore la fidélité tout en dégradant la précision du contexte vous dit quelque chose de précis sur ce qui a changé — et c'est cette précision qui rend l'itération gouvernable.

7. Tests de régression et intégration continue

Un prompt est un artefact logiciel. Il doit être versionné, relu et testé avant déploiement, exactement comme n'importe quel autre changement de code. L'exigence de fond : dès qu'un prompt change, exécutez toute la suite d'évaluation contre lui et faites apparaître un diff des variations de score. Un changement qui améliore la performance agrégée tout en régressant sur une catégorie précise n'est visible qu'avec des étiquettes de catégorie et une référence historique à laquelle se comparer. Sans cette infrastructure, les régressions se propagent silencieusement en production.

Khattab et al. (2023) posent tout le pipeline de prompt engineering comme un problème de compilation dans DSPy : les prompts sont optimisés automatiquement contre une métrique, la suite d'évaluation servant de fonction objectif. Même sans adopter l'optimisation automatique, l'intuition tient — la suite d'évaluation est la spécification, et l'itération sur les prompts est la procédure de recherche.

Pipeline d'évaluation automatisé — intégration CI Pipeline
1. Load eval dataset (golden set + adversarial cases)
2. Run system on all inputs
3. Score outputs (rule-based + judge, as applicable)
4. Aggregate by category
5. Diff against baseline
6. Post report to PR

# Gate merge on: no category regression > threshold (e.g. 3%).
# Human review required for: any adversarial category change.

Le problème du diff de prompt

De petits changements de formulation peuvent produire de grands changements de sortie, peu évidents. Ajouter « sois concis » peut améliorer la longueur moyenne mais dégrader la fidélité, parce que le modèle omet des nuances. Retirer « Tu es un expert en… » peut légèrement réduire le calibrage de la confiance, d'une manière qui demande cinquante évaluations pour être détectée statistiquement. Les changements de prompt méritent le même examen que du code touchant des chemins critiques — le diff d'évaluation est l'outil de relecture. Un changement dont les scores agrégés sont propres mais qui déplace la distribution des notes individuelles (plus de 3 et de 5, moins de 4) n'est pas neutre ; c'est un changement de fiabilité que l'agrégat masque. Suivez la variance des scores, pas seulement la moyenne.

8. La décision de livrer

La décision de livrer relève du jugement, pas du calcul — mais d'un jugement éclairé par des preuves. L'erreur de livraison la plus fréquente n'est pas de livrer trop tôt ; c'est de livrer sans avoir défini ce que « prêt » veut dire. Une équipe sans score cible défini à l'avance trouvera toujours une raison de juger le score actuel acceptable.

Deuxième erreur courante : prendre la première livraison pour la fin du processus d'évaluation. C'est en production que vit la vraie distribution d'entrées — les requêtes que soumettent de vrais utilisateurs contiennent des schémas que votre jeu de référence n'avait pas anticipés. L'infrastructure d'évaluation bâtie avant le lancement est la référence ; la surveillance en production est ce qui vous dit si cette référence tient. C'est un seul processus continu, pas deux phases distinctes.

Obligatoire

Les bloquants durs à lever avant de livrer. En général : aucune régression sur les catégories hostiles et critiques pour la sécurité, un score de fidélité au-dessus d'un seuil minimal sur tous les types d'entrées, une conformité du format de sortie structuré à 100 % sur le jeu de référence. Non négociable — un système qui échoue sur un bloquant dur ne part pas.

Cible

Le niveau de qualité visé sur les métriques principales (fidélité, pertinence de la réponse, score agrégé du juge). Défini avant la première exécution d'évaluation, pas après — fixer des cibles rétrospectivement, c'est du biais de confirmation sous un autre nom. Si le système atteint la cible, on livre. Sinon, l'écart, c'est le travail qui reste.

Lacunes connues

Catégories d'entrées ou cas limites où le système reste sous la cible sans constituer un bloquant dur. Reconnues, consignées et priorisées pour l'itération suivante. Tout système part avec des lacunes connues — la question est de savoir si elles sont acceptables pour le cas d'usage.

Surveillance

Un plan de ce que vous mesurerez en production : quelles sorties seront échantillonnées, qui les relira, et ce qui déclenche un retour arrière. Évaluer en préproduction et évaluer en production sont toutes deux nécessaires. Aucune ne remplace l'autre.

La leçon 01 établissait qu'un prompt façonne une distribution de probabilité. Chaque leçon depuis portait sur des méthodes pour déplacer cette distribution vers la région des sorties utiles et exactes. L'évaluation est la façon de mesurer si vous y êtes parvenu — non pas sur les exemples pour lesquels vous avez conçu le système, mais sur toute la distribution d'entrées qu'il rencontrera réellement.

Sans évaluation, toute affirmation sur la qualité est un a priori, pas un a posteriori. C'est là que le prompt engineering devient une discipline plutôt qu'un artisanat.
Boucler la boucle de la série

Cette leçon vous a-t-elle été utile ?

FAQ

Questions fréquentes

Les sorties d'un modèle de langage sont stochastiques et de grande dimension : un même prompt produit des sorties différentes d'une exécution à l'autre, si bien que la justesse est une propriété de la distribution des sorties plutôt que d'une exécution isolée. Un prompt excellent sur 80 % des entrées et catastrophiquement faux sur 20 % est un incident en latence — l'évaluation mesure toute la distribution au lieu des exemples que vous avez vérifiés au hasard.

Références

  1. Shankar, S., et al. (2024). Who Validates the Validators? Aligning LLM-Assisted Evaluation of LLM Outputs with Human Preferences. arXiv:2404.12272.
  2. Lin, C.-Y. (2004). ROUGE: A Package for Automatic Evaluation of Summaries. ACL Workshop on Text Summarization Branches Out.
  3. Zhang, T., et al. (2019). BERTScore: Evaluating Text Generation with BERT. ICLR 2020. arXiv:1904.09675.
  4. Zheng, L., et al. (2023). Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena. NeurIPS 2023. arXiv:2306.05685.
  5. Shen, T., et al. (2023). Large Language Models are Not Yet Human-Level Evaluators for Abstractive Summarization. arXiv:2305.13091.
  6. Es, S., et al. (2023). RAGAS: Automated Evaluation of Retrieval Augmented Generation. arXiv:2309.15217.
  7. Khattab, O., et al. (2023). DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. arXiv:2310.03714.
  8. Guo, Q., et al. (2023). Evaluating Large Language Models: A Comprehensive Survey. arXiv:2310.19736.
  9. Anthropic. (2025). Define success criteria and build evaluations. platform.claude.com/docs.

Envie de vous tester ?

10 questions tirées au hasard des six leçons de la Partie I. Sans limite de temps. Partagez votre score.

Faire le quiz

Contact

Un système à construire ?

Si vous montez un pipeline RAG, un workflow d'agents IA ou une intégration MCP et que vous voulez comparer vos notes, échanger des idées, ou simplement éviter les erreurs que j'ai déjà faites — écrivez-moi.

Ou recevez le Playbook par e-mail — un message quand une nouvelle leçon sort, et rien d'autre.

Pas de bruit, pas de spam. Désinscription à tout moment.