Analyse de série chronologique

Changer de service à l’aide de la liste déroulante Version . En savoir plus sur la navigation.
S’applique à : ✅ Microsoft Fabric ✅ Azure Data Explorer ✅ Azure Monitor ✅ Microsoft Sentinel

Les services cloud et les appareils IoT génèrent des données de télémétrie que vous pouvez utiliser pour obtenir des insights sur l’intégrité des services, les processus de production et les tendances d’utilisation. L’analyse de série chronologique vous permet d’identifier les écarts par rapport aux modèles de base classiques.

Kusto Query Language (KQL) prend en charge nativement la création, la manipulation et l’analyse de plusieurs séries chronologiques. Cet article explique comment utiliser KQL pour créer et analyser des milliers de séries chronologiques en secondes afin d’activer des solutions et des flux de travail de surveillance en temps quasi réel.

Création de séries chronologiques

Créez un grand ensemble de séries chronologiques régulières à l’aide de l’opérateur make-series et renseignez les valeurs manquantes si nécessaire. Partitionnez et transformez la table de télémétrie 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 dimension contextuelle et aucune métrique :

Étant donné qu’il n’existe aucune métrique, générez des séries chronologiques représentant le nombre de trafics, partitionnés par système d’exploitation :

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 trois séries chronologiques, où :
  • num=count(): comptage de trafic.
  • from min_t to max_t step 1h: crée la série temporelle dans des intervalles d'une heure, allant du plus ancien au plus récent horodatage de la table.
  • default=0: spécifie 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 un comportement de remplissage différent.
  • by OsVer: partitions par système d’exploitation.
• La structure des données de série chronologique est un tableau numérique de valeurs agrégées pour chaque compartiment de temps. Utiliser render timechart pour la visualisation.

Le tableau ci-dessus comporte trois partitions (Windows 10, Windows 7 et Windows 8.1). Le graphique affiche une série chronologique distincte pour chaque version du système d’exploitation :

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

Cet exemple montre la détection d’anomalies fonctionnant à grande échelle sur des milliers de séries chronologiques en quelques secondes. Pour afficher des exemples d’enregistrements de télémétrie pour une métrique de nombre de lectures du service de base de données sur quatre jours, exécutez la requête suivante :

demo_many_series1
| take 4 

Afficher les statistiques simples :

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

Une série temporelle en intervalles de 1 heure de la métrique de lecture (quatre jours × 24 heures = 96 points) montre une fluctuation horaire normale.

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) 

Ce comportement est trompeur, car la série chronologique normale unique est agrégée à partir de milliers d’instances qui peuvent avoir des modèles anormaux. Créez une série chronologique par instance définie par Loc (emplacement), Op (opération) et DB (ordinateur spécifique).

Combien de séries chronologiques pouvez-vous créer ?

demo_many_series1
| summarize by Loc, Op, DB
| count

Créez 18 339 séries chronologiques pour la métrique de nombre de lectures. Ajoutez la by clause à l’instruction make-series, appliquez la régression linéaire et sélectionnez les deux premières séries chronologiques avec 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, la requête analyse près de 20 000 séries chronologiques et détecte deux avec une chute soudaine du nombre de lectures.

Ces fonctionnalités et les performances de la plateforme fournissent une solution puissante pour l’analyse de série chronologique.

Contenu connexe

• Détection et prévision d’anomalies avec KQL.
• Fonctionnalités de Machine Learning avec KQL.