Qu’est-ce que l’évaluation des LLM en CI ?
L’évaluation des LLM en CI exécute un jeu de référence (golden set) versionné de vraies questions à chaque changement pouvant modifier les réponses, et bloque quand une vérification exacte échoue ou qu’un score jugé baisse au-delà du bruit mesuré. Un échec nomme les cas ; un succès montre que les cas connus fonctionnent encore, pas que le système est correct.
Des changements d’apparence anodine modifient les réponses : un prompt reformulé, une taille de chunk, une modification de manifeste d’outil, un changement de modèle, que la passerelle IA ne livre qu’une fois le jeu de référence validé. C’est la couche 4 de l’architecture de plateforme IA d’entreprise ; les détails sur DeepEval et Langfuse datent d’octobre 2026.
Le contrôle d’évaluation en un coup d’œil
| À décider | La règle | Où elle se trouve | Comment la tester |
|---|---|---|---|
| Le jeu de référence | De vraies questions, des documents attendus, un comportement par cas | Un fichier JSON relu, à côté du code | Compter les cas par comportement : refus, questions d’un autre tenant |
| Métriques par couche | Recherche, ancrage et pertinence jugés sur les cas de réponse ; vérifications exactes pour le reste | Des tests simples ; DeepEval via evaluate() |
Retirer un document attendu : son cas échoue en recherche |
| Baseline et seuil | Pas pire qu’une baseline relue, métrique par métrique | Un fichier de baseline relu | Dégrader le prompt sur une branche : code 1, cas nommés |
| Bruit et répétitions | Tolérance tirée d’au moins huit exécutions de la version inchangée ; aucune pour l’exact | Le fichier de baseline | Relancer main plusieurs fois : il doit rarement échouer |
| Le juge | Modèle, version, mode et template figés ; calibré sur des annotations humaines | Configuration des métriques et baseline | Changer le modèle juge : code 2 |
| Confiance dans l’exécution | Jeu ou juge modifié, score manquant, erreur : jamais un succès | Première étape du contrôle | Faire échouer un appel au juge : code 2, pas 1 |
| Les traces de production | Une mauvaise réponse devient un cas, avec trace et version de prompt | Traces Langfuse ; le champ origin du cas |
Depuis un cas, ouvrir sa trace et sa version de prompt |
Ce que contient un cas du jeu de référence
Un cas du jeu de référence est une question que quelqu’un a vraiment posée, ou qu’un expert du domaine poserait, assortie de ce qui doit se passer : les documents qui doivent étayer la réponse et un comportement, réponse, refus ou escalade. Deux cas d’illustration, avec les noms de champs des goldens de DeepEval :
[
{
"input": "How long do customers in Spain have to return an order?",
"expected_output": "Thirty days from delivery.",
"additional_metadata": {
"id": "returns-window-es",
"behaviour": "answer",
"tenant": "tenant-a",
"expected_sources": ["policies/returns-eu"],
"origin": "trace 3f9c2a, prompt returns-assistant v12"
}
},
{
"input": "What penalties does the Northwind contract set?",
"additional_metadata": {
"id": "other-tenant-contract",
"behaviour": "refusal",
"tenant": "tenant-a",
"expected_sources": [],
"origin": "security review"
}
}
]
Les sources attendues nomment des documents, pas des chunks, pour qu’un nouveau découpage laisse les cas valides. expected_output est la réponse de référence qu’exigent les métriques contextuelles de DeepEval : les métriques jugées ne portent donc que sur les cas de réponse ; les autres ont des vérifications exactes. Un jeu digne de bloquer une livraison réunit quatre types de cas : des réponses que les documents étayent ; des refus, quand aucun document ne répond ; des questions d’un autre tenant, refusées aussi ; des escalades, comme une demande d’effacement qui doit parvenir à une personne. Ajoutez des cas difficiles et hostiles : questions ambiguës, documents quasi identiques, extraction de données personnelles, instructions glissées dans un document.
Le fichier évolue par revue, comme du code, et a un responsable. Coût : une curation permanente. Test : analysez-le en CI ; un identifiant en double, une réponse sans source ou un cas sans origine font échouer le build.
Combien de cas faut-il dans un jeu de référence ?
Quelques dizaines de cas relus, refus compris, suffisent à contrôler un comportement connu : chacun est une vérification nommée qu’un changement peut casser. Ils ne mesurent pas un taux. Prenez quarante cas dont trente-six réussis : l’intervalle de score de Wilson va, au niveau habituel de quatre-vingt-quinze pour cent, d’un peu plus de trois sur quatre à environ vingt-quatre sur vingt-cinq, et suppose un échantillon aléatoire, ce qu’un jeu choisi n’est pas.
Le contrôle peut donc dire « ces cas passent encore », jamais « l’assistant a raison neuf fois sur dix ». Un léger écart du nombre de cas réussis reste invisible à cette taille, comme une baisse sur des questions absentes du jeu. Faites grandir le jeu à partir des échecs de production : chaque mauvaise réponse vue par un utilisateur est un cas qui manquait. Test : pour chaque échec récent en production, retrouvez son cas.
Les métriques par couche, et la place de DeepEval
Mesurez chaque couche séparément, pour qu’un échec désigne sa cause.
- Recherche : les documents attendus figurent-ils parmi ceux retrouvés ? Calculez-le en code depuis
expected_sources. Le rappel contextuel (contextual recall) et la précision contextuelle (contextual precision) de DeepEval jugentretrieval_contextau regard d’expected_output: le rappel, si les affirmations de la réponse de référence peuvent être attribuées aux passages retrouvés ; la précision, si les passages pertinents sont classés avant les autres. Sous un filtre de tenant, utilisez le test de rappel du guide RAG, face à une recherche exacte. - Ancrage : la fidélité (faithfulness) fait confronter par un juge les affirmations de la réponse à l’ensemble de
retrieval_context. Une affirmation compte comme vraie tant qu’elle ne contredit pas les passages ; les ambiguës comptent sauf sipenalize_ambiguous_claimsest activé. À mon sens, une affirmation non étayée mais compatible passe : le contrôle des citations reste dans le code. - Pertinence : la pertinence de la réponse (answer relevancy), à partir de
inputetactual_output: la part des affirmations de la réponse qui concernent la question. - Comportement : refus, escalade, aucun document d’un autre tenant cité, données personnelles masquées. Des vérifications exactes, jamais un juge.
- Budgets : latence et coût par requête, chacun avec un seuil traité comme une vérification exacte.
Par défaut, ces métriques reposent sur un LLM juge et valident un cas dès 0,5. DeepEval conseille de contrôler par des tests unitaires, où assert_test fait échouer tout cas sous son seuil. Il admet pourtant que les cas proches du seuil basculent d’une exécution à l’autre. Pour les scores jugés, je m’en écarterais : les collecter avec evaluate(), enregistrer chaque exécution avec results_folder et laisser trancher un script. Le coût : maintenir ce script et sa boucle de répétitions, sans la comparaison de baseline de DeepEval, qui passe par son service hébergé Confident AI.
Le contrôle : une baseline relue et une tolérance mesurée
Je garderais la baseline dans un fichier du dépôt : l’empreinte du jeu, l’identité du juge, les versions de l’application et, par métrique, la moyenne et une tolérance. Partez des scores d’aujourd’hui, pour que le premier contrôle soit « pas pire qu’aujourd’hui », et relisez-la. Ne l’écrivez jamais à partir de l’exécution testée, comme le rappelle la documentation CI de Langfuse.
Les vérifications exactes, je les appliquerais cas par cas : un cas de refus qui répond, dans n’importe quelle répétition, bloque. Les métriques jugées, je les contrôlerais sur la moyenne, même si les deux outils documentent des contrôles cas par cas. Avec trois répétitions indépendantes, un cas qui réussit une fois sur deux les rate toutes lors d’une exécution sur huit. La moyenne peut masquer un cas jugé cassé : ce qui ne doit jamais casser reçoit donc une vérification exacte, et le contrôle affiche les cas jugés en plus forte baisse.
Pour la tolérance, je lancerais la version inchangée au moins huit fois, avec des répétitions indépendantes, hors cache DeepEval : la baseline est la moyenne de ces exécutions, la tolérance le plus grand écart entre leurs moyennes. Une version inchangée échoue encore parfois : avec un bruit à peu près normal et indépendant, quatre métriques jugées et huit exécutions de baseline, environ une exécution sur dix-huit ; avec cinq seulement, une sur six. Moyenner des répétitions indépendantes divise la dispersion d’une moyenne par la racine carrée de leur nombre (NIST).
Je lancerais les vérifications exactes et un sous-ensemble jugé à chaque pull request, le jeu complet avec répétitions avant livraison, et chaque nuit, pour ce qui échappe aux pull requests : documents de l’index, label de prompt déplacé dans Langfuse, état de cycle de vie d’un modèle sur Bedrock. Avant la livraison du troisième produit, l’ordre de construction laisse de côté une grande suite jugée : quelques dizaines de cas relus, avec vérifications exactes, suffisent.
Pire, ou comparaison impossible : ce que signifie un échec
Les remèdes diffèrent : un contrôle en échec doit dire ce qui a échoué. pytest, sur lequel s’appuie le lanceur de tests de DeepEval, distingue les tests en échec (code de sortie 1) des erreurs internes (3) ; je donnerais au contrôle trois issues, le code 2 étant ma propre convention :
- Comparaison impossible, code de sortie 2 : le jeu ou le juge diffère de la baseline, il faut la refaire ; ou un appel au juge a échoué, un score manque, il faut relancer. Le contrôle doit intercepter les erreurs pour renvoyer 2 : une exception non interceptée sort avec 1.
- Pire, code de sortie 1 : une vérification exacte ou un budget a échoué, une moyenne jugée est sortie de sa tolérance, ou l’application a levé une erreur sur un cas, cas nommés à l’appui.
- Succès, code de sortie 0, listant quand même les cas jugés en plus forte baisse.
Je ferais porter à toute pull request qui modifie le jeu sa nouvelle baseline, calculée sur la branche de base et relue avec les cas. N’activez pas l’option de DeepEval qui ignore les erreurs : un contrôle qui saute des cas a cessé de mesurer. Test : faites échouer un appel au juge ; le job sort avec le code 2.
Les juges LLM : les figer, les calibrer, laisser l’exact au code
Un juge fait partie de la mesure : figez-le comme une dépendance, modèle, version de DeepEval, mode d’évaluation et template éventuel, consignés dans la baseline. Sans model, le juge est celui que configure la machine de CI, ou gpt-5.4 d’OpenAI, appelé hors de la passerelle et de sa règle UE. Je passerais un modèle personnalisé qui appelle la passerelle et garderais le mode d’évaluation llm : hybrid et system_one appellent Jev, de TypeSafe AI, et hybrid se rabat sur le LLM quand un appel à Jev échoue.
Zheng et al. (2023) ont observé des biais de position et de verbosité, et des juges induits en erreur par les réponses qu’ils notaient. Ils relèvent aussi que les scores absolus risquent de fluctuer davantage que les comparaisons par paires quand le modèle juge change. D’où une nouvelle baseline à chaque changement de juge, et des vérifications déterministes pour tout ce qui est exact.
Calibrez avant de faire confiance : faites annoter un échantillon par des experts, comparez avec le juge et regardez d’abord les faux succès. L’analyse des scores de Langfuse mesure l’accord entre deux scores sur les mêmes traces. Test : soumettez au juge un cas qu’une personne a rejeté ; il le rejette aussi.
Les traces de production deviennent des cas du jeu de référence
Rattachez chaque trace de production à ce qui l’a produite : dans Langfuse, lier les prompts aux traces donne des métriques par version de prompt, et une release fixée au commit désigne le code. Quand une trace montre une mauvaise réponse, reproduisez-la, corrigez la cause et ajoutez le cas, avec l’identifiant de trace et la version de prompt dans origin. Langfuse peut créer un élément de dataset à partir d’une trace ; j’en ferais la boîte de réception des cas à relire, que l’effacement doit alors atteindre aussi.
Une question de production peut contenir des données personnelles, et un cas copié les place dans Git, où l’effacement est difficile : réécrivez-la et ne gardez que l’identifiant de trace. Langfuse sert par ailleurs la version étiquetée production quand aucun label n’est demandé (gestion des versions) : déplacer ce label déploie donc un prompt sans pull request. Lancez le jeu avant de le déplacer.
En pratique
Sur la plateforme d’ENSO, j’ai spécifié des contrôles d’évaluation en CI fondés sur DeepEval, des jeux de référence et le traçage Langfuse, comme une couche d’une plateforme qui comprend aussi une passerelle, la recherche et des actions d’agents gouvernées. L’architecture d’ensemble est décrite dans le guide de référence de la plateforme IA d’entreprise et dans l’étude de cas ENSO, et ce type de contrôle fait partie du service de plateforme LLM d’entreprise.
Compromis et limites
L’évaluation coûte des appels au juge par métrique, par cas et par répétition, et chaque nouvelle baseline coûte au moins huit exécutions complètes. Une baseline devient caduque quand le jeu ou le juge change, et les anciens scores ne se comparent plus.
Les jeux de référence vieillissent quand les produits et les documents changent, et une équipe peut sur-ajuster en retouchant ses prompts jusqu’à ce que son propre jeu passe. Renouvelez-le depuis la production plus vite que vous ne réglez vos prompts dessus.
Un produit sans trafic n’a pas de traces : partez des questions écrites par des experts et de ce que les documents ne couvrent pas, puis remplacez-les à mesure qu’arrivent de vraies questions.
Un contrôle qui passe montre que les cas connus fonctionnent encore, pas que le système est correct : la relecture humaine de vraies conversations reste.
Questions fréquentes
Qu’est-ce qu’un jeu de référence pour une application LLM ?
Un fichier versionné de vraies questions, gardé à côté du code, chacune avec les documents qui doivent étayer la réponse et le comportement attendu : réponse, refus ou escalade. Il s’exécute à chaque changement de prompt, de modèle, de réglage de recherche ou de manifeste d’outil, et n’évolue que par revue.
Combien de cas de test faut-il dans un jeu de référence ?
Quelques dizaines de cas relus, refus compris, suffisent à contrôler un comportement connu : chacun est une vérification nommée. Ils ne mesurent pas un taux : avec quarante cas et un taux de réussite proche de neuf sur dix, la plage plausible est large d’environ un cinquième. Faites-le grandir à partir des échecs de production.
Comment gérer des résultats d’évaluation LLM instables ?
Jamais dans les vérifications exactes : un cas de refus qui répond parfois est un défaut. Pour les métriques jugées, je contrôlerais la moyenne de chaque métrique face à une tolérance tirée d’au moins huit exécutions indépendantes de la version inchangée, en acceptant un rare échec à tort. Répéter réduit le bruit, pas le manque de couverture.
Peut-on faire confiance à un LLM juge ?
Dans certaines limites. Figez son modèle, sa version de bibliothèque, son mode d’évaluation et son template ; refaites la baseline dès que l’un change. Calibrez-le sur des annotations humaines, faux succès d’abord. La recherche a relevé des biais de position et de verbosité, et des juges trompés par les réponses notées : ce qui se vérifie exactement reste déterministe.
Sources
- DeepEval (rappel, précision, fidélité, pertinence, modes, datasets, CI, options) : métriques, juges, goldens, contrôle, exécutions, erreurs.
- Langfuse (CI/CD, analyses, prompts, releases, datasets, labels) : baselines, accord, traces, labels.
- Zheng et al. (2023) : biais des juges.
- NIST/SEMATECH (Wilson, moyenne) : incertitude d’un taux, répétitions.
- Codes de sortie de pytest : types d’échec.
- Cycle de vie des modèles Bedrock : états du cycle de vie.