Texte et journaux inhabituels avec les plongements
- Leçon 26
- 40 min
- Module 6 : Méthodes profondes et plongements
Où nous en sommes
Nos détecteurs travaillent sur des nombres. Les lignes de journal sont du texte, et un nouveau type d'erreur produit un nouveau type de message. Dans cette leçon, nous transformons d'abord les lignes de journal en gabarits, une méthode peu coûteuse et souvent suffisante. Ensuite, nous utilisons les plongements pour trouver les messages éloignés de tous les messages connus.
Leçon 26 sur 38 · Détection d'anomalies : trouver ce qui est inhabituelTexte et journaux inhabituels avec les plongements
1. Ce que « inhabituel » veut dire
2. Des références de base simples et difficiles à battre
3. Maîtrise statistique des procédés et dérive de distribution
- Cartes de contrôle : cette variation est-elle normale?
- Règles pour les motifs, et le prix de chaque règle
- Cartes pour les taux et les dénombrements
- Petits décalages durables : CUSUM et EWMA
- La distribution a-t-elle changé?
- Dérive dans de nombreuses variables, et quoi faire
- Loi de Benford et autres vérifications d'affaires
4. Distance, densité et isolement
5. Les anomalies dans le temps
6. Méthodes profondes et plongements
7. Évaluer avec peu d'étiquettes
8. Apprendre des réviseurs
9. Exploiter un détecteur en production
Ce que vous saurez faire
Trouvez un nouveau type de message dans les journaux d’un service. Commencez par les gabarits, peu coûteux et souvent suffisants. Utilisez ensuite les plongements pour classer les quelques nouveaux messages selon leur différence. Découvrez pourquoi « différent » ne veut pas dire « dangereux ».
Carnet JupyterFaites cette leçon dans un carnet
Le carnet (notebook) Jupyter contient toutes les cellules de code, tâches et vérifications de cette leçon. Ses cellules de préparation installent pandas, PyTorch et sentence-transformers. Elles téléchargent les journaux (environ 2 Mo) et un petit modèle de plongement (environ 91 Mo). Environ 40 minutes.
Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Comment exécuter les carnets du cours, dans Découvrir les données de Larkfield.
- Ce que « connu » et « nouveau » signifient pour une période de référence, dans Le normal change avec l’heure et la saison.
- Connaître les plongements aide, mais n’est pas obligatoire. Jetons et plongements, dans L’apprentissage profond et les transformeurs expliqués, les présente. La leçon Les plongements pour la recherche, dans RAG : créer une IA qui utilise vos données, les présente aussi. Cette leçon explique les éléments qu’elle utilise.
Ce qu’il vous faut sur votre ordinateur
Un navigateur et un compte Google ou Kaggle gratuit pour le carnet, ou l’installation locale de Découvrir les données de Larkfield. Le modèle de plongement fonctionne sur un processeur. Il ne nécessite aucun compte ni service payant.
Testé avec Python 3.12.13 dans Jupyter sur macOS, avec sentence-transformers 6.2.0 et le modèle all-MiniLM-L6-v2. Colab, Kaggle et Windows n’ont pas été testés.
Un nouveau bruit dans la voiture
Section intitulée « Un nouveau bruit dans la voiture »Vous conduisez la même voiture chaque jour. Vous connaissez ses bruits : le moteur, le clignotant, le roulement des pneus sur l’autoroute. Vous n’y pensez pas. Puis, un matin, vous entendez un clic quand vous tournez à gauche. Vous ne savez pas ce qu’il signifie. Mais vous savez tout de suite qu’il est nouveau.
Certains nouveaux bruits sont sans danger. De nouveaux pneus produisent un bruit différent. D’autres sont sérieux : un clic dans la direction. Votre oreille vous dit « nouveau ». Elle ne vous dit pas « dangereux ». Pour le savoir, vous devez vérifier.
Les journaux (logs) d’un service fonctionnent de la même façon. La plupart des lignes sont les bruits habituels. Un nouveau type de message est le clic.
Les journaux d’Amira
Section intitulée « Les journaux d’Amira »Amira développe le service ticket-api du centre de soutien. Le service écrit une ligne de journal chaque fois qu’un événement survient : requête, requête SQL lente, courriel envoyé, erreur. Chaque ligne contient une heure, un niveau (INFO pour les événements normaux, WARN pour un avertissement, ERROR pour un échec) et un message. Voici six lignes du premier matin des données, le 1er septembre 2025 :
| Heure | Niveau | Message |
|---|---|---|
| 00:01:02 | INFO | GET /tickets/T-472971 200 in 39 ms |
| 00:05:50 | INFO | GET /tickets/T-421326 200 in 58 ms |
| 00:08:43 | WARN | slow query on tickets table took 1434 ms |
| 00:14:16 | INFO | worker 4 picked job J-1945010 (queue depth 9) |
| 00:26:45 | ERROR | upstream timeout calling email-service after 1207 ms |
| 00:28:24 | INFO | sent reply email for ticket T-410889 (2579 bytes) |
Les données contiennent 137 013 lignes sur 60 jours, soit environ 2 500 par jour. Personne ne les lit toutes. Amira leur demande une seule chose : « dites-moi quand le service dit quelque chose qu’il n’a jamais dit auparavant ».
Le problème : presque chaque ligne est nouvelle
Section intitulée « Le problème : presque chaque ligne est nouvelle »L’idée la plus simple consiste à conserver tous les messages des deux premières semaines, du 1er au 14 septembre. Puis à signaler chaque message suivant qui ne figure pas dans cette liste. Essayez avec les données. Les deux premières semaines contenaient 24 693 messages différents. Ensuite, 108 393 lignes sont arrivées, dont 91 023 avec un message jamais vu auparavant. Cela représente 84 %, soit environ 2 126 « nouvelles » lignes par jour.
Ce détecteur est inutile. Les deux lignes GET ci-dessus représentent le même événement, avec un autre numéro de billet et une autre durée en millisecondes. Les données contiennent 108 502 messages différents, mais seulement quelques dizaines de phrases différentes. Les identifiants et les nombres rendent presque chaque ligne unique.
Gabarits : la phrase sans ses nombres
Section intitulée « Gabarits : la phrase sans ses nombres »La solution reprend l’idée que la personne au volant utilise sans y penser. « Un clic quand je tourne à gauche » est un seul bruit, le lundi comme le mardi. Un gabarit est un message de journal dont les parties variables sont remplacées par un masque. Le masque <id> remplace l’identifiant d’un billet, d’une tâche, d’une requête ou d’un agent. Le masque <num> remplace un nombre. Le carnet le fait avec quatre motifs de recherche et remplacement :
MASKS = [(re.compile(r"\b[TJ]-\d+\b"), "<id>"), (re.compile(r"\bq-[0-9a-f]+\b"), "<id>"), (re.compile(r"\b[AK]-\d+\b"), "<id>"), (re.compile(r"\d+(\.\d+)?"), "<num>")]
def template(message): """Replace the parts that change (IDs, numbers) with <id> and <num>.""" for pattern, mask in MASKS: message = pattern.sub(mask, message) return messageVoici de nouveau les six lignes, sous forme de gabarits :
| Message | Gabarit |
|---|---|
GET /tickets/T-472971 200 in 39 ms |
GET /tickets/<id> <num> in <num> ms |
GET /tickets/T-421326 200 in 58 ms |
GET /tickets/<id> <num> in <num> ms |
slow query on tickets table took 1434 ms |
slow query on tickets table took <num> ms |
worker 4 picked job J-1945010 (queue depth 9) |
worker <num> picked job <id> (queue depth <num>) |
upstream timeout calling email-service after 1207 ms |
upstream timeout calling email-service after <num> ms |
sent reply email for ticket T-410889 (2579 bytes) |
sent reply email for ticket <id> (<num> bytes) |
Les deux lignes GET ont maintenant le même gabarit. Pour l’ensemble des lignes, le carnet affiche :
137,013 lines, 108,502 different messages, 36 templates, in 0.24 sLes 108 502 messages ne représentent que 36 gabarits. La création des gabarits a pris 0,24 seconde sur la machine de test, soit environ 2 microsecondes par ligne. Les vrais systèmes de journalisation utilisent souvent un analyseur de journaux, comme Drain, qui apprend les masques lui-même. L’idée est la même.
Trois nouveaux gabarits
Section intitulée « Trois nouveaux gabarits »Maintenant, « nouveau » signifie « un gabarit qui n’est jamais apparu pendant les deux premières semaines ». Le carnet trouve 33 gabarits pendant ces semaines et 3 nouveaux ensuite :
33 templates in the first two weeks; 3 new ones after them: first_seen linestemplatefeature flag new-reply-editor is on for <num>% of agents 2025-09-16 19:25:26.448 878unhandled exception in update_ticket: KeyError: 'priority' 2025-10-08 14:05:16.494 59cache pool exhausted, request <id> waited <num> ms for a connection 2025-10-20 10:02:19.778 4757De 91 023 « nouvelles » lignes à 3 nouveaux gabarits. Chacun a une histoire, racontée par la liste des mises en production et des changements du service :
- L’indicateur de fonctionnalité (INFO, à partir du 16 septembre). L’équipe a activé un nouvel éditeur de réponses pour certains agents. Un indicateur de fonctionnalité est un interrupteur qui active une nouvelle fonctionnalité pour certains utilisateurs. Il est sans danger : nous l’avons inséré comme changement normal.
- Le
KeyError(ERROR, 59 lignes le 8 octobre). La version 4.12.0 a été mise en production à 14 h 05. Une fonction a échoué à cause d’un champ manquant,priority. L’équipe est revenue à la version précédente à 14 h 45. C’est un vrai problème. - Le pool du cache (WARN, 4 757 lignes à partir du 20 octobre). À 10 h ce jour-là, un changement de configuration a réduit le pool du cache : de 64 connexions à 16. Deux minutes plus tard, les requêtes ont commencé à attendre une connexion. C’est un vrai problème, et il persiste.
Toute la méthode tient dans une image :
Description textuelle du diagramme
Le diagramme montre un flux de gauche à droite. Il commence par une ligne de journal : « pool du cache épuisé, la requête q-3f0097 a attendu 877 ms ». La case suivante crée son gabarit en masquant les identifiants et les nombres. Puis vient une question : ce gabarit a-t-il été vu pendant les deux premières semaines? Si oui, le gabarit est connu, et nous le comptons seulement. Sinon, c’est un nouveau gabarit; il y en a eu 3 en 60 jours. Chaque nouveau gabarit passe à l’étape du plongement : 384 nombres et la similarité cosinus avec le gabarit connu le plus proche. La dernière case indique qu’Amira lit les nouveaux gabarits, les plus différents en premier.
Les gabarits ont trouvé chaque nouveau type de message, avec quelques lignes de code et sans modèle. Pour le service d’Amira, cela suffit souvent. Mais les gabarits peuvent seulement dire « nouveau » ou « connu ». Ils ne peuvent pas dire « un peu nouveau » ou « très nouveau ». Et pour du texte sans phrases fixes, comme celui d’un billet de soutien d’un client, il n’y a aucun gabarit.
Plongements : une carte du sens
Section intitulée « Plongements : une carte du sens »Pensez à une carte de ville. Deux cafés sur la même rue sont proches sur la carte. Un café et un stationnement à l’autre bout de la ville sont éloignés. Un plongement (embedding) est une carte de ce genre pour les phrases. Un petit réseau de neurones, un modèle de plongement, transforme chaque phrase en une liste de nombres. Il a été entraîné pour que les phrases de sens semblable produisent des listes semblables.
Le cours utilise le modèle all-MiniLM-L6-v2 (90,9 Mo, licence Apache-2.0, fonctionne sur un processeur). Il transforme chaque phrase en 384 nombres. Le carnet fixe sa version exacte pour que tout le monde obtienne les mêmes nombres.
À quel point deux listes de nombres sont-elles proches?
Section intitulée « À quel point deux listes de nombres sont-elles proches? »La similarité cosinus compare la direction de deux listes. Elle vaut 1 quand elles pointent dans la même direction, 0 quand elles n’ont rien en commun, et une valeur intermédiaire autrement. La longueur d’une liste est la racine carrée de la somme des carrés de ses nombres. Quand les deux listes ont une longueur de 1, le cosinus est la somme des produits de leurs nombres.
Un petit exemple avec 2 nombres plutôt que 384 (construit) :
| Phrase | Plongement | Cosinus avec A |
|---|---|---|
| A | (1,0, 0,0) | 1,0 × 1,0 + 0,0 × 0,0 = 1,0 |
| B, une phrase semblable | (0,8, 0,6) | 1,0 × 0,8 + 0,0 × 0,6 = 0,8 |
| C, un autre sujet | (0,0, 1,0) | 1,0 × 0,0 + 0,0 × 1,0 = 0,0 |
Les trois listes ont une longueur de 1 : pour B, 0,8 × 0,8 + 0,6 × 0,6 = 1. Le cosinus est donc simplement la somme des produits.
Le gabarit connu le plus proche
Section intitulée « Le gabarit connu le plus proche »Pour chaque nouveau gabarit, le carnet trouve le plus semblable parmi les 33 gabarits connus. Un cosinus faible signifie que le nouveau message est éloigné de tout ce que le service a dit auparavant :
new template nearest known template cosine feature flag new-reply-editor is on for <num>% of agents agent <id> signed in 0.340 unhandled exception in update_ticket: KeyError: 'priority' unhandled exception in update_ticket: TimeoutError 0.801cache pool exhausted, request <id> waited <num> ms for a connection cache hit ratio <num> over the last <num> requests 0.491Known templates: median cosine to their nearest known neighbour: 0.793La dernière ligne est la référence de base. Un gabarit connu est généralement proche d’un autre gabarit connu : le cosinus médian est de 0,793. Le graphique place les trois nouveaux gabarits à côté :
Description textuelle du graphique
Quatre lignes, chacune avec un point, sur un axe de similarité cosinus allant de 0 à 1. L’indicateur de fonctionnalité, nouveau et sans danger : 0,34, la valeur la plus basse. Le message du pool du cache, nouveau et représentant un vrai problème : 0,491. La médiane des gabarits connus : 0,793. KeyError, nouveau et représentant un vrai problème : 0,801, aussi élevé qu’un gabarit connu habituel.
Lisez les points de gauche à droite. Le message le plus différent est l’indicateur de fonctionnalité sans danger. Le KeyError est le moins différent. C’est presque la même phrase qu’une erreur connue de la même fonction, avec KeyError: 'priority' plutôt que TimeoutError. Selon la distance seulement, il semble normal.
La carte
Section intitulée « La carte »Les 384 nombres de chaque gabarit peuvent être réduits à 2 nombres avec l’ACP (analyse en composantes principales). L’ACP conserve les deux directions dans lesquelles les données varient le plus. Nous pouvons ensuite dessiner les gabarits sur une carte :
- Gabarit connu (deux premières semaines)
- Nouveau : un vrai problème (KeyError, pool du cache)
- Nouveau : sans danger (indicateur de fonctionnalité)
Description textuelle du graphique
La carte contient 36 points, un par gabarit. Les 33 gabarits connus sont d’une couleur. Les deux nouveaux gabarits représentant de vrais problèmes sont d’une deuxième couleur. Le nouvel indicateur de fonctionnalité sans danger est d’une troisième couleur. En haut à gauche se trouve un groupe de messages d’exception, comme « exception non gérée dans update_ticket : TimeoutError ». Le nouveau message KeyError se trouve dans ce groupe. En bas se trouvent les messages de requête et de classification. À droite se trouvent les messages concernant les délais dépassés, les pools de connexions et les vérifications de santé. Le nouveau message du pool du cache se trouve parmi eux. Le nouvel indicateur de fonctionnalité se trouve au milieu à droite, près des messages de limite de débit et de vérification de santé.
La carte raconte la même histoire, avec une mise en garde. Le KeyError se trouve dans le groupe des exceptions connues. Le message du pool du cache se trouve à côté des autres messages sur les pools et les délais dépassés. L’indicateur de fonctionnalité semble proche d’autres messages, mais c’est l’effet de la réduction à 2 nombres. Avec 384 nombres, le cosinus indique qu’il est le plus éloigné. Ne mesurez jamais les distances sur une carte en 2D. Utilisez-la pour voir les groupes.
Différent ne veut pas dire dangereux
Section intitulée « Différent ne veut pas dire dangereux »Les plongements mesurent à quel point un message est différent. Ils ne mesurent pas à quel point il est grave. Pour ce service :
| Gabarit | Nouveau? | Cosinus (plus faible = plus différent) | Vrai problème? |
|---|---|---|---|
| indicateur de fonctionnalité | oui | 0,34 | non : un changement prévu |
| pool du cache | oui | 0,49 | oui : le changement de configuration |
KeyError |
oui | 0,80 | oui : la mise en production annulée |
Si Amira déclenchait une alerte pour « cosinus inférieur à la médiane connue », elle recevrait l’indicateur sans danger et le pool du cache. Elle manquerait le KeyError. Les gabarits ont trouvé les trois. Le niveau aide aussi : le KeyError est une ERROR, le pool du cache un WARN, l’indicateur une INFO. Une règle simple et utile : « chaque nouveau gabarit, avec son niveau et sa première ligne, est transmis à une personne ».
Où les plongements aident-ils, alors?
- À classer les nouveaux gabarits quand ils sont nombreux, par exemple après une mise en production importante.
- À regrouper les nouveaux messages qui disent la même chose avec des mots différents. Un analyseur de journaux crée un nouveau gabarit pour chaque formulation. Les plongements les réunissent.
- Pour le texte libre, comme le texte du billet d’un client. Une plainte sur un nouveau problème, par exemple « l’application m’a facturé deux fois », n’a pas de gabarit. Sa distance de toutes les plaintes connues permet de la trouver. Les données du cours ne contiennent aucun texte de billet, donc nous ne mesurons pas cela ici.
Le coût de chaque méthode
Section intitulée « Le coût de chaque méthode »Le carnet chronomètre les deux méthodes sur les mêmes lignes :
templates: 1.8 microseconds a lineembeddings: 654 microseconds a line, about 1.5 minutes for all 137,013 linesCes durées proviennent de la machine de test; les vôtres seront différentes. Produire le plongement d’une ligne coûte environ 360 fois plus que créer son gabarit. À l’échelle de Larkfield, les deux sont peu coûteux. Prenons un exemple construit d’un million de lignes par jour. Les gabarits prennent environ 2 secondes, et les plongements environ 11 minutes de processeur. Les plongements nécessitent aussi un modèle de 91 Mo à installer et à maintenir à jour.
L’ordre est donc : d’abord les gabarits pour chaque ligne, les plongements seulement pour les quelques nouveaux gabarits. Produire les plongements de trois nouveaux gabarits prend bien moins d’une seconde.
Erreur courante
Signaler chaque message jamais vu auparavant
Symptôme : Amira, qui développe ticket-api, écrit une vérification rapide : « envoyer une alerte pour chaque message absent des deux premières semaines ». Le premier soir, le canal du centre de soutien reçoit des milliers d’alertes. Après les deux premières semaines, 91 023 des 108 393 lignes sont « nouvelles », soit environ 2 126 par jour.
Cause : la vérification compare les messages entiers. Chaque message contient un numéro de billet, un numéro de tâche ou une durée en millisecondes. Presque chaque ligne est donc unique. Les 108 502 messages différents ne représentent que 36 phrases.
Solution : comparez les gabarits, pas les messages. Masquez d’abord les identifiants et les nombres. Les mêmes données donnent alors 3 nouveaux gabarits en 60 jours. Chacun représente un vrai changement à examiner.
Conséquence pour le travail en IA : l’unité d’un détecteur détermine tout. Ici, la bonne unité est « un type de phrase », pas « une ligne ». Une vérification avec la mauvaise unité submerge l’équipe. L’équipe apprend à désactiver ses alertes, ce qui cache aussi la vraie erreur.
À vous de jouer dans le carnet
Section intitulée « À vous de jouer dans le carnet »Le carnet se termine par deux tâches, avec des vérifications :
- Le changement de configuration a eu lieu le 20 octobre 2025 à 10 h. Dans le tableau des nouveaux gabarits, trouvez celui qui est apparu pour la première fois après cette heure.
- Trouvez le nouveau gabarit au cosinus le plus faible avec son gabarit connu le plus proche. Décidez s’il représente un problème.
Comparez ensuite les deux méthodes pour Amira, en deux phrases : ce que chacune a trouvé et ce que chacune a coûté.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Expliquez pourquoi signaler chaque message de journal jamais vu auparavant échoue pour ticket-api, et ce qu'un gabarit change.
Afficher la réponse
Presque chaque message contient un identifiant de billet, un identifiant de tâche ou un nombre de millisecondes. Presque chaque ligne est donc unique. Après les deux premières semaines, 84 % des lignes étaient « nouvelles », soit environ 2 126 par jour. Le détecteur signale presque tout. Un gabarit masque les parties qui changent. Les lignes qui contiennent la même phrase obtiennent donc le même gabarit. Les 108 502 messages deviennent 36 gabarits, dont seulement 3 sont nouveaux en 60 jours.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Faites une prédiction : une nouvelle version ajoute le message « unhandled exception in search: KeyError: 'query' » (exception non gérée dans la recherche). Le service consigne déjà « unhandled exception in search: TimeoutError ». Son cosinus avec le gabarit connu le plus proche sera-t-il élevé ou faible? Faut-il le transmettre à une personne?
Afficher la réponse
Élevé, probablement : la phrase ressemble beaucoup à celle d’une exception connue dans la même fonction. C’est comme le KeyError du 8 octobre (cosinus de 0,80). Selon la distance, le message semble normal. Mais c’est un nouveau gabarit de niveau ERROR (erreur), donc il faut le transmettre à une personne. Une règle « transmettre chaque nouveau gabarit à une personne, avec son niveau » le détecte. Un seuil de cosinus seul le manquerait.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Amira demande : « Devrait-on calculer le plongement de chaque ligne de journal chaque jour, par sécurité? » Répondez avec les coûts de cette leçon.
Afficher la réponse
Non. Les plongements coûtent environ 0,65 milliseconde par ligne sur la machine de test, contre environ 2 microsecondes pour un gabarit. C’est environ 360 fois plus. Ils nécessitent aussi un modèle de 91 Mo à installer, dont il faut conserver la même version. Avec ces données, ils ont classé l’indicateur sans danger en premier et le véritable KeyError en dernier. Créez un gabarit pour chaque ligne. Calculez les plongements seulement pour les quelques nouveaux gabarits, afin de les regrouper et de les classer pour une personne.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Comparer les messages de journal complets échoue : après deux semaines, 84 % des lignes étaient « nouvelles », à cause des identifiants et des nombres.
- Un gabarit masque les parties qui changent. Les 108 502 messages de
ticket-apiforment 36 gabarits, dont 3 sont nouveaux en 60 jours. Ce sont l’indicateur de fonctionnalité sans danger, leKeyErroraprès une mise en production et le pool de cache après le changement de configuration. - Un plongement transforme une phrase en nombres pour rapprocher les sens similaires. La similarité cosinus avec le gabarit connu le plus proche indique à quel point un nouveau message est différent.
- Différent ne veut pas dire dangereux : l’indicateur sans danger était le plus différent (0,34) et le véritable
KeyError, le moins différent (0,80). - Les gabarits coûtent environ 2 microsecondes par ligne; les plongements, environ 360 fois plus. Créez un gabarit pour chaque ligne; calculez les plongements seulement pour les nouveaux gabarits.
Vous pouvez maintenant trouver de nouveaux types de messages dans les journaux. Vous savez aussi qu’une personne doit encore juger ce qui est « nouveau ». Mais cette personne doit lire chaque alerte et la comprendre rapidement. Ensuite, vous verrez si un LLM peut écrire ce premier résumé pour Sofia, et comment vérifier ce qu’il écrit.
Leçon suivante : Où un LLM aide, et où il n'aide pas