Aller au contenu
English

Plusieurs métriques à la fois

  • Leçon 24
  • 35 min
  • Module 5 : Les anomalies dans le temps

Où nous en sommes

Nos détecteurs surveillent une série à la fois. L'API de billets a trois métriques : latence, erreurs et requêtes. Un incident fait varier les trois à la fois. Dans cette leçon, nous comparons un détecteur par métrique à un détecteur pour toutes. Nous regroupons les alertes pour qu'un incident donne une alerte, pas quarante.

Leçon 24 sur 38 · Détection d'anomalies : trouver ce qui est inhabituelPlusieurs métriques à la fois
Aperçu du cours

Ce que vous saurez faire

Surveillez plusieurs métriques d’un service sans submerger l’équipe d’alertes. Un incident doit donner une alerte indiquant ce qui a changé, pas quarante alertes provenant de quatre détecteurs.

Carnet JupyterFaites cette leçon dans un carnet JupyterColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter contient toutes les cellules de code, les tâches et les vérifications de cette leçon. Ses cellules de préparation installent pandas, NumPy, SciPy, scikit-learn et matplotlib. Elles téléchargent aussi les métriques de l’API de billets (moins de 1 Mo) avec compare.py. Environ 25 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 mainEnviron 35 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

L’option carnet Jupyter (Colab ou Kaggle) ou l’option locale, comme dans la première leçon de ce module.

Testé avec Python 3.12.13 dans Jupyter sur macOS, avec pandas 3.1.1 et scikit-learn 1.9.1. Les commandes Windows et Colab n’ont pas été testées.

Une cuisine a une alarme de fumée, une alarme de chaleur et une alarme de gaz. Une poêle prend feu. Les trois alarmes sonnent, puis chacune sonne à nouveau chaque minute jusqu’à ce que le feu soit éteint.

Les pompiers ont besoin d’un seul appel qui dit « feu de cuisine, fumée et chaleur ». Quarante appels en dix minutes ne les aideraient pas. Ils masqueraient un deuxième feu, s’il y en avait un.

Un service avec trois métriques fonctionne de la même façon. Un incident les fait toutes varier à la fois.

L’API de billets d’Amira écrit une ligne chaque minute pendant 60 jours (du 1er septembre au 30 octobre 2025, soit 86 400 minutes) :

  • requêtes : combien de requêtes sont arrivées dans la minute (moyenne de 70,57);
  • taux d’erreur : la proportion de requêtes qui ont échoué (moyenne de 0,004, soit 0,4 %);
  • latence p95 : 95 % des requêtes ont été plus rapides que cette valeur (médiane de 198,2 ms).

Nous avons inséré trois incidents. Chacun fait varier une métrique différente :

Incident inséré Quand Ce qui change
Une fuite de mémoire lente Du 22 septembre à 3 h au redémarrage du 27 septembre à 4 h 30 La latence, lentement, pendant cinq jours
Un pic d’erreurs après une mise en production Le 8 octobre, de 14 h 05 à 14 h 45 Les erreurs, d’un coup; la latence, un peu
Un changement de configuration À partir du 20 octobre à 10 h La latence, une hausse soudaine et permanente

La mise en production du 8 octobre à 14 h 05 s’est mal passée. Pendant 40 minutes, beaucoup de requêtes ont échoué : jusqu’à 14,75 % en une minute. Amira est ensuite revenue à la version précédente. Voici ce qu’a détecté le seuil du taux d’erreur, qui alerte quand plus de 3 % des requêtes échouent en une minute :

  • Taux d'erreur
  • Seuil de 3 %
  • Pic inséré
  • Minute avec alerte (34)
Le taux d'erreur de l'API de billets, minute par minute, autour du pic inséré après la mise en production. Pendant les 40 minutes du pic, le seuil du taux d'erreur produit des alertes durant 34 minutes. Avant et après, la plupart des minutes n'ont aucune erreur.
Description textuelle du graphique

Une courbe du taux d’erreur par minute, de 13 h 30 à 15 h 29 le 8 octobre 2025. Le seuil de 3 % apparaît en pointillé. Avant 14 h 05, la courbe est à 0 % durant 30 des 35 minutes. Entre les deux lignes verticales pointillées, à 14 h 05 et à 14 h 45, elle passe entre 1,47 % et 14,75 %. Trente-quatre points marquent les minutes au-dessus de 3 %. Après 14 h 45, la courbe revient à 0 %.

