Pannes dans les métriques de machines ou de serveurs
- Étude de cas 2
- 120 min
- Facultative · 1 étude de cas requise pour le certificat
Où nous en sommes
Dans ce cours, nous avons trouvé la fuite de mémoire et le pic lié à une mise en production dans les métriques de l'API de billets de soutien. Nous essayons maintenant les mêmes détecteurs sur de vraies machines et de vrais serveurs, avec des défaillances réellement survenues. Dans cette étude de cas, nous comparons trois méthodes selon les défaillances trouvées, le retard et les fausses notifications par jour.
Étude de cas 2 sur 4 · Détection d'anomalies : trouver ce qui est inhabituelPannes dans les métriques de machines ou de serveurs
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
Surveillez 38 métriques de vrais serveurs pour repérer les défaillances, puis choisissez un détecteur que vous pouvez justifier. Vous fixerez tous les seuils de la même façon, sans étiquette, selon un budget de notifications. Vous comparerez une cote z robuste, Isolation Forest et un score de rupture en direct. Vous évaluerez chacun selon les défaillances trouvées, le retard et les fausses notifications par jour. Ensuite, vous exécuterez le détecteur choisi une seule fois sur un serveur qu’aucune étape n’a encore vu.
Le carnet (notebook) Jupyter exécute chaque étape de cette page, avec le même code et les mêmes sorties. Il ajoute deux tâches avec des vérifications. Ses cellules de configuration installent pandas, NumPy, SciPy, scikit-learn, matplotlib et ruptures. Elles téléchargent les données de trois serveurs depuis la source d’origine (environ 55 Mo) et vérifient chaque fichier. Après la configuration, le carnet s’exécute en moins d’une minute sur un ordinateur portable.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
Cette étude de cas utilise tout le cours. Voici les leçons les plus importantes :
- La cote z (z-score) robuste (médiane et MAD), dans Médiane, MAD et IQR.
- Isolation Forest (forêt d’isolement), et pourquoi les variables comptent plus que l’algorithme, dans Isolation Forest et Les variables comptent plus que l’algorithme.
- Les points de rupture, le coût fondé sur l’erreur quadratique et la pénalité, dans Points de rupture.
- Les événements d’alerte, les fenêtres trouvées et le délai de détection en minutes, dans Plusieurs métriques à la fois.
- Le choix d’un seuil selon un budget, dans Le budget d’alertes.
Ce qu’il vous faut sur votre ordinateur
Rien : le carnet s’exécute dans Colab ou Kaggle. Pour l’exécuter localement, utilisez un environnement virtuel avec Python 3.12 et les versions de la cellule de configuration (pandas 3.1.1, NumPy 2.5.4, scikit-learn 1.9.1, ruptures 1.1.10). La cellule de configuration crée un dossier server-metrics. Pour recommencer, supprimez ce dossier.
Testé sur macOS (puce Apple) avec Python 3.12.13, dans Jupyter lancé à neuf. Colab, Kaggle, Windows et Linux n’ont pas été testés.
La situation
Section intitulée « La situation »On finit par éteindre un détecteur de fumée qui sonne chaque fois qu’on fait des rôties. Un détecteur qui sonne dix minutes après le début d’un incendie arrive trop tard. Les alertes de serveurs échouent de ces deux façons.
Hiroshi gère l’horaire de garde d’une équipe qui exploite de nombreux serveurs. Quand une alerte commence, l’ingénieur de garde reçoit une notification : un message sur son téléphone, jour ou nuit. Kwame est le scientifique des données de l’équipe. Nous avons inventé ces deux personnes pour cette étude de cas. Les serveurs et leurs défaillances sont réels.
Les règles que Hiroshi donne à Kwame ressemblent à celles du cours. Chacune est une hypothèse, pas une mesure :
- Le budget de notifications : les jours normaux, au plus 1 notification par jour par serveur.
- Une fausse notification coûte 15 minutes à un ingénieur, pour examiner la situation, décider et retourner dormir.
- Une alerte qui persiste envoie une autre notification après 30 minutes. De nombreux outils de notification fonctionnent ainsi.
Hiroshi demande à Kwame : « Quel détecteur devrait nous envoyer des notifications? Combien de vraies défaillances trouvera-t-il, avec quel retard, et combien de fausses notifications enverra-t-il? »
Ce que vous allez créer
Section intitulée « Ce que vous allez créer »Vous créerez trois détecteurs à partir de 38 métriques par serveur. Vous fixerez le seuil de chacun selon le même budget de notifications, sans étiquette. Ensuite, vous les évaluerez sur 21 défaillances réelles de deux serveurs et vous en choisirez un. Vous l’exécuterez une seule fois sur un troisième serveur ayant 4 défaillances.
Les données
Section intitulée « Les données »Les données proviennent de SMD, le Server Machine Dataset. Le groupe de recherche NetManAIOps les a recueillies sur 28 serveurs d’une « grande entreprise Internet ». Il les a publiées avec sa méthode OmniAnomaly. Chaque serveur a 38 métriques, avec une valeur par minute, sur environ cinq semaines.
Les fichiers d’un serveur :
| Fichier | Contenu |
|---|---|
train-<m>.txt |
La première moitié : une ligne par minute, 38 valeurs. Aucune étiquette. |
test-<m>.txt |
La seconde moitié, sous la même forme. |
label-<m>.txt |
Un 0 ou un 1 par minute de la moitié de test : 1 signifie « pendant une défaillance ». |
interp-<m>.txt |
Pour chaque défaillance, les métriques que les auteurs du jeu de données ont associées à celle-ci. |
Les métriques n’ont aucun nom. Elles mesurent notamment le processeur, la mémoire, le réseau et le disque, mais le jeu de données ne précise pas lesquelles. Les auteurs ont ramené chaque métrique entre 0 et 1. Il n’y a aucune date, seulement des numéros de minute.
Nous avons comparé deux autres jeux de données. NAB, le Numenta Anomaly Benchmark, contient aussi des métriques de serveurs, mais une seule par fichier. Les conditions d’utilisation de ses données sont aussi peu claires. Le dépôt était sous licence AGPL de 2015 à décembre 2024, puis sous licence MIT. Une grande partie de ses données provient de tiers. SKAB est sous licence GPL, qui ne figure pas dans notre liste de licences autorisées.
Quels serveurs
Section intitulée « Quels serveurs »Kwame prend trois serveurs selon une règle choisie avant d’exécuter les détecteurs : le premier serveur de chacun des trois groupes.
- machine-1-1 et machine-2-1 servent à la comparaison. Ensemble, ils ont 21 défaillances sur 36,2 jours de test.
- machine-3-1 est la nouvelle entrée. Il est utilisé une seule fois, après le choix. Il a 4 défaillances sur 19,9 jours de test.
Une règle choisie à l’avance vous empêche de sélectionner les serveurs où votre méthode préférée donne de bons résultats.
Premières vérifications
Section intitulée « Premières vérifications »machine-1-1: train (28479, 38), test (28479, 38) = 19.8 days, 9.5% of test minutes in a fault, 8 fault windows window lengths (minutes): [546, 554, 457, 721, 409, 3, 2, 2]machine-2-1: train (23693, 38), test (23694, 38) = 16.5 days, 4.9% of test minutes in a fault, 13 fault windows window lengths (minutes): [22, 54, 46, 26, 8, 452, 17, 33, 75, 16, 12, 21, 388]missing values: 0smallest and largest value: 0.0 0.0 | 1.0 1.0metrics that never change in the training half: 8 of 38metrics that never change in the test half: 6 of 38Ce que cela nous apprend. Les deux serveurs sont différents. machine-1-1 a cinq longues défaillances de 7 à 12 h et trois très courtes de 2 ou 3 minutes. machine-2-1 a 13 défaillances, dont la plupart durent moins d’une heure. Il n’y a aucune valeur manquante. Huit métriques ne changent jamais dans la moitié d’entraînement. Leur dispersion vaut 0, donc une cote z entraînerait une division par zéro. Kwame donne à chaque métrique une dispersion d’au moins 1 % de son étendue.
Une défaillance, minute par minute
Section intitulée « Une défaillance, minute par minute »- Métrique 1
- Début et fin de la défaillance étiquetée
Description textuelle du graphique
La courbe montre la métrique 1 de machine-1-1, minute par minute. Elle commence 240 minutes avant la première défaillance étiquetée et se termine 60 minutes après. Avant la défaillance, elle est basse, entre 0,04 et 0,13. À la minute 0, elle passe à environ 0,5 et reste près de 0,5 jusqu’à la minute 269. À la minute 270, elle redescend à environ 0,1 pendant environ une demi-heure. Elle remonte ensuite à 0,68, avec des pics et des baisses. Dans l’heure suivant la fin de l’étiquette, elle se situe entre 0,19 et 0,34. Deux lignes verticales pointillées marquent le début et la fin de l’étiquette, à 545 minutes d’intervalle.
Ce que cela nous apprend. Cette défaillance commence par un saut de niveau : le niveau change d’un coup et reste ainsi pendant des heures. Tout détecteur qui compare cette minute à la normale devrait le voir. D’autres défaillances durent 2 minutes ou modifient légèrement plusieurs métriques.
Comment nous évaluons un détecteur
Section intitulée « Comment nous évaluons un détecteur »Les défaillances sont des fenêtres, pas des points
Section intitulée « Les défaillances sont des fenêtres, pas des points »Dans le tableau comparatif du cours, un paiement représentait une unité. Une défaillance de serveur est différente. C’est une fenêtre de temps, de sa première minute étiquetée à sa dernière. Une défaillance produit des centaines de minutes inhabituelles, mais Hiroshi a besoin d’une seule notification, rapidement.
Nous évaluons donc chaque détecteur avec trois nombres, comme pour l’API de billets dans Plusieurs métriques à la fois :
- Défaillances trouvées : une défaillance est trouvée quand le détecteur déclenche une alerte pendant sa fenêtre.
- Délai de détection en minutes : du début de la fenêtre à la première alerte pendant celle-ci.
- Fausses notifications par jour : notifications envoyées en dehors de toutes les fenêtres de défaillance.
Description textuelle du diagramme
Le diagramme présente un flux de gauche à droite. La première boîte indique : calculez le score de chaque minute; un score au-dessus du seuil crée une minute d’alerte. La deuxième boîte indique : envoyez une notification à l’ingénieur à la première minute d’alerte, puis après 30 minutes si les alertes continuent. Un losange demande : la notification se situe-t-elle dans une défaillance étiquetée? La flèche oui mène à « notification réelle : défaillance trouvée; délai de détection égal à la première alerte moins le début de la défaillance ». La flèche non mène à « fausse notification : elle coûte 15 minutes (une hypothèse) ».
Pourquoi compter les notifications plutôt que les événements d’alerte du cours (alertes espacées de moins de 30 minutes, regroupées)? Un détecteur qui déclenche une alerte toutes les 20 minutes pendant dix jours crée un seul événement. Pourtant, le téléphone de Hiroshi sonne constamment. Un cas d’échec ci-dessous le montre.
Un petit exemple
Section intitulée « Un petit exemple »Prenez 120 minutes inventées. Une défaillance va de la minute 50 à la minute 59. Un détecteur déclenche des alertes à la minute 10, de 52 à 54, de 70 à 85 et à la minute 100.
pages at minutes: [10, 52, 82]{'pages': 3, 'false pages': 2, 'faults found': 1, 'minutes to detection': [2]}- La minute 10 est la première alerte, donc elle envoie une notification. Elle est hors de la défaillance : une fausse notification.
- La minute 52 arrive 42 minutes après la dernière notification, donc elle en envoie une. Elle est dans la défaillance : une notification réelle. La défaillance est trouvée 2 minutes après son début.
- L’alerte de 70 à 85 commence seulement 18 minutes après la notification à 52. Elle envoie une seule notification à la minute 82, soit 30 minutes après la précédente. C’est une fausse notification.
- La minute 100 arrive 18 minutes après la notification à 82, donc elle n’en envoie pas.
La même règle de seuil pour chaque détecteur
Section intitulée « La même règle de seuil pour chaque détecteur »Chaque détecteur donne un score par minute, et un seuil transforme le score en alertes. Tous les seuils sont donc choisis de la même façon, sans étiquette :
Description textuelle du diagramme
À gauche se trouve la moitié d’entraînement d’un serveur, environ deux semaines et demie, sans étiquettes. Ses premiers 80 % forment la partie d’ajustement : chaque détecteur y apprend la normale. Ses derniers 20 % forment la partie de calibration : le seuil y est fixé pour 1 notification par jour. Une flèche mène à la moitié de test, avec étiquettes. On y évalue les notifications, les défaillances trouvées et le délai de détection en minutes. Une note indique : machine-1-1 et machine-2-1 sont comparés, avec 21 défaillances; machine-3-1 est la nouvelle entrée, utilisée une seule fois, avec 4 défaillances.
- Apprenez la normale sur les premiers 80 % de la moitié d’entraînement (les minutes d’ajustement).
- Sur les derniers 20 % (les minutes de calibration, environ 3 à 4 jours), choisissez le seuil le plus bas qui envoie au plus une notification par jour.
- Exécutez le détecteur sur la moitié de test et évaluez-le avec les étiquettes.
La moitié d’entraînement peut contenir des défaillances. Nous la traitons comme « surtout normale », comme le ferait une vraie équipe. C’est la règle de Le budget d’alertes, avec des notifications par jour plutôt que des alertes par jour.
La référence de base : une cote z robuste par métrique
Section intitulée « La référence de base : une cote z robuste par métrique »Pour chaque métrique, sa médiane et sa MAD sur les minutes d’ajustement donnent une cote z robuste, comme dans Médiane, MAD et IQR. Le score du détecteur est le plus grand |z| des 38 métriques à cette minute.
def robust_scale(fit): """Each metric's median and spread (1.4826 x MAD, at least MIN_SCALE) on the fit minutes.""" med = np.median(fit, axis=0) spread = np.maximum(1.4826 * np.median(np.abs(fit - med), axis=0), MIN_SCALE) return med, spread
def robust_z_score(x, med, spread): """The baseline: the largest |robust z| over the 38 metrics, minute by minute.""" return np.abs((x - med) / spread).max(axis=1)machine-1-1: threshold |z| > 20.3; {'pages': 156, 'false pages': 83, 'faults found': 8, 'faults': 8, 'minutes to detection': [1, 0, 0, 0, 0, 0, 0, 0]}machine-2-1: threshold |z| > 49.6; {'pages': 23, 'false pages': 14, 'faults found': 7, 'faults': 13, 'minutes to detection': [None, None, 45, 0, None, 449, 5, 28, None, None, None, 14, 8]}Ce que cela nous apprend. Les seuils sont très élevés : |z| au-dessus de 20 et de 50. Beaucoup de métriques changent à peine pendant les minutes normales. Sur machine-1-1, 17 des 38 métriques ont une dispersion au plancher de 1 %. Pour une telle métrique, un petit pic ordinaire donne un z énorme. Le budget pousse donc le seuil très haut. Sur machine-1-1, la référence de base trouve les 8 défaillances en une minute ou moins, même les très courtes. Sur machine-2-1, elle n’en trouve que 7 sur 13, dont une avec 449 minutes de retard. Dans les 6 défaillances qu’elle manque, aucune métrique n’atteint |z| = 49,6.
Nous n’avons pas exécuté l’autre référence de base du cours, les résidus STL. Sur notre ordinateur portable, STL avec une saison d’un jour (1 440 minutes) a pris 73 secondes pour une seule métrique d’une moitié de test. À cette vitesse, 38 métriques sur trois serveurs prennent plus de deux heures, beaucoup trop pour un carnet.
Isolation Forest sur de courtes fenêtres
Section intitulée « Isolation Forest sur de courtes fenêtres »Isolation Forest voit toutes les métriques à la fois, comme dans Isolation Forest. Une seule minute est bruitée, donc Kwame lui donne de courtes fenêtres. Pour chaque minute, les variables sont la moyenne et l’écart-type de chaque métrique sur les 10 dernières minutes : 76 variables. La forêt a 200 arbres et apprend sur les minutes d’ajustement. Son score mesure à quelle vitesse une minute est isolée.
machine-1-1 (0.3 s): {'pages': 126, 'false pages': 84, 'faults found': 5, 'faults': 8, 'minutes to detection': [254, 239, 226, 340, 258, None, None, None]}machine-2-1 (0.2 s): {'pages': 25, 'false pages': 15, 'faults found': 8, 'faults': 13, 'minutes to detection': [0, None, 45, None, None, 449, 5, 30, None, 6, None, 14, 8]}Ce que cela nous apprend. Sur machine-1-1, Isolation Forest trouve les cinq longues défaillances avec 226 à 340 minutes de retard. Il manque les trois très courtes. Le saut de niveau de la métrique 1 montré plus haut est une variable parmi 76. Une raison probable : les arbres divisent rarement les données selon cette seule variable. Une minute où seule cette variable a changé n’est donc pas isolée rapidement. Les variables comptent plus que l’algorithme présentait la même idée avec des paiements. Sur machine-2-1, les résultats sont à peu près aussi bons que ceux de la référence de base.
Un score de point de rupture en temps réel
Section intitulée « Un score de point de rupture en temps réel »Le problème : les points de rupture regardent en arrière
Section intitulée « Le problème : les points de rupture regardent en arrière »Beaucoup de défaillances ici sont des changements par palier : un niveau change et reste stable. Points de rupture trouvait ces changements avec PELT et la segmentation binaire. Mais ces méthodes découpent une série terminée. Elles ont besoin des minutes qui suivent le changement. Il faut envoyer une notification maintenant.
L’idée : découper seulement la dernière heure
Section intitulée « L’idée : découper seulement la dernière heure »Pensez à un pèse-personne. Vous n’avez pas besoin d’une année de pesées pour voir un changement. Vous comparez les derniers jours aux jours précédents. Kwame fait la même chose chaque minute. Il prend seulement les 60 dernières minutes. Il demande : quelle coupure unique convient le mieux à cette heure, et de combien réduit-elle l’erreur quadratique? Si un seul niveau décrit bien l’heure, aucune coupure n’aide beaucoup. Si le niveau a changé pendant l’heure, la meilleure coupure réduit beaucoup l’erreur quadratique. Cette réduction est le score.
Un petit exemple. Douze minutes d’une mesure mise à l’échelle : 0,1, −0,2, 0,0, 0,2, −0,1, 0,0, puis 2,1, 1,9, 2,0, 2,2, 1,8, 2,0. Sans coupure, l’erreur quadratique est de 12,20. Dans ce petit exemple, chaque coupure laisse au moins 3 minutes de chaque côté (le vrai score en utilise 5) :
cut before minute 4: squared error 7.93, lowered by 4.27cut before minute 5: squared error 6.50, lowered by 5.70cut before minute 6: squared error 3.63, lowered by 8.57cut before minute 7: squared error 0.20, lowered by 12.00cut before minute 8: squared error 3.97, lowered by 8.23cut before minute 9: squared error 6.20, lowered by 6.00cut before minute 10: squared error 8.20, lowered by 4.00La meilleure coupure se trouve avant la minute 7, là où le niveau a changé. Elle réduit l’erreur quadratique de 12,00, soit presque toute l’erreur.
Description textuelle du diagramme
Le diagramme présente un flux de gauche à droite. Première case : chaque minute, prenez les 60 dernières minutes des 38 mesures mises à l’échelle. Deuxième case : essayez chaque coupure avec au moins 5 minutes de chaque côté. Troisième case : le score correspond à la réduction de l’erreur quadratique obtenue avec la meilleure coupure. Un losange demande : le score dépasse-t-il le seuil pour 1 notification par jour? La flèche oui mène à la dernière case : envoyez une notification et nommez la mesure ayant la plus grande cote z robuste.
change_score fait ce calcul chaque minute pour les 38 mesures à la fois. Chaque mesure est d’abord mise à l’échelle selon sa médiane et sa dispersion, comme pour la cote z robuste. Les sommes cumulées accélèrent le calcul : une moitié de test prend moins d’une seconde.
def change_score(z, w=60, m=5): """A live change-point score: in the last w minutes, the best single cut with at least m minutes on each side, and how much it lowers the squared error (the l2 cost of the ruptures package). z: scaled metrics.""" n, d = z.shape S = np.vstack([np.zeros(d), np.cumsum(z, axis=0)]) out = np.zeros(n) t = np.arange(w - 1, n) # the window is a = t - w + 1 ... t a = t - w + 1 best = np.zeros(len(t)) for k in range(m, w - m + 1): # the cut: k minutes before it, w - k after it c = a + k left = (S[c] - S[a]) / k right = (S[t + 1] - S[c]) / (w - k) gain = (k * (w - k) / w) * ((left - right) ** 2).sum(axis=1) best = np.maximum(best, gain) out[w - 1:] = best return outEst-ce vraiment la coupure que trouve l’outil du cours? Le carnet (notebook) Jupyter compare une minute avec la segmentation binaire de ruptures, avec une coupure et le coût l2 :
ruptures: cut after minute 37 of 60; squared error lowered by 945.3change_score at that minute: 945.3Le script de mesure a vérifié 200 minutes au hasard de la même façon. La plus grande différence était de 1,2 × 10⁻¹², une erreur d’arrondi.
machine-1-1: {'pages': 185, 'false pages': 116, 'faults found': 8, 'faults': 8, 'minutes to detection': [2, 1, 0, 0, 0, 0, 0, 0]}machine-2-1: {'pages': 38, 'false pages': 22, 'faults found': 10, 'faults': 13, 'minutes to detection': [0, None, 45, 0, None, 2, 5, 30, None, 6, 8, 14, 8]}Ce que cela nous apprend. Le score de point de rupture trouve les 8 défaillances de machine-1-1 en 2 minutes, et 10 des 13 de machine-2-1. Regardez la sixième défaillance de machine-2-1 : la référence de base l’a trouvée après 449 minutes, le score de point de rupture après 2. Une raison probable : le jeu de données associe quatre mesures à cette défaillance. De petits changements simultanés dans plusieurs mesures s’additionnent dans l’erreur quadratique. Pourtant, aucune cote z individuelle n’atteint le seuil de la référence de base.
Trois détecteurs sur une défaillance
Section intitulée « Trois détecteurs sur une défaillance »- Cote z robuste
- Isolation Forest
- Point de rupture
- Seuil, début et fin de la défaillance
Description textuelle du graphique
Trois lignes montrent le score de chaque détecteur divisé par son propre seuil. Ainsi, 1 représente le seuil pour tous. Une ligne pointillée marque 1. Avant la défaillance, les trois lignes restent surtout sous 1. À la minute 0, les lignes de la cote z robuste et du point de rupture dépassent largement 1 en 2 minutes. La cote z robuste reste au-dessus de 1 pendant 82 % de la défaillance. La ligne du point de rupture passe sous 1 après environ une heure, puis remonte chaque fois que le niveau change. Elle dépasse 1 pendant 66 % de la défaillance. La ligne d’Isolation Forest reste sous 1 jusqu’à la minute 254, puis dépasse ce seuil pendant une partie du temps restant.
Pourquoi la ligne du point de rupture passe-t-elle sous 1 environ une heure après le début? Les 60 dernières minutes ont alors de nouveau un seul niveau : rien n’a changé pendant l’heure. Un score de point de rupture dit « le niveau a changé », pas « il est encore élevé ». Pour envoyer une notification, cela suffit.
La comparaison équitable
Section intitulée « La comparaison équitable »Prédisez. Avec un budget de 1 notification par jour par serveur, quel détecteur trouve le plus de défaillances en 30 minutes? La simple cote z robuste, Isolation Forest (forêt d’isolement) ou le score de point de rupture?
Le carnet évalue les trois détecteurs sur les deux serveurs de comparaison et additionne les résultats. Les « heures de travail d’ingénierie » correspondent aux fausses notifications × 15 minutes, par serveur et par semaine (une hypothèse).
pages false pages per day precision faults found found within 30 min median minutes to detection engineer hours a week on false pagesrobust z 179 2.68 0.458 15 13 0.0 4.7Isolation Forest 151 2.73 0.344 13 6 45.0 4.8change point 223 3.81 0.381 18 17 1.5 6.7Une mesure pour choisir
Section intitulée « Une mesure pour choisir »Quelle colonne décide? Hiroshi demandait de trouver les défaillances tôt, sans dépasser le budget de notifications. La mesure est donc les défaillances trouvées en 30 minutes, avec le même budget de notifications. Les autres colonnes l’expliquent :
- Le score de point de rupture en trouve le plus : 17 défaillances sur 21 en 30 minutes, contre 13 pour la cote z robuste et 6 pour Isolation Forest.
- La cote z robuste a la meilleure précision : 45,8 % de ses notifications sont vraies. Elle envoie moins de fausses notifications (2,68 par jour) que le score de point de rupture (3,81).
- Isolation Forest perd dans chaque colonne, sauf celle du nombre de notifications. Son délai médian de détection est de 45 minutes.
Le budget a été dépassé
Section intitulée « Le budget a été dépassé »Le budget était de 1 notification par jour. Sur les moitiés de test, chaque détecteur envoie 2,7 à 3,8 fausses notifications par jour. Les jours de calibration étaient plus calmes que les jours de test. Le pire cas est machine-1-1, avec 4,2 à 5,9 fausses notifications par jour. Seulement 6 à 14 de ses 83 à 116 fausses notifications sont survenues à moins d’une heure d’une défaillance. Les limites des étiquettes ne les expliquent donc pas.
Un seuil fixé sur trois ou quatre jours reste une estimation pour les trois semaines suivantes, comme dans Quand le « normal » change. Et les détecteurs n’ont pas le même coût. Le tableau n’est donc pas tout à fait équitable. Le graphique ci-dessous rend la comparaison équitable. Pour dix budgets, il compare les fausses notifications réellement envoyées aux défaillances trouvées en 30 minutes :
- Cote z robuste
- Isolation Forest
- Point de rupture
Description textuelle du graphique
Trois lignes avec des points, une par détecteur, pour dix budgets. L’axe horizontal montre les fausses notifications réellement envoyées par jour sur les moitiés de test, de 0 à 11. L’axe vertical montre les défaillances trouvées en 30 minutes, sur 21. La ligne du point de rupture commence à 15 défaillances avec 2,1 fausses notifications par jour. Elle reste à 17 entre 3,8 et 7 fausses notifications, puis atteint 19 vers 9. La ligne de la cote z robuste commence à 12 défaillances avec 0,44 fausse notification par jour. Elle va de 13 à 16 entre 1 et 5 fausses notifications, puis atteint 18 vers 7,6. Isolation Forest reste à 6 défaillances jusqu’à environ 3 fausses notifications par jour et atteint 17 seulement vers 8.
Ce que cela nous apprend. Entre 2 et 5 fausses notifications par jour, le score de point de rupture trouve 1 à 3 défaillances de plus en 30 minutes que la cote z robuste. Au-dessus d’environ 7, la cote z robuste le rattrape. Seule la cote z robuste peut envoyer très peu de notifications : 12 défaillances avec 0,44 fausse notification par jour. Sur ces fenêtres, Isolation Forest reste loin derrière jusqu’à environ 8 fausses notifications par jour.
Kwame choisit le score de point de rupture pour les notifications. Il le choisit sur ces deux serveurs seulement, avant d’examiner le troisième.
Expliquer une notification
Section intitulée « Expliquer une notification »Une notification disant « le serveur 1-1 est inhabituel » oblige l’ingénieur à examiner 38 mesures à 3 h du matin. Expliquer une alerte demandait d’inclure la raison dans l’alerte elle-même. Ici, la raison est simple : à la première minute d’alerte, nommez la mesure ayant la plus grande |cote z robuste|. Le score de point de rupture décide quand envoyer une notification, et la cote z robuste indique ce qui a changé. Plusieurs métriques à la fois se terminait avec la même conception.
SMD nous permet de vérifier. Pour chaque défaillance, les auteurs du jeu de données ont indiqué les mesures associées.
machine-1-1: the top metric is in the dataset's label for 8 of 8 found faults [(1, True), (9, True), (9, True), (14, True), (9, True), (9, True), (9, True), (9, True)]machine-2-1: the top metric is in the dataset's label for 6 of 10 found faults [(16, False), (10, True), (34, True), (26, True), (18, True), (9, True), (18, False), (11, False), (16, False), (16, True)]Ce que cela nous apprend. Sur machine-1-1, la mesure nommée figure toujours parmi celles des auteurs. Sur machine-2-1, elle est correcte dans 6 cas sur 10. La mesure 16 est nommée trois fois et est incorrecte deux fois. L’explication donne un bon point de départ, pas un diagnostic.
Le nouveau serveur, une seule fois
Section intitulée « Le nouveau serveur, une seule fois »Le choix est fait : le score de point de rupture pour les notifications, la mesure ayant le plus grand |z| pour l’explication. Kwame exécute maintenant les trois détecteurs sur machine-3-1, avec les mêmes règles et sans changement. Aucune étape ne l’a utilisé, et il provient du troisième groupe de serveurs.
Prédisez. Le détecteur choisi gardera-t-il son avance sur un serveur d’un autre groupe?
machine-3-1: 19.9 test days, 4 fault windows pages false pages per day faults found minutes to detection alert minutesrobust z 35 1.51 2 [None, 31, None, 16] 57Isolation Forest 490 24.18 4 [3, 116, 0, 0] 8785change point 56 2.31 4 [12, 21, 20, 6] 514Description textuelle du graphique
Un diagramme à trois colonnes montre les fausses notifications par jour sur machine-3-1. Cote z robuste : 1,51, et elle trouve 2 défaillances sur 4. Isolation Forest : 24,18, de loin le plus haut, et il trouve 4 défaillances sur 4. Point de rupture : 2,31, mis en évidence, et il trouve 4 défaillances sur 4.
Ce que cela nous apprend. Le choix tient. Le score de point de rupture trouve les 4 défaillances, 6 à 21 minutes après leur début, avec 2,31 fausses notifications par jour. La cote z robuste en manque la moitié. Isolation Forest trouve aussi les 4, mais envoie 24,18 fausses notifications par jour. Il est en alerte pendant 8 785 des 28 700 minutes de test. Sa normale, apprise sur la moitié d’entraînement, ne convenait pas à la moitié de test de ce serveur. « Les 4 trouvées » signifie peu quand le détecteur alerte presque tout le temps.
Regardez aussi le délai de détection : 6 à 21 minutes, plus lent que pour la plupart des défaillances des serveurs de comparaison. Le jeu de données associe 3 à 15 mesures à chacune de ces quatre défaillances. Nous n’avons pas étudié pourquoi elles sont trouvées plus tard.
Erreur courante
L'alerte qui a duré dix jours
Symptôme : Kwame a d’abord fixé le budget en événements d’alerte, selon la règle du cours : des alertes espacées de moins de 30 minutes forment un événement. Sur machine-3-1, la cote z robuste respectait son budget : seulement 7 événements d’alerte en 20 jours. Hiroshi était satisfaite. Puis son téléphone n’arrêtait pas de sonner.
Diagnostic : le carnet compte les minutes d’alerte et les notifications pour le même seuil :
cal, st, _ = new_scores["robust z"]flags = st > threshold_for_budget(cal, BUDGET, count="events") # the budget counts alert events, not pagesevents = events_of(flags)print("alert events:", len(events), "| alert minutes:", int(flags.sum()), "| pages:", len(pages_of(flags)))print("the longest alert event:", max(e - s + 1 for s, e in events), "minutes")alert events: 7 | alert minutes: 3095 | pages: 928the longest alert event: 14967 minutesUne mesure déclenche une alerte toutes les quelques minutes, et les intervalles n’atteignent jamais 30 minutes. Les alertes forment donc un seul événement de 14 967 minutes, soit plus de 10 jours. Le nombre d’événements reste bas, et l’ingénieur reçoit 928 notifications.
Correction : comptez ce qui atteint la personne : les notifications, avec un délai de répétition. Ou limitez la durée d’un événement, par exemple « un nouvel événement après 60 minutes ». Fixez ensuite le budget de nouveau.
Conséquence pour le travail en IA : une mesure qui cache le coût donne une bonne apparence à un mauvais détecteur. Une alerte sans fin est le moyen le plus rapide de la faire désactiver, comme dans Fatigue d’alerte et responsabilité.
Recommandation
Section intitulée « Recommandation »Kwame écrit à Hiroshi dans ses mots :
- Envoyez les notifications avec le score de point de rupture sur les 60 dernières minutes, à raison de 1 notification par jour normal. Sur les deux serveurs de comparaison, il a trouvé 17 défaillances sur 21 en 30 minutes. Sur le nouveau serveur, il a trouvé les 4.
- Incluez la mesure principale dans la notification. Elle correspondait à la liste du jeu de données pour 17 des 22 défaillances trouvées sur les trois serveurs. Traitez-la comme le premier endroit à examiner.
- Attendez-vous à plus de notifications que le budget. Pendant les jours de test des serveurs de comparaison, il a envoyé en moyenne 3,8 fausses notifications par jour, pas 1 (5,9 sur machine-1-1). Sur le nouveau serveur, il en a envoyé 2,3. Cela représente environ 6,7 heures de travail d’ingénierie par semaine par serveur (à 15 minutes par notification, une hypothèse). Vérifiez le taux réel chaque semaine et refixez le seuil à partir d’une période normale plus longue.
- N’utilisez pas Isolation Forest sur ces fenêtres pour envoyer des notifications. Il était lent sur les serveurs de comparaison et a submergé le nouveau serveur de notifications.
Et les usages à éviter :
- Pas pour les dérives lentes. Un changement prenant plus d’une heure n’apparaît jamais comme un palier dans les 60 dernières minutes. Une fuite de mémoire comme celle de l’API de billets demande une fenêtre plus longue. Par exemple, la référence de base saisonnière de Plusieurs métriques à la fois.
- Pas comme seule vérification d’un parc de serveurs. 1 notification par jour par serveur donne 28 notifications par jour pour 28 serveurs. Il faut aussi regrouper les alertes entre serveurs, pas seulement dans le temps comme dans Plusieurs métriques à la fois.
Constats et limites
Section intitulée « Constats et limites »- La méthode simple était proche. La cote z robuste a trouvé 13 défaillances en 30 minutes contre 17, avec moins de fausses notifications. Elle avait la meilleure précision et aucun réglage autre que le seuil. Si l’équipe doit envoyer moins de notifications, c’est le meilleur choix.
- Le changement par palier est la forme courante des défaillances ici. C’est pourquoi un score de point de rupture gagne. Sur des serveurs ayant des dérives lentes ou des pics courts, le classement pourrait changer.
- Le budget a été fixé sur 3 à 4 jours. Les jours de test étaient plus chargés, donc chaque détecteur l’a dépassé. Une période normale plus longue aiderait.
- Les étiquettes sont des jugements. Un détecteur qui alerte 1 minute après la fin d’une fenêtre ne reçoit aucun crédit. Sa notification compte comme fausse.
- Trois serveurs, 25 défaillances. C’est un petit échantillon, et l’ordre des détecteurs pourrait changer sur d’autres serveurs.
- Aucun nom, aucune heure. Les mesures sont anonymes et mises à l’échelle. Une vraie équipe ajouterait l’heure de la journée, comme dans Le normal change avec l’heure et la saison.
Utilisation responsable
Section intitulée « Utilisation responsable »- Les données concernent les systèmes réels d’une vraie entreprise. Elles ne contiennent aucune donnée personnelle. N’essayez pas de découvrir l’entreprise ou les serveurs qu’elles décrivent.
- Citez la source. La licence MIT permet d’utiliser, de modifier et de partager les données. Conservez l’avis de droit d’auteur et de licence avec toute copie.
- Une notification réveille une personne. Les fausses notifications coûtent du sommeil et de la confiance, pas seulement des minutes. Indiquez les fausses notifications par jour à côté de chaque affirmation sur les défaillances trouvées.
- Indiquez les hypothèses. Le budget de notifications, les 15 minutes par notification et la répétition après 30 minutes sont des choix. Précisez-le partout où un nombre en dépend.
En faire un projet de portfolio
Section intitulée « En faire un projet de portfolio »Cette étude de cas montre à un employeur que vous savez utiliser des données d’exploitation réelles pour décider d’envoyer des notifications. Elle montre aussi que vous évaluez honnêtement les détecteurs, en présentant le coût à côté du gain. Personnalisez-la avec un changement : plus de serveurs, une autre durée de fenêtre ou l’heure de la journée, par exemple. Rendez-la ensuite publique et facile à lire en cinq minutes.
Quoi mettre dans le dépôt :
README.md, la page que les gens lisent en premier (modèle ci-dessous).- Le carnet, exécuté du début à la fin, avec ses sorties.
scoring.md: les règles d’évaluation (notifications, répétition après 30 minutes, défaillances trouvées, délai de détection) et la règle du seuil.comparison.csv: les trois détecteurs au budget fixé, etcurves.csvavec les dix budgets;new_server.csv, conservé à part.- La source et la licence des données, avec le texte d’attribution ci-dessus. Un lien et les sommes de contrôle suffisent; vous n’avez pas besoin de copier les données.
Un modèle de README :
# Paging on server faults: robust z vs Isolation Forest vs a live change point
## ProblemAn on-call team watches 38 metrics per server. Budget: 1 page a day per server on normaldays; a false page costs 15 minutes; an alert that stays on pages again after 30 minutes(assumptions). Find faults early.
## Data and licenceSMD (Server Machine Dataset), NetManAIOps, MIT licence,https://github.com/NetManAIOps/OmniAnomaly. Servers machine-1-1 and machine-2-1(comparison, 21 faults) and machine-3-1 (new input, 4 faults), chosen by a rule.
## ApproachFit on the first 80% of the unlabelled training half, threshold for 1 page a day on thelast 20%, score on the labelled test half. Robust z per metric (max of 38), IsolationForest on 10-minute means and standard deviations, best single cut in the last 60 minutes.
## ResultsFaults found within 30 minutes: change point 17/21, robust z 13/21, Isolation Forest 6/21.False pages a day: 3.81, 2.68, 2.73. New server: change point 4/4 at 2.31 false pages a day;Isolation Forest 4/4 at 24.18.
## LimitsBudget broken on the test days; 3 servers; anonymous metrics; no time of day; label edges.Comment le décrire en entrevue, en deux phrases : « J’ai comparé trois détecteurs sur des mesures réelles de serveurs avec une règle de seuil sans étiquettes, selon les défaillances trouvées en 30 minutes et les fausses notifications par jour. Un score de point de rupture en temps réel sur la dernière heure a gagné et tenu sur un nouveau serveur, et j’ai montré que compter les événements plutôt que les notifications cachait une alerte de dix jours. »
Pour aller plus loin :
- Testez les 28 serveurs (environ 470 Mo). Le score de point de rupture gagne-t-il encore sur la plupart?
- Combinez la cote z robuste et le score de point de rupture dans une règle : envoyez une notification si l’un dépasse son seuil. Fixez le budget pour la paire et comparez.
- Comparez avec les autres études de cas, Fraude par carte avec un budget de révision et Cartes de contrôle sur une vraie ligne de production : où une méthode simple gagne-t-elle?
À vous de jouer
Section intitulée « À vous de jouer »La section 9 du carnet Jupyter propose deux tâches.
Tâche 1. Le score de point de rupture exige au moins 5 minutes de chaque côté de la coupure. Avant de l’exécuter, faites une prédiction. Avec au moins 10 minutes, trouvera-t-il plus ou moins de défaillances en 30 minutes? Exécutez change_score(z, m=10) sur les deux serveurs de comparaison, avec les mêmes règles. Inscrivez le nombre dans found_30_m10.
Afficher la réponse
rows = []for m in DEV: train, test, label = data[m] n_fit = int(len(train) * FIT_SHARE) med, spread = robust_scale(train[:n_fit]) z_train, z_test = (train - med) / spread, (test - med) / spread threshold = threshold_for_budget(change_score(z_train, m=10)[n_fit:]) rows.append(score_windows(change_score(z_test, m=10) > threshold, windows_of(label)))found_30_m10 = pooled(rows, dev_days)["found within 30 min"]print(found_30_m10)16Une de moins qu’avec 5 minutes (17). Un côté plus long exige plus de minutes après le changement avant que la coupure compte. Il manque aussi les changements de niveau de courte durée.
Tâche 2. Exécutez la comparaison avec un budget de 2 notifications par jour à l’aide de compare(2.0). Combien de fausses notifications par jour la cote z robuste produit-elle sur les serveurs de comparaison? Inscrivez ce nombre dans robust_false_per_day_2.
Afficher la réponse
robust_false_per_day_2 = compare(2.0).loc["robust z", "false pages per day"]print(robust_false_per_day_2)3.62De 2,68 à 3,62 fausses notifications par jour, pour une défaillance de plus détectée en 30 minutes (14 plutôt que 13). Doubler le budget ne double pas le nombre de défaillances détectées.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Avec la règle du cours pour les événements d'alerte, la cote z robuste a respecté son budget sur le nouveau serveur : 7 événements d'alerte en 20 jours. Pourquoi cette mesure était-elle mauvaise ici, et qu'a compté Kwame à la place?
Afficher la réponse
Les alertes espacées de moins de 30 minutes forment un seul événement. Une mesure déclenchait une alerte toutes les quelques minutes. Les intervalles n’atteignaient donc jamais 30 minutes. Les alertes ont formé un seul événement de 14 967 minutes, soit plus de 10 jours. Le nombre d’événements restait faible, mais l’ingénieur recevrait 928 notifications. Kwame a plutôt compté les notifications : une à la première minute d’alerte, puis une autre après 30 minutes si les alertes continuent. Un budget doit compter ce qui parvient à la 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.
Vérifiez votre compréhension
Sur le nouveau serveur, Isolation Forest a trouvé les 4 défaillances, tout comme le score de point de rupture. Pourquoi reste-t-il le pire choix?
Afficher la réponse
Il les a trouvées en déclenchant des alertes presque tout le temps : pendant 8 785 des 28 700 minutes. Il a envoyé 24,18 fausses notifications par jour, contre 2,31 pour le score de point de rupture. Un détecteur qui alerte tout le temps trouve chaque défaillance, mais personne ne peut agir sur ses alertes. Le nombre de défaillances détectées n’a de sens qu’avec le nombre de fausses notifications qu’il a coûtées. Son comportement normal, appris sur la moitié d’entraînement, ne correspondait pas à la moitié de test de ce serveur.
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
Les méthodes de points de rupture du cours découpent une série terminée. Comment le score de point de rupture de cette étude de cas envoie-t-il des notifications en temps réel? Quel type de défaillance ne peut-il pas voir?
Afficher la réponse
Chaque minute, il examine seulement les 60 dernières minutes. Il y trouve la meilleure coupure unique, avec au moins 5 minutes de chaque côté. Il évalue ensuite combien cette coupure réduit l’erreur quadratique. Il n’a besoin d’aucune minute future. Il peut donc envoyer une notification immédiatement, quelques minutes après un changement de niveau. Il ne peut pas voir une dérive lente qui dure plus d’une heure, comme une fuite de mémoire. Dans une heure donnée, le niveau bouge à peine. Après un changement de niveau, le score baisse de nouveau, car la dernière heure présente un seul niveau.
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
- Les défaillances de serveur sont des fenêtres. Évaluez un détecteur en combinant les défaillances détectées, les minutes avant la détection et les fausses notifications par jour.
- Fixez chaque seuil de la même façon, sans aucune étiquette : apprenez le comportement normal sur les minutes d’ajustement, puis fixez le budget sur les minutes de calibration.
- Le score de point de rupture en temps réel (la meilleure coupure dans les 60 dernières minutes) a trouvé 17 des 21 défaillances en 30 minutes. La simple cote z robuste en a trouvé 13 avec moins de fausses notifications. Isolation Forest appliqué aux fenêtres en a trouvé 6.
- Le budget d’une notification par jour n’a pas tenu pendant les jours de test, pour tous les détecteurs. Comparez-les aussi à nombre égal de fausses notifications par jour.
- Sur le nouveau serveur, le détecteur choisi a trouvé les 4 défaillances. Comptez les notifications, pas les événements d’alerte : un événement a duré 10 jours.
Ensuite, une étude de cas sans aucune étiquette : une vraie série publique où vous insérez vos propres anomalies pour mesurer les détecteurs.
Leçon suivante : Mesures inhabituelles dans des données ouvertes publiques