Tijdreeksanalyse
Cloudservices en IoT-apparaten genereren telemetriegegevens die kunnen worden gebruikt om inzichten te verkrijgen, zoals het bewaken van de servicestatus, fysieke productieprocessen en gebruikstrends. Het uitvoeren van een tijdreeksanalyse is een manier om afwijkingen in het patroon van deze metrische gegevens te identificeren ten opzichte van hun typische basislijnpatroon.
Kusto-querytaal (KQL) bevat systeemeigen ondersteuning voor het maken, bewerken en analyseren van meerdere tijdreeksen. In dit artikel leert u hoe KQL wordt gebruikt voor het maken en analyseren van duizenden tijdreeksen in seconden, waardoor bijna realtime bewakingsoplossingen en werkstromen mogelijk zijn.
Tijdreeks maken
In deze sectie maken we eenvoudig en intuïtief een grote set reguliere tijdreeksen met behulp van de make-series
operator en vullen we ontbrekende waarden zo nodig in.
De eerste stap in tijdreeksanalyse bestaat uit het partitioneren en transformeren van de oorspronkelijke telemetrietabel naar een set tijdreeksen. De tabel bevat meestal een tijdstempelkolom, contextuele dimensies en optionele metrische gegevens. De dimensies worden gebruikt om de gegevens te partitioneren. Het doel is om met regelmatige tijdsintervallen duizenden tijdreeksen per partitie te maken.
De invoertabel demo_make_series1 bevat 600.000 records van willekeurig webserviceverkeer. Gebruik de volgende opdracht om een voorbeeld van 10 records te nemen:
demo_make_series1 | take 10
De resulterende tabel bevat een tijdstempelkolom, drie kolommen met contextuele dimensies en geen metrische gegevens:
TimeStamp | BrowserVer | OsVer | Land/regio |
---|---|---|---|
2016-08-25 09:12:35.4020000 | Chrome 51.0 | Windows 7 | Verenigd Koninkrijk |
2016-08-25 09:12:41.1120000 | Chrome 52.0 | Windows 10 | |
2016-08-25 09:12:46.2300000 | Chrome 52.0 | Windows 7 | Verenigd Koninkrijk |
2016-08-25 09:12:46.5100000 | Chrome 52.0 | Windows 10 | Verenigd Koninkrijk |
2016-08-25 09:12:46.5570000 | Chrome 52.0 | Windows 10 | Republiek Litouwen |
2016-08-25 09:12:47.0470000 | Chrome 52.0 | Windows 8.1 | India |
2016-08-25 09:12:51.3600000 | Chrome 52.0 | Windows 10 | Verenigd Koninkrijk |
2016-08-25 09:12:51.6930000 | Chrome 52.0 | Windows 7 | Nederland |
2016-08-25 09:12:56.4240000 | Chrome 52.0 | Windows 10 | Verenigd Koninkrijk |
2016-08-25 09:13:08.7230000 | Chrome 52.0 | Windows 10 | India |
Omdat er geen metrische gegevens zijn, kunnen we alleen een set tijdreeksen maken die het aantal verkeer zelf vertegenwoordigen, gepartitioneerd per besturingssysteem met behulp van de volgende query:
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
- Gebruik de
make-series
operator om een set van drie tijdreeksen te maken, waarbij:num=count()
: tijdreeks van verkeerfrom min_t to max_t step 1h
: tijdreeksen worden gemaakt in bins van 1 uur in het tijdsbereik (oudste en nieuwste tijdstempels van tabelrecords)default=0
: geef de vulmethode op voor ontbrekende bins om een normale tijdreeks te maken. U kunt ook ,series_fill_forward()
series_fill_backward()
enseries_fill_linear()
gebruikenseries_fill_const()
voor wijzigingenby OsVer
: partitioneren op besturingssysteem
- De werkelijke tijdreeksgegevensstructuur is een numerieke matrix van de geaggregeerde waarde per tijdslocatie. We gebruiken
render timechart
voor visualisatie.
In de bovenstaande tabel hebben we drie partities. We kunnen een afzonderlijke tijdreeks maken: Windows 10 (rood), 7 (blauw) en 8.1 (groen) voor elke versie van het besturingssysteem, zoals te zien is in de grafiek:
Functies voor tijdreeksanalyse
In deze sectie voeren we typische reeksverwerkingsfuncties uit. Zodra een set tijdreeksen is gemaakt, ondersteunt KQL een groeiende lijst met functies om deze te verwerken en te analyseren. We beschrijven enkele representatieve functies voor het verwerken en analyseren van tijdreeksen.
Filteren
Filteren is een gangbare praktijk bij signaalverwerking en handig voor taken voor het verwerken van tijdreeksen (bijvoorbeeld een ruissignaal vloeiend maken, wijzigingsdetectie).
- Er zijn twee algemene filterfuncties:
series_fir()
: FIR-filter toepassen. Wordt gebruikt voor eenvoudige berekening van voortschrijdend gemiddelde en differentiatie van de tijdreeks voor wijzigingsdetectie.series_iir()
: IIR-filter toepassen. Wordt gebruikt voor exponentiële afvlakking en cumulatieve som.
Extend
de tijdreeks die wordt ingesteld door een nieuwe reeks met zwevend gemiddelde van grootte 5 bins ( met de naam ma_num) toe te voegen aan de query:
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
Regressieanalyse
Azure Data Explorer ondersteunt gesegmenteerde lineaire regressieanalyse om de trend van de tijdreeks te schatten.
- Gebruik series_fit_line() om de beste lijn aan te passen aan een tijdreeks voor algemene trenddetectie.
- Gebruik series_fit_2lines() om trendwijzigingen ten opzichte van de basislijn te detecteren die nuttig zijn in bewakingsscenario's.
Voorbeeld van functies en series_fit_line()
series_fit_2lines()
in een tijdreeksquery:
demo_series2
| extend series_fit_2lines(y), series_fit_line(y)
| render linechart with(xcolumn=x)
- Blauw: oorspronkelijke tijdreeks
- Groen: aangepaste lijn
- Rood: twee aangepaste lijnen
Notitie
De functie heeft het sprongpunt (niveauwijziging) nauwkeurig gedetecteerd.
Seizoensgebondenheidsdetectie
Veel metrische gegevens volgen seizoensgebonden (periodieke) patronen. Gebruikersverkeer van cloudservices bevat meestal dagelijkse en wekelijkse patronen die het hoogst zijn rond het midden van de werkdag en het laagst 's nachts en in het weekend. IoT-sensoren meten periodiek. Fysieke metingen, zoals temperatuur, druk of vochtigheid, kunnen ook seizoensgebonden gedrag vertonen.
In het volgende voorbeeld wordt seizoensgebondenheidsdetectie toegepast op verkeer van één maand van een webservice (opslaglocaties van 2 uur):
demo_series3
| render timechart
- Gebruik series_periods_detect() om de perioden in de tijdreeks automatisch te detecteren.
- Gebruik series_periods_validate() als we weten dat een metrische waarde specifieke afzonderlijke perioden moet hebben en we willen controleren of deze bestaan.
Notitie
Het is een anomalie als er geen specifieke afzonderlijke perioden bestaan
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
Perioden | Scores | Dagen |
---|---|---|
84 | 0.820622786055595 | 7 |
12 | 0.764601405803502 | 1 |
De functie detecteert dagelijkse en wekelijkse seizoensgebondenheid. De dagelijkse scores zijn lager dan de wekelijkse, omdat weekenddagen anders zijn dan weekdagen.
Functies op het punt van elementen
Rekenkundige en logische bewerkingen kunnen worden uitgevoerd op een tijdreeks. Met behulp van series_subtract() kunnen we een resterende tijdreeks berekenen, dat wil weten het verschil tussen de oorspronkelijke onbewerkte metrische gegevens en een afgevlakt metrische waarde, en zoeken naar afwijkingen in het restsignaal:
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 in 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
- Blauw: oorspronkelijke tijdreeks
- Rood: vloeiende tijdreeks
- Groen: resterende tijdreeks
Tijdreekswerkstroom op schaal
In het onderstaande voorbeeld ziet u hoe deze functies op schaal kunnen worden uitgevoerd op duizenden tijdreeksen in seconden voor anomaliedetectie. Voer de volgende query uit om een paar voorbeeldtelemetrierecords van het metrische aantal leesbewerkingen van een DB-service gedurende vier dagen weer te geven:
demo_many_series1
| take 4
TIMESTAMP | Loc | Op | DB | DataRead |
---|---|---|---|---|
2016-09-11 21:00:00.0000000 | Loc 9 | 5117853934049630089 | 262 | 0 |
2016-09-11 21:00:00.0000000 | Loc 9 | 5117853934049630089 | 241 | 0 |
2016-09-11 21:00:00.0000000 | Loc 9 | -865998331941149874 | 262 | 279862 |
2016-09-11 21:00:00.0000000 | Loc 9 | 371921734563783410 | 255 | 0 |
En eenvoudige statistieken:
demo_many_series1
| summarize num=count(), min_t=min(TIMESTAMP), max_t=max(TIMESTAMP)
num | min_t | max_t |
---|---|---|
2177472 | 2016-09-08 00:00:00.0000000 | 2016-09-11 23:00:00.0000000 |
Het bouwen van een tijdreeks in bins van 1 uur van de leeswaarde (totaal vier dagen * 24 uur = 96 punten), resulteert in normale patroonschommelingen:
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)
Het bovenstaande gedrag is misleidend, omdat de enkele normale tijdreeks wordt geaggregeerd uit duizenden verschillende exemplaren die mogelijk abnormale patronen hebben. Daarom maken we een tijdreeks per exemplaar. Een exemplaar wordt gedefinieerd door Loc (locatie), Op (bewerking) en DB (specifieke computer).
Hoeveel tijdreeksen kunnen we maken?
demo_many_series1
| summarize by Loc, Op, DB
| count
Count |
---|
18339 |
We gaan nu een set van 18339 tijdreeksen maken van de metrische waarde voor het aantal leesbewerkingen. We voegen de by
component toe aan de instructie make-series, passen lineaire regressie toe en selecteren de bovenste twee tijdreeksen met de belangrijkste dalende trend:
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)')
De exemplaren weergeven:
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
Loc | Op | DB | Helling |
---|---|---|---|
Loc 15 | 37 | 1151 | -102743.910227889 |
Loc 13 | 37 | 1249 | -86303.2334644601 |
In minder dan twee minuten werden bijna 20.000 tijdreeksen geanalyseerd en twee abnormale tijdreeksen waarin het aantal leesbewerkingen plotseling daalden gedetecteerd.
Deze geavanceerde mogelijkheden in combinatie met snelle prestaties leveren een unieke en krachtige oplossing voor tijdreeksanalyse.
Gerelateerde inhoud
- Meer informatie over anomaliedetectie en -prognoses met KQL.
- Meer informatie over machine learning-mogelijkheden met KQL.
Feedback
https://aka.ms/ContentUserFeedback.
Binnenkort beschikbaar: In de loop van 2024 zullen we GitHub-problemen geleidelijk uitfaseren als het feedbackmechanisme voor inhoud en deze vervangen door een nieuw feedbacksysteem. Zie voor meer informatie:Feedback verzenden en weergeven voor