Analyse de série chronologique

S’applique à : ✅Microsoft Fabric

Les services cloud et les appareils IoT génèrent des données de télémétrie qui peuvent être utilisées pour obtenir des insights tels que la surveillance de l’intégrité des services, les processus de production physique et les tendances d’utilisation. L’exécution d’une analyse de série chronologique est un moyen d’identifier les écarts dans le modèle de ces métriques par rapport à leur modèle de référence classique.

Kusto Query Language (KQL) contient la prise en charge native de la création, de la manipulation et de l’analyse de plusieurs séries chronologiques. Dans cet article, découvrez comment KQL est utilisé pour créer et analyser des milliers de séries chronologiques en secondes, ce qui permet d’effectuer des solutions et des flux de travail de surveillance en temps quasi réel.

Création de séries chronologiques

Dans cette section, nous allons créer un grand ensemble de séries chronologiques régulières simplement et intuitivement à l’aide de l’opérateur make-series , et remplir les valeurs manquantes si nécessaire. La première étape de l’analyse de série chronologique consiste à partitionner et transformer la table de télémétrie d’origine en un ensemble de séries chronologiques. La table contient généralement une colonne d’horodatage, des dimensions contextuelles et des métriques facultatives. Les dimensions sont utilisées pour partitionner les données. L’objectif est de créer des milliers de séries chronologiques par partition à intervalles réguliers.

La table demo_make_series1 contient 600 000 enregistrements de trafic arbitraire des services web. Utilisez la commande suivante pour échantillonner 10 enregistrements :

demo_make_series1 | take 10 

La table résultante contient une colonne d’horodatage, trois colonnes de dimensions contextuelles et aucune métrique :

Étant donné qu’il n’existe aucune métrique, nous ne pouvons générer qu’un ensemble de séries chronologiques représentant le nombre de trafics lui-même, partitionné par le système d’exploitation à l’aide de la requête suivante :

let min_t = toscalar(demo_make_series1 | summarize min(TimeStamp));
let max_t = toscalar(demo_make_series1 | summarize max(TimeStamp));
demo_make_series1
| make-series num=count() default=0 on TimeStamp from min_t to max_t step 1h by OsVer
| render timechart 

• Utilisez l’opérateur make-series pour créer un ensemble de trois séries chronologiques, où :
  • num=count(): série chronologique du trafic
  • from min_t to max_t step 1h : la série chronologique est créée en compartiments de 1 heure dans l’intervalle de temps (timestamps les plus anciens et les plus récents des enregistrements de la table)
  • default=0: spécifiez la méthode de remplissage pour les compartiments manquants afin de créer des séries chronologiques régulières. Vous pouvez également utiliser series_fill_const(), series_fill_forward(), series_fill_backward() et series_fill_linear() pour les modifications.
  • by OsVer: partition par système d’exploitation
• La structure de données de série chronologique réelle est un tableau numérique de la valeur agrégée par compartiment de temps. Nous utilisons render timechart pour la visualisation.

Dans le tableau ci-dessus, nous avons trois partitions. Nous pouvons créer une série chronologique distincte : Windows 10 (rouge), 7 (bleu) et 8.1 (vert) pour chaque version du système d’exploitation, comme indiqué dans le graphique :

Fonctions d’analyse de série chronologique

Dans cette section, nous allons effectuer des fonctions de traitement de série standard. Une fois qu’un ensemble de séries chronologiques est créé, KQL prend en charge une liste croissante de fonctions à traiter et à les analyser. Nous allons décrire quelques fonctions représentatives pour le traitement et l’analyse des séries chronologiques.

Filtrage

Le filtrage est une pratique courante dans le traitement des signaux et utile pour les tâches de traitement de série chronologique (par exemple, lissage d’un signal bruyant, détection des modifications).

• Il existe deux fonctions de filtrage générique :
  • series_fir(): Application du filtre FIR. Utilisé pour le calcul simple de la moyenne mobile et de la différenciation des séries chronologiques pour la détection des modifications.
  • series_iir(): Application du filtre IIR. Utilisé pour le lissage exponentiel et la somme cumulative.
• Étendre (Extend) l’ensemble de séries chronologiques en ajoutant une nouvelle série de moyennes mobiles de 5 compartiments (nommée ma_num) à la requête :

let min_t = toscalar(demo_make_series1 | summarize min(TimeStamp));
let max_t = toscalar(demo_make_series1 | summarize max(TimeStamp));
demo_make_series1
| make-series num=count() default=0 on TimeStamp from min_t to max_t step 1h by OsVer
| extend ma_num=series_fir(num, repeat(1, 5), true, true)
| render timechart

Analyse de régression

Une analyse de régression linéaire segmentée peut être utilisée pour estimer la tendance de la série chronologique.

• Utilisez series_fit_line() pour ajuster la meilleure ligne à une série chronologique pour la détection générale des tendances.
• Utilisez series_fit_2lines() pour détecter les changements de tendance, par rapport à la ligne de base, qui sont utiles dans les scénarios de surveillance.

Exemple de fonctions series_fit_line() et series_fit_2lines() dans une requête de série chronologique :

demo_series2
| extend series_fit_2lines(y), series_fit_line(y)
| render linechart with(xcolumn=x)

• Bleu : série chronologique originale
• Vert : droite ajustée
• Rouge : deux droites ajustées

Détection de saisonnalité

