Un modèle IA qui dérive ne tombe pas en panne. Il continue de répondre, de moins en moins bien, et personne ne le voit avant qu'un utilisateur ne s'en plaigne. La seule façon fiable de le détecter avant ce moment, c'est de rejouer régulièrement un jeu de cas réels validés par vos experts et de surveiller un score, avec des seuils d'alerte et une personne désignée pour les lire.
Un modèle ne casse pas, il dérive : ce que cela change pour la supervision
Une application classique a un comportement binaire : le code fonctionne ou lève une erreur, et l'erreur remonte dans les journaux. La supervision traditionnelle repose sur cette logique. Elle reste indispensable pour un système IA, mais elle ne suffit plus, et c'est ce qui distingue une maintenance supervisée d'un système IA d'une maintenance classique.
Un modèle de langage ou un classifieur répond toujours quelque chose. Quand la qualité baisse, la réponse arrive dans les délais, sans code d'erreur, avec une mise en forme correcte. Le serveur est vert. Le tableau de bord est vert. Pourtant, l'assistant juridique cite un article de loi abrogé, l'agent de qualification des demandes d'un service client classe en « réclamation » ce qui est une simple question, et le résumé de compte rendu oublie la décision prise en réunion.
La dérive est donc un problème de mesure avant d'être un problème technique. Si vous ne mesurez pas la qualité des réponses, vous ne saurez pas qu'elle baisse. Et une fois mesurée, il reste à décider ce qui constitue une baisse anormale et qui doit être prévenu.
Pourquoi un modèle se dégrade sans que personne n'y touche
Quatre causes reviennent, souvent combinées.
La version du modèle chez l'éditeur. Les fournisseurs de modèles remplacent régulièrement une version par une autre, parfois de manière transparente derrière un même nom. Une mise à jour peut améliorer la moyenne des cas et dégrader précisément votre cas. Le phénomène est mesuré : des chercheurs de Stanford et de Berkeley ont comparé deux versions de GPT-4 publiées sous le même nom à trois mois d'intervalle. Sur une tâche simple, dire si un nombre est premier, la précision est passée de 84 % en mars 2023 à 51 % en juin 2023 (Chen, Zaharia et Zou, 2023). L'application qui appelait ce modèle n'avait, elle, pas changé d'une ligne.
Le prompt retouché. Une consigne modifiée « pour corriger un cas » en modifie dix autres sans que personne ne s'en aperçoive. Exemple type : on ajoute une phrase pour que l'assistant réponde plus court, et l'assistant cesse de citer ses sources.
La base documentaire qui vieillit. Un assistant qui s'appuie sur une base de connaissances (RAG) répond à partir de documents. Si la grille tarifaire, la procédure ou la réglementation a changé et que la base ne l'a pas suivi, le modèle répond avec assurance quelque chose de faux. Ce n'est pas le modèle qui dérive, c'est son environnement, mais le résultat pour l'utilisateur est le même.
L'usage qui change. Le système a été conçu pour un périmètre. Six mois plus tard, une nouvelle équipe l'utilise pour autre chose, les questions posées ne ressemblent plus à celles du lancement, et le modèle se retrouve hors de sa zone de confiance. Un agent de tri de courrier entrant calibré sur des demandes de devis se met à recevoir des litiges, et les traite comme des devis.
Les signaux que vos équipes envoient avant la DSI
Avant toute mesure formelle, la dérive se voit dans le comportement des équipes. Ces signaux arrivent tard, mais ils sont faciles à repérer.
Les reprises humaines augmentent. Un opérateur corrige la sortie du modèle avant de l'envoyer. Au début, une fois sur vingt. Puis une fois sur cinq. Personne ne le signale, parce que corriger prend trente secondes et que remonter un problème prend une réunion. Si votre application trace l'écart entre la proposition du modèle et la version finale, ce taux de reprise est votre premier indicateur.
Les plaintes arrivent par des canaux détournés. Un commercial dit en passant que « l'assistant raconte n'importe quoi sur les délais ». Un client final signale une réponse erronée au support, qui ne fait pas le lien avec l'IA. Ces remarques ne remontent jamais jusqu'à la DSI si aucun circuit n'est prévu pour elles.
Les contournements s'installent. C'est le symptôme le plus coûteux et le plus silencieux. Une équipe qui ne fait plus confiance à l'outil revient au tableur ou au collègue expert. L'application tourne, l'éditeur facture l'inférence, mais la valeur produite est nulle. Le dirigeant le découvre souvent lors d'un point budgétaire : le coût est stable, personne n'utilise le système.
Ces trois symptômes arrivent plusieurs semaines après la cause. Quand ils apparaissent, la dérive est déjà installée. Le jeu d'évaluation sert à la voir avant.
Constituer un jeu d'évaluation avec vos experts
Un jeu d'évaluation est une liste de cas d'entrée réels, chacun accompagné de la réponse attendue ou d'un critère de jugement. Il ne vérifie pas que le code fonctionne, il vérifie que le système produit des réponses qu'un expert du métier considère correctes.
Partir des vrais cas, pas de cas inventés. Prenez des demandes réelles tirées des journaux d'utilisation, anonymisées si nécessaire. Les cas inventés par l'équipe technique sont trop propres : les vrais contiennent les fautes de frappe, les questions ambiguës et les documents mal scannés qui font la différence en production.
Faire valider la réponse attendue par la personne qui fait le travail. Pour un assistant de réponse aux appels d'offres, c'est le chargé d'affaires. Pour un extracteur de factures fournisseurs, c'est le comptable. Une demi-journée avec deux experts suffit à qualifier une cinquantaine de cas. Ce temps est le seul investissement humain non négociable de toute la démarche.
Couvrir les cas qui font mal. Le jeu doit contenir les cas courants, mais surtout les cas où une erreur a un coût : une clause de résiliation mal interprétée, un montant avec une virgule décalée, une question à laquelle le modèle doit répondre « je ne sais pas » plutôt que d'inventer. Chaque incident passé devient un cas du jeu : s'il se reproduit, le rejeu suivant le montre.
Le scénario d'une IA qui hallucine en production montre ce qui arrive sans lui. Retenez surtout que cinquante cas bien choisis et validés valent mieux que cinq cents cas générés automatiquement.
Rejouer à intervalle régulier et à chaque changement
Un jeu d'évaluation ne sert que s'il est rejoué. On le rejoue dans deux cas.
Le rejeu planifié. Chaque semaine, ou chaque nuit pour les systèmes critiques, l'ensemble des cas est soumis au système dans les conditions de la production et les réponses sont comparées aux attendus. Le résultat est un score, ou plusieurs scores par famille de cas. Ce rejeu attrape les dérives dont vous n'êtes pas à l'origine : version de l'éditeur, base documentaire qui vieillit.
Le rejeu à chaque changement. Avant toute mise en production (prompt, modèle, base, version de l'application), le jeu est rejoué et le score comparé au précédent. Une baisse bloque la mise en production. C'est ce mécanisme qui aurait évité à l'assistant de l'exemple plus haut de perdre ses sources.
Pour un classifieur ou un extracteur, la comparaison est exacte : la valeur est bonne ou fausse. Pour un modèle qui génère du texte, il faut un juge : une grille de critères appliquée par un second modèle, ou une relecture humaine sur un échantillon. Ce qui compte, c'est que le critère reste stable dans le temps, sinon on ne mesure plus la dérive du système mais celle du juge.
Ces pratiques relèvent de ce que le secteur appelle le LLMOps. Nous en donnons une vue d'ensemble dans notre article sur la mise en production des systèmes IA.
Fixer des seuils et décider qui lit l'alerte
Un score qui n'est lu par personne ne sert à rien. Deux décisions à prendre dès la mise en place.
Le seuil. On fixe une valeur de référence au lancement, puis une tolérance. Une baisse de quelques points sur une semaine peut être du bruit, en particulier avec un juge automatique. Une baisse marquée, ou une baisse lente mais continue sur plusieurs rejeux, doit déclencher une alerte. Il est utile d'avoir deux niveaux : un niveau d'attention, qui ouvre une analyse, et un niveau critique, qui justifie de désactiver une fonction ou de revenir à la version précédente.
Le destinataire. L'alerte doit arriver à quelqu'un dont c'est la responsabilité, pas dans une boîte générique. Dans une PME, c'est souvent le responsable métier qui a validé les cas, en binôme avec la personne en charge du système. Ce point est fréquemment oublié : l'alerte part, et personne ne l'ouvre parce que le destinataire a changé de poste ou que le canal a été archivé.
Le seuil se révise. Un seuil trop sensible génère des alertes ignorées, un seuil trop laxiste laisse passer la dérive. La bonne valeur se trouve en observant quelques mois, pas en la fixant a priori.
Distinguer dérive du modèle et dérive des données d'entrée
Quand le score baisse, la première question à poser n'est pas « le modèle est-il moins bon ? » mais « qu'est-ce qui a changé ? ». La réponse dépend de ce qui a bougé.
Le modèle a changé, les données non. Si le score baisse alors que les cas du jeu n'ont pas bougé, c'est le système qui a changé : version de modèle, prompt, base documentaire, paramètre d'inférence. L'analyse consiste à retrouver la modification, ce qui suppose que chaque changement soit tracé et daté.
Les données ont changé, le modèle non. Le score du jeu est stable, mais les reprises humaines augmentent et les utilisateurs se plaignent. Ici, ce sont les demandes réelles qui ne ressemblent plus au jeu. Le système est toujours aussi bon sur les cas d'hier, il est mauvais sur les cas d'aujourd'hui. Exemple type : un fabricant ouvre son assistant de devis à l'export, les demandes arrivent en anglais et en allemand, avec des unités et des normes différentes, et le jeu ne contient que des cas français.
Pour détecter ce second type de dérive, on compare la distribution des demandes réelles à celle du jeu (langue, longueur, vocabulaire, catégories), et un échantillon mensuel de demandes réelles, relu par un expert, vient enrichir le jeu. Sans cet entretien, le jeu vieillit comme la base documentaire et l'indicateur devient rassurant sans être juste.
Ce qu'on fait une fois la dérive confirmée
Une fois la dérive confirmée et sa cause identifiée, quatre actions sont possibles, de la plus rapide à la plus lourde.
Revenir en arrière. Si la cause est un changement que vous maîtrisez (prompt, version d'application), le retour à la version précédente est la solution la plus rapide, à condition de l'avoir conservée. Si l'éditeur a changé de version, il faut vérifier que l'ancienne reste disponible, et pour combien de temps.
Remettre à jour l'environnement. Base documentaire vieillie, référentiel produit obsolète, index de recherche non reconstruit. C'est souvent la correction la moins technique et la plus négligée, parce qu'elle appartient au métier plus qu'à l'informatique.
Ajuster le système. Reformuler le prompt, ajouter des exemples pour les nouveaux types de demandes, réentraîner un classifieur avec les cas récents. Chaque ajustement passe par un rejeu complet avant mise en production, pour ne pas corriger un cas en cassant les autres.
Anticiper la dépréciation. Les éditeurs annoncent la fin de vie de leurs modèles avec un préavis court : Anthropic, par exemple, s'engage à prévenir au moins 60 jours avant le retrait d'un modèle public (politique de dépréciation d'Anthropic). Un système non migré avant la date limite cesse de fonctionner, sans dérive progressive cette fois. La supervision inclut donc une veille sur ces calendriers et une migration planifiée, testée sur le jeu avant la bascule.
Tout cela suppose une méthode et, surtout, une personne qui regarde. Dans la plupart des PME et des ETI, cette personne n'existe pas en interne, et le système IA livré il y a un an vit sans surveillance. C'est le périmètre d'une offre de maintenance des modèles et agents IA : jeu d'évaluation constitué avec vos experts et rejoué, seuils d'alerte lus par quelqu'un, suivi des coûts d'inférence et des dépréciations, rapport d'activité. Les engagements sont écrits et définis au contrat après un audit du système existant, et le code comme les accès restent chez vous.
Cette supervision s'inscrit dans une démarche plus large d'industrialisation des systèmes IA, qui couvre aussi le code, les intégrations, l'infrastructure et le suivi du coût d'inférence. Un modèle bien surveillé sur une application qui ne l'est pas ne tient pas longtemps.









