Anomalieerkennung und -vorhersage

Clouddienste und IoT-Geräte generieren Telemetriedaten, mit denen Erkenntnisse wie die Überwachung der Dienstintegrität, physische Produktionsprozesse und Nutzungstrends gewonnen werden können. Die Durchführung von Zeitreihenanalysen ist eine Möglichkeit, Abweichungen im Muster dieser Metriken im Vergleich zu ihrem typischen Baselinemuster zu identifizieren.

Kusto-Abfragesprache (KQL) enthält native Unterstützung für die Erstellung, Bearbeitung und Analyse mehrerer Zeitreihen. Mit KQL können Sie Tausende von Zeitreihen in Sekunden erstellen und analysieren, sodass Überwachungslösungen und Workflows nahezu in Echtzeit möglich sind.

In diesem Artikel werden die Funktionen zur Erkennung und Vorhersage von Zeitreihenanomalie von KQL erläutert. Die anwendbaren Zeitreihenfunktionen basieren auf einem robusten, gut bekannten Analysemodell, in dem jede ursprüngliche Zeitreihe in saisonale, Trend- und Restkomponenten aufgeschlüsselt wird. Anomalien werden anhand von Ausreißern bei Restkomponenten erkannt, während die Prognose durch Extrapolieren von saisonalen und Trendkomponenten erfolgt. Die KQL-Implementierung verbessert das grundlegende Zerlegungsmodell erheblich durch automatische Saisonalitätserkennung, robuste Ausreißeranalyse und vektorisierte Implementierung, um Tausende von Zeitreihen in Sekunden zu verarbeiten.

Voraussetzungen

• Ein Microsoft-Konto oder eine Microsoft Entra Benutzeridentität. Ein Azure-Abonnement ist nicht erforderlich.
• Lesen Sie die Zeitreihenanalyse , um eine Übersicht über die Funktionen von Zeitreihen zu finden.

Zeitreihenanalyse-Modell

Die native KQL-Implementierung für Zeitreihenvorhersage und Anomalieerkennung verwendet ein bekanntes Zerlegungsmodell. Dieses Modell wird auf Zeitreihen von Metriken angewendet, von denen erwartet wird, dass sie regelmäßiges und Trendverhalten wie Dienstdatenverkehr, Komponententakt und periodische IoT-Messungen zum Vorhersagen zukünftiger Metrikwerte und Erkennen anomaler Werte manifestieren. Dieser Regressionsprozess geht von der Annahme aus, dass die Zeitreihen anders als das zuvor bekannte saisonale und Trendverhalten nach dem Zufallsprinzip verteilt sind. Sie können dann zukünftige Metrikwerte auf Basis der saisonalen und Trendkomponenten, zusammen als Baseline bezeichnet, prognostizieren und den restlichen Teil ignorieren. Sie können anomale Werte auch basierend auf der Ausreißeranalyse erkennen, wobei nur der restliche Teil verwendet wird. Verwenden Sie zum Erstellen eines Analysemodells die Funktion series_decompose(). Die series_decompose()-Funktion nimmt einen Satz von Zeitreihen und schlüsselt sie automatisch jedes Mal in saisonale, Trend-, Rest- und Baselinekomponenten auf.

Beispielsweise können Sie Datenverkehr eines internen Webdiensts mit der folgenden Abfrage aufschlüsseln:

Abfrage ausführen

let min_t = datetime(2017-01-05);
let max_t = datetime(2017-02-03 22:00);
let dt = 2h;
demo_make_series2
| make-series num=avg(num) on TimeStamp from min_t to max_t step dt by sid 
| where sid == 'TS1'   //  select a single time series for a cleaner visualization
| extend (baseline, seasonal, trend, residual) = series_decompose(num, -1, 'linefit')  //  decomposition of a set of time series to seasonal, trend, residual, and baseline (seasonal+trend)
| render timechart with(title='Web app. traffic of a month, decomposition', ysplit=panels)

• Die ursprüngliche Zeitreihe wird mit num (in Rot) bezeichnet.
• Der Prozess beginnt mit der automatischen Erkennung der Saisonabhängigkeit mithilfe der Funktion series_periods_detect() und extrahiert das saisonale Muster (in Violett).
• Das saisonale Muster wird der ursprünglichen Zeitreihe entnommen und eine lineare Regression mit der Funktion series_fit_line() ausgeführt, um die Trendkomponente (in Hellblau dargestellt) zu finden.
• Die Funktion entnimmt den Trend, und das Verbleibende ist die Restkomponente (in Grün).
• Abschließend fügt die Funktion die saisonalen und Trendkomponenten hinzu, um die Baseline (in Blau) zu generieren.

Anomalieerkennung in Zeitreihen