Trente-quatre alertes d’un seul détecteur, pour un seul incident. Le test du nombre d’erreurs en ajoute 31 : plus d’erreurs que ce qu’un taux de 0,4 % peut expliquer. La référence de base saisonnière de la latence en ajoute 3, parce que la latence a aussi un peu augmenté :

  • Latence p95
  • Seuil de latence de 350 ms
  • Pic inséré
  • Alerte de la référence de base saisonnière (3)
La latence p95 pendant les mêmes deux heures. Durant le pic, elle se situe entre 200 et 275 ms, contre 170 à 228 ms avant. Elle reste bien sous le seuil de 350 ms, mais la référence de base saisonnière alerte durant 3 minutes.
Description textuelle du graphique

Une courbe de la latence p95 par minute, de 13 h 30 à 15 h 29. Avant 14 h 05, elle se situe entre 170 et 228 millisecondes. Entre 14 h 05 et 14 h 45, elle est un peu plus élevée, entre 200 et 275 millisecondes, puis redescend. Une ligne pointillée à 350 millisecondes, le seuil de latence, reste toujours bien au-dessus de la courbe. Trois points, vers 14 h 23 à 14 h 25, marquent les minutes où la référence de base saisonnière alerte.

Le carnet Jupyter compte ensemble les minutes avec alerte brutes des quatre détecteurs par métrique :

alert minutes, four detectors: 14474
alert minutes in the release spike: 34

Sur 60 jours, les quatre détecteurs donnent 14 474 minutes avec alerte. Personne ne peut lire tout cela. Il nous faut deux choses : mieux surveiller les métriques et transformer les minutes avec alerte en incidents.

La conception la plus simple donne à chaque métrique son propre détecteur. Le carnet Jupyter en construit quatre et évalue chacun sur les incidents insérés pour sa propre métrique :

detector alert events false alert events recall minutes to detection
latency threshold 17 0 0.5 {'memory_leak': 3342, 'config_change': None}
error-rate threshold 526 525 1.0 {'release_error_spike': 0}
seasonal baseline, latency 92 78 1.0 {'memory_leak': 506, 'config_change': 3}
error count test 328 327 1.0 {'release_error_spike': 0}

Un événement d’alerte est un groupe d’alertes espacées de moins de 30 minutes. Le rappel est la proportion d’incidents insérés pour cette métrique qui ont au moins un événement.

Le seuil du taux d’erreur détecte le pic après la mise en production immédiatement (0 minute). Mais il produit 525 faux événements en 60 jours. Pourquoi autant? Dans 2 130 de ses 2 736 minutes avec alerte, une seule requête a échoué. Durant une minute calme, une erreur sur 30 requêtes représente déjà 3,3 %. Une proportion est bruitée quand le nombre sur lequel elle repose est petit.

Le test du nombre d’erreurs pose une meilleure question : y a-t-il plus d’erreurs que le nombre de requêtes peut expliquer? Il prévoit que 0,4 % des requêtes échoueront. Il alerte quand le nombre réel dépasse cette attente de 4 écarts-types, et seulement durant les minutes comptant au moins 20 requêtes. Il produit encore 327 faux événements : c’est mieux, mais ce n’est pas satisfaisant.

Le seuil de latence (350 ms) ne produit aucun faux événement. Mais il ne détecte la fuite qu’après 3 342 minutes, soit plus de deux jours. Il ne détecte jamais le changement de configuration : une hausse soudaine d’environ 14 % reste sous 350 ms. La référence de base saisonnière compare la latence à celle de la même minute, 1 et 2 semaines auparavant. Elle détecte la fuite après 506 minutes et le changement de configuration après 3 minutes.

Prédisez. Un Isolation Forest observe les trois métriques ensemble, chaque minute. Produira-t-il plus ou moins d’événements d’alerte que les détecteurs par métrique?

Le carnet Jupyter construit d’abord les caractéristiques. Il met chaque métrique à l’échelle selon sa valeur habituelle à cette heure de la journée (sa médiane et sa MAD, l’écart absolu médian). Il compare donc 10 h à 10 h. Ensuite, un Isolation Forest (200 arbres) apprend les deux premières semaines comme étant « normales ». Il alerte pour les minutes dont le score se situe dans les 0,1 % les plus élevés de ces deux semaines.

