Análise de série temporal

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

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

A KQL (Linguagem de Consulta Kusto) 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 quase em tempo real e fluxos de trabalho.

Criação de série temporal

Nesta seção, criaremos um grande conjunto de séries temporais regulares de forma simples e intuitiva usando o make-series operador e preencheremos valores ausentes conforme necessário. A primeira etapa na análise de série temporal é 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. A meta é 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 do serviço Web. Use o seguinte comando para amostrar 10 registros:

demo_make_series1 | take 10 

A tabela resultante contém uma coluna de timestamp, três colunas de dimensões contextuais e nenhuma métrica.

Como não há métricas, só podemos criar um conjunto de séries temporais que representam a própria contagem de tráfego, 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, em que:
  • num=count(): série temporal de tráfego
  • from min_t to max_t step 1h: a série temporal é criada em intervalos de 1 hora dentro do intervalo de tempo (carimbos de data/hora mais antigos e mais recentes dos registros de tabela)
  • default=0: especifique o método de preenchimento para compartimentos ausentes para criar séries temporais regulares. Como alternativa, use series_fill_const()e series_fill_forward()series_fill_backward()series_fill_linear() para alterações
  • by OsVer: partição por sistema operacional
• A estrutura de dados de 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 grafo:

Funções de análise de série temporal

Nesta seção, executaremos funções típicas de processamento de série. Depois que um conjunto de séries temporais é criado, o KQL dá suporte a 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érie temporal (por exemplo, suavizar um sinal barulhento, detecção de alterações).

• Há duas funções de filtragem genéricas:
  • series_fir(): aplicando o filtro FIR. Usado para cálculo simples de média móvel e diferenciação da série temporal para detecção de alterações.
  • series_iir(): aplicando o filtro IIR. Usado para a suavização exponencial e a soma cumulativa.
• Extend a série temporal definida adicionando uma nova série média móvel de tamanho 5 bins (denominada 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érie temporal.

Análise de regressão

Uma análise de regressão linear segmentada pode ser usada para estimar a tendência da série temporal.

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

Exemplo das funções series_fit_line() e series_fit_2lines() 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 encaixadas

Detecção de sazonalidade

Muitas métricas seguem padrões sazonais (periódicos). O tráfego de usuários de serviços de nuvem geralmente contém padrões diários e semanais que são mais altos no meio do dia comercial e mais baixos à noite e no fim de semana. Os sensores de 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 detecção de sazonalidade ao tráfego de um serviço Web durante um mês (intervalos de 2 horas):

demo_series3
| render timechart 

• Use series_periods_detect() para detectar automaticamente os períodos na série temporal, em que:
  • num: a série temporal a ser analisada
  • 0.: o comprimento mínimo do período em dias (0 significa que não há mínimo)
  • 14d/2h: o comprimento máximo do período em dias, que é de 14 dias dividido em intervalos de 2 horas
  • 2: o número de períodos a serem detectados
• Use series_periods_validate() se soubermos que uma métrica deve ter períodos distintos específicos e queremos verificar se elas 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 detecta sazonalidade diária e semanal. As pontuações diárias são menores do que a semanal porque os dias de fim de semana são diferentes dos dias da semana.

Funções em termos de 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érie temporal suavizada
• Verde: séries temporais residuais

Fluxo de trabalho de séries temporais em escala

O exemplo a seguir mostra como essas funções podem ser executadas em escala em milhares de séries temporais em segundos para detecção de anomalias. Para ver alguns registros de telemetria de exemplo da métrica de contagem de leitura de um serviço de banco de dados ao longo de 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 uma série temporal em intervalos de 1 hora da métrica de leitura (total de quatro dias * 24 horas = 96 pontos) resulta em 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, pois a única série temporal normal é agregada de milhares de instâncias diferentes que podem ter padrões anormais. Portanto, criamos uma série temporal para cada instância. Uma instância é definida por Loc (local), Op (operação) e BD (computador específico).

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 leitura. 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 leituras caiu repentinamente foram detectadas.

Esses recursos avançados combinados com o desempenho rápido fornecem uma solução exclusiva e poderosa para análise de série temporal.

Conteúdo relacionado

• Saiba mais sobre a detecção e a previsão de anomalias com o KQL.
• Saiba mais sobre os recursos de machine learning com KQL.