Análise de séries temporais

Aplica-se a: ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel

Serviços de nuvem e dispositivos IoT geram dados de telemetria que podem ser usados para obter informações, como monitoramento da integridade do serviço, processos de produção física e tendências de uso. Realizar a análise de séries temporais é uma maneira de identificar desvios no padrão dessas métricas em comparação com seu padrão típico de linha de base.

Kusto Query Language (KQL) contém suporte nativo para criação, manipulação e análise de várias séries temporais. Neste artigo, saiba como o KQL é usado para criar e analisar milhares de séries temporais em segundos, permitindo soluções de monitoramento e fluxos de trabalho quase em tempo real.

Criação de séries cronológicas

Nesta seção, criaremos um grande conjunto de séries temporais regulares de forma simples e intuitiva usando o make-series operador e preencheremos os valores ausentes conforme necessário. O primeiro passo na análise de séries temporais é particionar e transformar a tabela de telemetria original em um conjunto de séries temporais. A tabela geralmente contém uma coluna de marca temporal, dimensões contextuais e métricas opcionais. As dimensões são usadas para particionar os dados. O objetivo é criar milhares de séries temporais por partição em intervalos de tempo regulares.

A tabela de entrada demo_make_series1 contém 600 mil registros de tráfego arbitrário de serviço Web. Use o seguinte comando para obter um exemplo de 10 registros:

demo_make_series1 | take 10 

A tabela resultante contém uma coluna de data e hora, três colunas para dimensões contextuais e sem métricas.

Como não há métricas, só podemos construir um conjunto de séries temporais representando a contagem de tráfego em si, particionada pelo sistema operacional usando a seguinte consulta:

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 

• Use o make-series operador para criar um conjunto de três séries temporais, onde:
  • num=count(): séries cronológicas do tráfego
  • from min_t to max_t step 1h: séries temporais são criadas em intervalos de 1 hora na faixa de tempo (carimbos de data/hora mais antigos e mais recentes dos registos da tabela)
  • default=0: Especifique o método de preenchimento para compartimentos ausentes para criar séries temporais regulares. Alternativa use series_fill_const(), series_fill_forward(), series_fill_backward() e series_fill_linear() para alterações
  • by OsVer: partição por SO
• A estrutura de dados da série temporal real é uma matriz numérica do valor agregado por cada compartimento de tempo. Usamos render timechart para visualização.

Na tabela acima, temos três partições. Podemos criar uma série temporal separada: Windows 10 (vermelho), 7 (azul) e 8.1 (verde) para cada versão do sistema operacional, como visto no gráfico:

Funções de análise de séries temporais

Nesta seção, executaremos funções típicas de processamento em série. Uma vez que um conjunto de séries temporais é criado, o KQL suporta uma lista crescente de funções para processá-las e analisá-las. Descreveremos algumas funções representativas para processar e analisar séries temporais.

Filtragem

A filtragem é uma prática comum no processamento de sinais e útil para tarefas de processamento de séries temporais (por exemplo, suavizar um sinal ruidoso, deteção de alterações).

• Existem duas funções de filtragem genéricas:
  • series_fir(): Aplicação do filtro FIR. Usado para cálculo simples de média móvel e diferenciação da série temporal para deteção de alterações.
  • series_iir(): Aplicação do filtro IIR. Usado para suavização exponencial e soma cumulativa.
• Extend A série temporal definida adicionando uma nova série de média móvel de compartimentos de tamanho 5 (chamada ma_num) à consulta:

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

Filtragem de séries temporais.

Análise de regressão

Uma análise de regressão linear segmentada pode ser usada para estimar a tendência das séries temporais.

• Use series_fit_line() para ajustar a melhor linha a uma série temporal para deteção de tendências gerais.
• Use series_fit_2lines() para detetar alterações de tendência, em relação à linha de base, que são úteis em cenários de monitoramento.

Exemplo de series_fit_line() e series_fit_2lines() funções em uma consulta de série temporal:

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

• Azul: série temporal original
• Verde: linha ajustada
• Vermelho: duas linhas ajustadas

Deteção de sazonalidade

Muitas métricas seguem padrões sazonais (periódicos). O tráfego de usuários de serviços em nuvem geralmente contém padrões diários e semanais que são mais altos no meio do dia útil e mais baixos à noite e no fim de semana. Os sensores IoT medem em intervalos periódicos. Medidas físicas como temperatura, pressão ou umidade também podem mostrar comportamento sazonal.

O exemplo a seguir aplica a deteção de sazonalidade no tráfego de um mês de um serviço web (intervalos de 2 horas):

demo_series3
| render timechart 

• Use series_periods_detect() para detetar automaticamente os períodos nas séries temporais, onde:
  • num: as séries temporais a analisar
  • 0.: a duração mínima do período em dias (0 significa sem mínimo)
  • 14d/2h: a duração máxima do período em dias, que é de 14 dias divididos em intervalos de 2 horas
  • 2: o número de períodos a detectar
• Use series_periods_validate() se soubermos que uma métrica deve ter período(s) distinto(s) específico(s) e quisermos verificar se eles existem.

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

A função deteta sazonalidade diária e semanal. A pontuação diária é menor do que a semanal, porque os dias de fim de semana são diferentes dos dias da semana.

Funções elemento a elemento

Operações aritméticas e lógicas podem ser feitas em uma série temporal. Usando series_subtract() podemos calcular uma série temporal residual, ou seja, a diferença entre a métrica bruta original e uma suavizada, e procurar anomalias no sinal residual:

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

• Azul: série temporal original
• Vermelho: séries temporais suavizadas
• Verde: séries cronológicas residuais

Fluxo de trabalho de séries cronológicas em escala

O exemplo abaixo mostra como essas funções podem ser executadas em escala em milhares de séries temporais em segundos para deteção de anomalias. Para ver alguns exemplos de registros de telemetria da métrica de contagem de leitura de um serviço de banco de dados durante quatro dias, execute a seguinte consulta:

demo_many_series1
| take 4 

E estatísticas simples:

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

A construção de séries temporais em intervalos de 1 hora para a métrica de leitura (um total de quatro dias multiplicado por 24 horas, resultando em 96 pontos) resulta numa flutuação normal do padrão:

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) 

O comportamento acima é enganoso, uma vez que a única série temporal normal é agregada a partir de milhares de instâncias diferentes que podem ter padrões anormais. Portanto, criamos uma série temporal por instância. Uma instância é definida por Loc (local), Op (operação) e DB (máquina específica).

Quantas séries temporais podemos criar?

demo_many_series1
| summarize by Loc, Op, DB
| count

Agora, vamos criar um conjunto de 18339 séries temporais da métrica de contagem de leituras. Adicionamos a by cláusula à instrução make-series, aplicamos regressão linear e selecionamos as duas principais séries temporais que tiveram a tendência decrescente mais 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)')

Exiba as instâncias:

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 

Em menos de dois minutos, cerca de 20.000 séries temporais foram analisadas e duas séries temporais anormais em que a contagem de leitura caiu repentinamente foram detetadas.

Estas capacidades avançadas combinadas com um desempenho rápido fornecem uma solução única e poderosa para análise de séries cronológicas.

Conteúdo relacionado

• Saiba mais sobre a deteção e previsão de anomalias com o KQL.
• Saiba mais sobre os recursos de aprendizado de máquina com o KQL.