De nombreuses métriques suivent des modèles saisonniers (périodiques). Le trafic utilisateur des services cloud contient généralement des modèles quotidiens et hebdomadaires qui sont les plus élevés au milieu de la journée d’activité et le plus bas la nuit et le week-end. Les capteurs IoT mesurent dans des intervalles périodiques. Les mesures physiques telles que la température, la pression ou l’humidité peuvent également présenter un comportement saisonnier.

L'exemple suivant applique la détection de saisonnalité sur un mois de trafic d'un service web (intervalles de 2 heures) :

demo_series3
| render timechart 

• Utilisez series_periods_detect() pour détecter automatiquement les périodes de la série chronologique, où :
  • num: série chronologique à analyser
  • 0.: durée minimale en jours (0 signifie pas minimum)
  • 14d/2h: la durée maximale de la période en jours, soit 14 jours divisés en créneaux de 2 heures
  • 2: nombre de périodes à détecter
• Utilisez series_periods_validate() si nous savons qu’une métrique doit avoir des périodes distinctes spécifiques et que nous voulons vérifier qu’elles existent.

demo_series3
| project (periods, scores) = series_periods_detect(num, 0., 14d/2h, 2) //to detect the periods in the time series
| mv-expand periods, scores
| extend days=2h*todouble(periods)/1d

La fonction détecte la saisonnalité quotidienne et hebdomadaire. Les scores quotidiens sont inférieurs à la semaine, car les jours de week-end sont différents des jours de la semaine.

Fonctions à l’échelle des éléments

Les opérations arithmétiques et logiques peuvent être effectuées sur une série chronologique. En utilisant series_subtract() nous pouvons calculer une série chronologique résiduelle, autrement dit la différence entre la métrique brute d’origine et une métrique lissée, et rechercher des anomalies dans le signal résiduel :

let min_t = toscalar(demo_make_series1 | summarize min(TimeStamp));
let max_t = toscalar(demo_make_series1 | summarize max(TimeStamp));
demo_make_series1
| make-series num=count() default=0 on TimeStamp from min_t to max_t step 1h by OsVer
| extend ma_num=series_fir(num, repeat(1, 5), true, true)
| extend residual_num=series_subtract(num, ma_num) //to calculate residual time series
| where OsVer == "Windows 10"   // filter on Win 10 to visualize a cleaner chart 
| render timechart

• Bleu : série chronologique originale
• Rouge : série chronologique lisse
• Vert : série chronologique résiduelle

Flux de travail des séries temporelles à grande échelle

L’exemple ci-dessous montre comment ces fonctions peuvent s’exécuter à grande échelle sur des milliers de séries chronologiques en secondes pour la détection d’anomalies. Pour afficher quelques exemples d’enregistrements de télémétrie d’une métrique de nombre de lectures d’un service de base de données sur quatre jours, exécutez la requête suivante :

demo_many_series1
| take 4 

Et des statistiques simples :

demo_many_series1
| summarize num=count(), min_t=min(TIMESTAMP), max_t=max(TIMESTAMP) 

La création d’une série chronologique en compartiments de 1 heure de la métrique de lecture (total de quatre jours * 24 heures = 96 points), entraîne une fluctuation du modèle normal :

let min_t = toscalar(demo_many_series1 | summarize min(TIMESTAMP));  
let max_t = toscalar(demo_many_series1 | summarize max(TIMESTAMP));  
demo_many_series1
| make-series reads=avg(DataRead) on TIMESTAMP from min_t to max_t step 1h
| render timechart with(ymin=0) 

Le comportement ci-dessus est trompeur, car la série chronologique normale unique est agrégée à partir de milliers d’instances différentes susceptibles d’avoir des modèles anormaux. Par conséquent, nous créons une série chronologique par instance. Une instance est définie par Loc (emplacement), Op (opération) et DB (ordinateur spécifique).

Combien de séries chronologiques pouvons-nous créer ?

demo_many_series1
| summarize by Loc, Op, DB
| count

Maintenant, nous allons créer un ensemble de 18 339 séries chronologiques pour la métrique du nombre de lectures. Nous ajoutons la by clause à l’instruction make-series, appliquez la régression linéaire et sélectionnez les deux premières séries chronologiques ayant la tendance décroissante la plus importante :

let min_t = toscalar(demo_many_series1 | summarize min(TIMESTAMP));  
let max_t = toscalar(demo_many_series1 | summarize max(TIMESTAMP));  
demo_many_series1
| make-series reads=avg(DataRead) on TIMESTAMP from min_t to max_t step 1h by Loc, Op, DB
| extend (rsquare, slope) = series_fit_line(reads)
| top 2 by slope asc 
| render timechart with(title='Service Traffic Outage for 2 instances (out of 18339)')

Affichez les instances :

let min_t = toscalar(demo_many_series1 | summarize min(TIMESTAMP));  
let max_t = toscalar(demo_many_series1 | summarize max(TIMESTAMP));  
demo_many_series1
| make-series reads=avg(DataRead) on TIMESTAMP from min_t to max_t step 1h by Loc, Op, DB
| extend (rsquare, slope) = series_fit_line(reads)
| top 2 by slope asc
| project Loc, Op, DB, slope 

En moins de deux minutes, près de 20 000 séries chronologiques ont été analysées, et deux séries chronologiques anormales dans lesquelles le nombre de lectures a soudainement baissé ont été détectées.

Ces fonctionnalités avancées combinées aux performances rapides fournissent une solution unique et puissante pour l’analyse des séries chronologiques.

Contenu connexe

• Découvrez la détection et la prévision des anomalies avec KQL.
• Découvrez les fonctionnalités de Machine Learning avec KQL.