detector alert events false alert events recall minutes to detection
Isolation Forest, 3 metrics 61 48 1.0 {'memory_leak': 2752, 'release_error_spike': 0, 'config_change': 1126}
two per-metric detectors 337 286 1.0 {'memory_leak': 192, 'release_error_spike': 0, 'config_change': 404}
Événements d'alerte en 60 jours, pour chaque détecteur par métrique et pour un Isolation Forest sur les trois métriques. L'Isolation Forest produit 61 événements et détecte les trois incidents insérés.
Description textuelle du graphique

Cinq colonnes, de gauche à droite : seuil de latence, 17 événements; seuil du taux d’erreur, 526; référence de base saisonnière de la latence, 92; test du nombre d’erreurs, 328. La cinquième colonne, d’une autre couleur, représente l’Isolation Forest sur trois métriques : 61.

L’Isolation Forest produit 61 événements et détecte les trois incidents. Le seuil de latence OU le test du nombre d’erreurs (la ligne « deux détecteurs par métrique ») produit 337 événements. Un détecteur pour toutes les métriques repère une minute où plusieurs choses sont un peu inhabituelles à la fois. Il a donc besoin de moins d’alertes pour détecter les mêmes incidents.

La ligne « deux détecteurs par métrique » indique qu’elle détecte la fuite de mémoire après 192 minutes, bien avant l’Isolation Forest (2 752). Ne la croyez pas encore. Sa première alerte pendant la fuite est une alerte d’erreur, le 22 septembre à 6 h 12. La fuite ne cause pas d’erreurs. Le test du nombre d’erreurs alerte durant environ 7,9 minutes par jour pendant la fuite, contre 7,1 minutes par jour au total. Cette alerte était un hasard. La partie latence de cette ligne (le seuil de 350 ms) alerte pour la première fois le 24 septembre à 10 h 42. Une évaluation qui compte toute alerte dans une fenêtre récompense les détecteurs bruyants. C’est pourquoi nous avons évalué chaque détecteur par métrique ci-dessus uniquement sur les incidents de sa propre métrique.

Conception Point fort Coût
Un détecteur par métrique Chaque alerte dit ce qui a changé : « taux d’erreur de 12 % à 14 h 06 ». Facile d’ajuster une métrique à la fois. Beaucoup de détecteurs, beaucoup d’alertes pour un incident.
Un détecteur pour toutes les métriques Moins d’alertes; repère quand « tout est un peu inhabituel à la fois ». L’alerte dit seulement « cette minute est étrange ». Une personne doit trouver quelle métrique a changé.

Le tableau comparatif mesure ce coût par le temps nécessaire pour expliquer une alerte. Il est de 2 minutes pour une alerte par métrique et de 5 minutes pour l’Isolation Forest. Ce sont deux hypothèses du cours, pas des mesures. Un faux événement d’alerte coûte 3 dollars (une autre hypothèse). Le coût par semaine est donc de 100 dollars pour les deux détecteurs par métrique et de 17 dollars pour l’Isolation Forest.

Une réponse courante et pratique consiste à utiliser les deux. Un détecteur pour toutes les métriques décide quand alerter. Les scores par métrique vont dans le texte de l’alerte pour dire ce qui a changé.

Même un bon détecteur donne plusieurs minutes avec alerte pour un incident. La dernière étape est donc le regroupement des alertes : réunir les alertes proches dans le temps en un événement d’alerte. Envoyez ensuite un message par événement.

Quatre détecteurs donnent 14 474 minutes avec alerte en 60 jours : le seuil de latence, le seuil du taux d'erreur, la référence de base saisonnière et le test du nombre d'erreurs. Une boîte de regroupement réunit les alertes espacées de moins de 30 minutes. Le résultat est de 496 événements d'alerte, soit 8,3 par jour. Une flèche pointillée part de la boîte de regroupement et montre le pic après la mise en production : 34 minutes avec alerte deviennent 1 événement.
Regroupement des alertes sur l'API de billets. Les quatre détecteurs par métrique donnent 14 474 minutes avec alerte en 60 jours. Regroupées avec un intervalle de 30 minutes, elles donnent 496 événements, et le pic après la mise en production forme un seul événement.
Description textuelle du diagramme