Die Funktion series_decompose_anomalies() sucht anomale Punkte in einem Satz von Zeitreihen. Diese Funktion ruft series_decompose() zum Erstellen des Analysemodells auf und führt dann series_outliers() für die Restkomponente aus. series_outliers() berechnet die Anomaliebewertungen für jeden Punkt der Restkomponente mithilfe des Zauntests von Tukey. Anomaliebewertungen über 1,5 oder unter -1,5 zeigen einen leichten Anomalienanstieg bzw. -abfall an. Anomaliebewertungen über 3,0 oder unter -3,0 zeigen eine starke Anomalie an.

Mit der folgenden Abfrage können Sie Anomalien im internen Webdienstdatenverkehr erkennen:

Abfrage ausführen

let min_t = datetime(2017-01-05);
let max_t = datetime(2017-02-03 22:00);
let dt = 2h;
demo_make_series2
| make-series num=avg(num) on TimeStamp from min_t to max_t step dt by sid 
| where sid == 'TS1'   //  select a single time series for a cleaner visualization
| extend (anomalies, score, baseline) = series_decompose_anomalies(num, 1.5, -1, 'linefit')
| render anomalychart with(anomalycolumns=anomalies, title='Web app. traffic of a month, anomalies') //use "| render anomalychart with anomalycolumns=anomalies" to render the anomalies as bold points on the series charts.

• Die ursprünglichen Zeitreihen (in Rot).
• Die Baselinekomponente (saisonal und Trend – in Blau).
• Die anomalen Punkte (in Violett) über der ursprünglichen Zeitreihe. Die anomalen Punkte weichen deutlich von den erwarteten Baselinewerten ab.

Zeitreihenvorhersage

Die Funktion series_decompose_forecast() prognostiziert die zukünftigen Werte eines Satzes Reihe von Zeitreihen. Diese Funktion ruft series_decompose() auf, um das Analysemodell zu erstellen, und extrapoliert dann für jede Zeitreihe die Baselinekomponente in die Zukunft.

Mit der folgenden Abfrage können Sie den Webdienstdatenverkehr der nächsten Woche vorhersagen:

Abfrage ausführen

let min_t = datetime(2017-01-05);
let max_t = datetime(2017-02-03 22:00);
let dt = 2h;
let horizon=7d;
demo_make_series2
| make-series num=avg(num) on TimeStamp from min_t to max_t+horizon step dt by sid 
| where sid == 'TS1'   //  select a single time series for a cleaner visualization
| extend forecast = series_decompose_forecast(num, toint(horizon/dt))
| render timechart with(title='Web app. traffic of a month, forecasting the next week by Time Series Decomposition')

• Ursprüngliche Metrik (in Rot). Zukünftige Werte fehlen und werden standardmäßig auf 0 (null) gesetzt.
• Extrapolieren Sie die Baselinekomponente (in Blau), um die Werte der nächsten Woche vorherzusagen.

Skalierbarkeit

Kusto-Abfragesprache Syntax ermöglicht einen einzelnen Aufruf, mehrere Zeitreihen zu verarbeiten. Ihre einzigartig optimierte Implementierung ermöglicht schnelle Verarbeitung, was für effektive Anomalieerkennung und Vorhersagen beim Überwachen Tausender von Leistungsindikatoren in nahezu in Echtzeit ablaufenden Szenarien von entscheidender Bedeutung ist.

Die folgende Abfrage zeigt die gleichzeitige Verarbeitung von drei Zeitreihen:

Abfrage ausführen

let min_t = datetime(2017-01-05);
let max_t = datetime(2017-02-03 22:00);
let dt = 2h;
let horizon=7d;
demo_make_series2
| make-series num=avg(num) on TimeStamp from min_t to max_t+horizon step dt by sid
| extend offset=case(sid=='TS3', 4000000, sid=='TS2', 2000000, 0)   //  add artificial offset for easy visualization of multiple time series
| extend num=series_add(num, offset)
| extend forecast = series_decompose_forecast(num, toint(horizon/dt))
| render timechart with(title='Web app. traffic of a month, forecasting the next week for 3 time series')

Zusammenfassung

In diesem Dokument werden native KQL-Funktionen für die Erkennung und Vorhersage von Zeitreihenanomalie beschrieben. Jede ursprüngliche Zeitreihe wird für die Erkennung von Anomalien und/oder Prognose in saisonale, Trend- und Restkomponenten aufgeschlüsselt. Diese Funktionen können für nahezu in Echtzeit ablaufende Überwachungsszenarien wie z.B. Fehlererkennung, vorbeugende Wartung sowie Bedarfs- und Auslastungsvorhersagen verwendet werden.

Verwandte Inhalte

• Weitere Informationen zu Machine Learning-Funktionen mit KQL