Analisi delle serie temporali

Selezionare un servizio dall'elenco a discesa a sinistra.
Si applica a: ✅ Microsoft Fabric ✅ Esplora dati di Azure ✅ Azure Monitor ✅ Microsoft Sentinel

I servizi cloud e i dispositivi IoT generano dati di telemetria che è possibile usare per ottenere informazioni dettagliate sull'integrità dei servizi, sui processi di produzione e sulle tendenze di utilizzo. L'analisi delle serie temporali consente di identificare le deviazioni dai modelli di base tipici.

Il linguaggio di query Kusto (KQL) offre supporto nativo per la creazione, la modifica e l'analisi di più serie temporali. Questo articolo illustra come usare KQL per creare e analizzare migliaia di serie temporali in pochi secondi per abilitare soluzioni e flussi di lavoro di monitoraggio quasi in tempo reale.

Creazione di serie temporali

Creare un ampio set di serie temporali regolari utilizzando l'operatore make-series e riempire i valori mancanti secondo necessità. Partizionare e trasformare la tabella di telemetria in un set di serie temporali. La tabella contiene in genere una colonna timestamp, dimensioni contestuali e metriche facoltative. Le dimensioni vengono utilizzate per partizionare i dati. L'obiettivo è creare migliaia di serie temporali per partizione a intervalli di tempo regolari.

La tabella di input demo_make_series1 contiene 600.000 record di traffico arbitrario del servizio Web. Usare il comando seguente per campionare 10 record:

demo_make_series1 | take 10 

La tabella risultante contiene una colonna timestamp, tre colonne delle dimensioni contestuali e nessuna metrica:

Dal momento che non ci sono metriche, costruisci serie temporali che rappresentano il conteggio del traffico, suddivise per sistema operativo.

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 

• Usare l'operatore make-series per creare tre serie temporali, dove:
  • num=count(): numero di traffico.
  • from min_t to max_t step 1h: crea la serie temporale in intervalli di un'ora dal timestamp più vecchio al più recente della tabella.
  • default=0: specifica il metodo di riempimento per i bin mancanti per creare una serie temporale che sia regolare. In alternativa, usare series_fill_const(), series_fill_forward(), series_fill_backward()e series_fill_linear() per un comportamento di riempimento diverso.
  • by OsVer: partizioni per sistema operativo.
• La struttura dei dati delle serie temporali è una matrice numerica di valori aggregati per ogni contenitore temporale. Usare render timechart per la visualizzazione.

La tabella precedente include tre partizioni (Windows 10, Windows 7 e Windows 8.1). Il grafico mostra una serie temporale separata per ogni versione del sistema operativo:

Screenshot di un grafico di serie temporali con linee separate per Windows 10, Windows 7 e Windows 8.1.

Funzioni di analisi delle serie temporali

In questa sezione verranno eseguite funzioni tipiche di elaborazione delle serie. Dopo aver creato un set di serie temporali, KQL supporta un elenco crescente di funzioni da elaborare e analizzare. Verranno descritte alcune funzioni rappresentative per l'elaborazione e l'analisi delle serie temporali.

Filtraggio

Il filtro è una pratica comune nell'elaborazione dei segnali e utile per le attività di elaborazione delle serie temporali (ad esempio, uniformare un segnale rumoroso, rilevamento delle modifiche).

• Esistono due funzioni di filtro generiche:
  • series_fir(): applicazione del filtro FIR. Usato per un semplice calcolo della media mobile e della differenziazione della serie temporale per il rilevamento delle modifiche.
  • series_iir(): applicazione del filtro IIR. Usato per il livellamento esponenziale e la somma cumulativa.
• Extend la serie temporale impostata aggiungendo una nuova serie di media mobile con una dimensione di 5 bin (denominata ma_num) alla 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

Analisi della regressione

È possibile usare un'analisi di regressione lineare segmentata per stimare la tendenza della serie temporale.

• Usare series_fit_line() per adattare la linea migliore a una serie temporale per il rilevamento generale delle tendenze.
• Usare series_fit_2lines() per rilevare le variazioni di tendenza rispetto alla baseline, utili negli scenari di monitoraggio.

Esempio delle funzioni series_fit_line() e series_fit_2lines() in una query di serie temporali:

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

• Blu: serie temporale originale
• Verde: linea adattata
• Rosso: due linee montate

Rilevamento della stagionalità

Molte metriche seguono modelli stagionali (periodici). Il traffico degli utenti dei servizi cloud in genere contiene modelli giornalieri e settimanali che sono più alti intorno alla metà del giorno lavorativo e al minimo di notte e nel fine settimana. I sensori IoT misurano a intervalli periodici. Le misurazioni fisiche, ad esempio temperatura, pressione o umidità, possono anche mostrare un comportamento stagionale.

L'esempio seguente applica il rilevamento della stagionalità sul traffico di un servizio web per un mese (intervalli di 2 ore):

demo_series3
| render timechart 

• Usare series_periods_detect() per rilevare automaticamente i periodi della serie temporale, dove:
  • num: serie temporale da analizzare
  • 0.: la lunghezza minima del periodo in giorni (0 indica che non è minimo)
  • 14d/2h: la lunghezza massima del periodo in giorni, ovvero 14 giorni divisi in contenitori di 2 ore
  • 2: numero di periodi da rilevare
• Usare series_periods_validate() se si sa che una metrica deve avere periodi distinti specifici e si vuole verificare che esistano.

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 funzione rileva la stagionalità giornaliera e settimanale. Il punteggio giornaliero è inferiore a quello settimanale perché i giorni del fine settimana sono diversi dai giorni feriali.

Funzioni a livello di elemento

Le operazioni aritmetiche e logiche possono essere eseguite su una serie temporale. Usando series_subtract() è possibile calcolare una serie temporale residua, ovvero la differenza tra la metrica non elaborata originale e quella smussata e cercare anomalie nel segnale residuo:

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

• Blu: serie temporale originale
• Rosso: serie temporale smussata
• Verde: serie temporale residua

Flusso di lavoro di serie temporali su larga scala

Questo esempio mostra il rilevamento delle anomalie in esecuzione su larga scala su migliaia di serie temporali in pochi secondi. Per visualizzare i record di telemetria di esempio per una metrica di conteggio delle letture del servizio di database in quattro giorni, eseguire la query seguente:

demo_many_series1
| take 4 

Visualizzare statistiche semplici:

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

Una serie temporale a intervalli di 1 ora della metrica di lettura (quattro giorni × 24 ore = 96 punti) mostra una fluttuazione oraria 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) 

Questo comportamento è fuorviante perché la singola serie temporale normale viene aggregata da migliaia di istanze che possono avere modelli anomali. Creare una serie temporale per ogni istanza definita da Loc (posizione), Op (operazione) e DB (computer specifico).

Quante serie temporali è possibile creare?

demo_many_series1
| summarize by Loc, Op, DB
| count

Creare 18,339 serie temporali per la metrica del conteggio di lettura. Aggiungere la by clausola all'istruzione make-series, applicare la regressione lineare e selezionare le prime due serie temporali con la tendenza decrescente più significativa:

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)')

Visualizza le istanze

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 

In meno di due minuti, la query analizza quasi 20.000 serie temporali e rileva due con un calo improvviso del numero di letture.

Queste funzionalità e le prestazioni della piattaforma offrono una soluzione efficace per l'analisi delle serie temporali.

Contenuti correlati

• Rilevamento e previsione anomalie con KQL.
• Funzionalità di Machine Learning con KQL.