À gauche, une boîte contient les quatre détecteurs par métrique. Ce sont le seuil de latence, le seuil du taux d’erreur, la référence de base saisonnière de la latence et le test du nombre d’erreurs. Une flèche mène à « 14 474 minutes avec alerte en 60 jours ». La boîte suivante, « regroupement », réunit les alertes espacées de moins de 30 minutes. Le résultat est de 496 événements d’alerte, soit environ 8,3 par jour. Une flèche pointillée part de la boîte de regroupement vers une note : le pic après la mise en production, avec 34 minutes avec alerte, devient 1 événement.

Voici l’idée avec un petit exemple. Trois détecteurs surveillent 12 minutes; 1 signifie une alerte durant cette minute :

14:00 14:01 14:02 14:03 14:04 14:05 14:06 14:07 14:08 14:09 14:10 14:11
latency 0 0 1 1 1 0 0 0 0 0 0 1
errors 0 1 1 1 1 1 0 0 0 0 0 0
requests 0 0 0 1 0 0 0 0 0 0 0 0
raw alerts: 10 | minutes with an alert: 6 | events (5-minute gap): 2
  1. Comptez les alertes brutes : une par détecteur et par minute. Il y en a 10.
  2. Réunissez les détecteurs : une minute avec au moins une alerte compte comme une minute avec alerte. Il y en a 6 (de 14 h 01 à 14 h 05, et à 14 h 11).
  3. Parcourez les minutes avec alerte dans l’ordre chronologique. Commencez un nouvel événement quand l’intervalle depuis la dernière minute avec alerte dépasse 5 minutes.
  4. De 14 h 01 à 14 h 05, il s’agit d’un seul événement. 14 h 11 arrive 6 minutes après 14 h 05 et commence donc un deuxième événement.

Sur l’API de billets, avec un intervalle de 30 minutes :

events after grouping (30 minutes): 496
events that overlap the spike: 1
Les mêmes 14 474 minutes avec alerte des quatre détecteurs par métrique, regroupées avec un intervalle de plus en plus long. Avec un intervalle de 1 minute, elles donnent 2 931 événements; avec 5 minutes, 2 014; avec 30 minutes, 496.
Description textuelle du graphique

Quatre colonnes. Sans regroupement, 14 474 minutes avec alerte. Avec un intervalle de 1 minute, 2 931 événements. Avec un intervalle de 5 minutes, 2 014 événements. Avec un intervalle de 30 minutes, 496 événements. La colonne de 30 minutes est d’une autre couleur.

L’intervalle est un choix :

  • Trop court, et un incident donne plusieurs événements : le pic après la mise en production produirait encore plusieurs messages.
  • Trop long, et deux incidents deviennent un seul événement. Un deuxième problème qui commence pendant le premier se retrouve masqué à l’intérieur.

Un bon intervalle dépasse un peu les périodes calmes à l’intérieur d’un incident réel. Il est aussi beaucoup plus court que le temps entre deux incidents. Le regroupement ne supprime pas les fausses alertes : 496 événements en 60 jours représentent encore 8,3 événements par jour. Le regroupement transforme chaque incident en un message; un meilleur détecteur réduit le nombre de messages.

  • Commencez avec un détecteur par métrique, avec le bon test pour chacune : une référence de base saisonnière pour la latence, un test du nombre pour les erreurs. Leurs alertes sont faciles à comprendre.
  • Ajoutez un détecteur pour toutes les métriques quand les détecteurs par métrique envoient trop d’alertes, ou quand plusieurs petits changements simultanés signalent les incidents.
  • Regroupez toujours les alertes de tous les détecteurs d’un service en événements. Envoyez un message par événement, avec l’état de chaque métrique.
  • Pour les tableaux de bord, l’acheminement des alertes et la réponse aux incidents, le cours de MLOps, MLOps et LLMOps : exploiter l’IA en production, va plus loin.

Erreur courante

Un seuil du taux d'erreur durant les minutes calmes

Symptôme : le seuil du taux d’erreur envoie des centaines d’alertes la nuit et les fins de semaine. L’équipe commence à l’ignorer.

Diagnostic : comptez les erreurs derrière chaque minute avec alerte. Sur l’API de billets, 2 130 des 2 736 minutes avec alerte comptent exactement une requête échouée. La minute avec alerte médiane ne compte que 27 requêtes. Une erreur sur 27 représente 3,7 %, au-dessus du seuil de 3 %.

Correction : testez le nombre, pas la proportion. Comparez le nombre d’erreurs à ce que le nombre de requêtes peut expliquer. Ignorez les minutes avec très peu de requêtes (le test du nombre d’erreurs utilise 20). Ou regroupez les minutes par périodes de 5 ou 15 minutes avant de calculer le taux. Le nombre sur lequel il repose sera ainsi plus grand.

La section 6 du carnet (notebook) Jupyter contient deux tâches.

  1. Regroupez les mêmes minutes d’alerte (any_alarm) avec un intervalle de 2 h plutôt que de 30 minutes.
  2. Comptez les événements. Inscrivez le nombre dans events_2h, puis exécutez sa cellule de vérification.
  3. Trouvez la ligne d’Isolation Forest (forêt d’isolement) dans table.
  4. Lisez combien de minutes après le début de la fuite de mémoire survient son premier événement. Inscrivez ce nombre dans iso_leak_minutes, puis exécutez sa cellule de vérification.

Vérifiez votre compréhension

Le seuil du taux d'erreur produit 525 faux événements d'alerte en 60 jours; le test du nombre d'erreurs, 327. Les deux détectent immédiatement le pic lié à la mise en production. Pourquoi le test du nombre d'erreurs est-il meilleur, et pourquoi reste-t-il insuffisant?

Afficher la réponse

Une proportion calculée sur quelques requêtes est instable : une erreur sur 30 requêtes représente déjà 3,3 %. Et 2 130 des 2 736 minutes avec alerte du seuil comptaient exactement une erreur. Le test du nombre d’erreurs compare les erreurs à ce que le nombre de requêtes peut expliquer. Il ignore les minutes comptant moins de 20 requêtes. Il déclenche encore 327 alertes, car chaque minute constitue un petit échantillon. Regrouper les minutes, ou augmenter la limite, réduirait encore ce nombre.

Vérifiez votre compréhension

Faites une prédiction : vous regroupez les alertes avec un intervalle d'un jour. Qu'arrive-t-il au nombre d'événements, et quel problème pourrait survenir?

Afficher la réponse

Le nombre d’événements diminue beaucoup, car la plupart des alertes sont espacées de moins d’un jour. Mais deux incidents survenant le même jour, ou l’un juste après l’autre, deviennent un seul événement. Un deuxième incident caché dans le premier n’est pas signalé. L’intervalle doit être plus court que le temps habituel entre deux incidents réels.

Vérifiez votre compréhension

Omar demande : Isolation Forest produit 61 événements, et les deux détecteurs par métrique en produisent 337. Pourquoi ne pas utiliser seulement Isolation Forest?

Afficher la réponse

Parce que son alerte dit seulement « cette minute est étrange ». La personne de garde doit ensuite examiner chaque métrique pour trouver ce qui a changé. Le cours suppose que cela prend 5 minutes, plutôt que 2. Il a aussi détecté la fuite tardivement (2 752 minutes) et le changement de configuration après 1 126 minutes. La référence de base saisonnière les a détectés après 506 et 3 minutes. Une bonne conception utilise un détecteur pour toutes les métriques afin de décider quand envoyer une alerte. Elle inclut les scores par métrique dans l’alerte.

Récapitulatif

  • Un incident modifie plusieurs métriques, et chaque détecteur par métrique envoie ses propres alertes : 34 minutes avec alerte pour un seul pic de 40 minutes lié à une mise en production.
  • Utilisez le bon test pour chaque métrique : un test du nombre pour les erreurs, une référence de base saisonnière pour la latence.
  • Un détecteur pour toutes les métriques (ici, Isolation Forest sur des métriques mises à l’échelle) nécessite moins d’alertes. Mais ses alertes sont plus difficiles à expliquer.
  • Regroupez en événements les alertes rapprochées dans le temps : 14 474 minutes avec alerte sont devenues 496 événements. Le pic lié à la mise en production est devenu un seul événement. L’intervalle est un choix.
  • Une méthode d’évaluation qui compte toute alerte dans une fenêtre récompense le bruit : évaluez chaque détecteur sur les incidents qu’il peut détecter.

Dans ce module, vous avez trouvé des anomalies dans le temps : références de base saisonnières, STL, prévisions, points de rupture et métriques multiples. Jusqu’ici, les détecteurs utilisent des règles, des statistiques et des arbres. Ensuite, dans le module 6, un petit réseau de neurones apprend à reconstruire les données normales. Ce qu’il ne peut pas reconstruire est étrange.

Leçon suivante : Autoencodeurs et erreur de reconstruction