Análisis de series temporales en Azure Data Explorer

Azure Data Explorer realiza la recopilación continua de datos de telemetría desde dispositivos en la nube o dispositivos de IoT. Estos datos se pueden analizar para obtener diversa información, como la supervisión del estado de los servicios, los procesos físicos de producción y las tendencias de utilización. El análisis se realiza en series temporales de métricas seleccionadas para encontrar una desviación en el patrón comparado con su patrón típico de línea de base. Azure Data Explorer contiene compatibilidad nativa para la creación, manipulación y análisis de varias series temporales. En este tema, aprenderá cómo se usa Azure Data Explorer para crear y analizar miles de series temporales en segundos, lo que permite flujos de trabajo y soluciones de supervisión casi en tiempo real.

Creación de series temporales

En esta sección, vamos a crear un gran conjunto de series temporales regulares de forma sencilla e intuitiva mediante el operador make-series y vamos a rellenar los valores que faltan según sea necesario. El primer paso en el análisis de series temporales es dividir y transformar la tabla de telemetría original en un conjunto de series temporales. La tabla generalmente contiene una columna de marca de tiempo, dimensiones contextuales y métricas opcionales. Las dimensiones se usan para particionar los datos. El objetivo es crear miles de series temporales por partición a intervalos de tiempo regulares.

La tabla de entrada demo_make_series1 contiene registros de 600 K de tráfico del servicio web arbitrario. Utilice el siguiente comando para muestrear 10 registros:

[ Hagaclic para ejecutar la consulta]

demo_make_series1 | take 10 

La tabla resultante contiene una columna de marca de tiempo, tres columnas de dimensiones contextuales y ninguna métrica:

Dado que no hay métricas, solo podemos crear un conjunto de series temporales que representen el mismo recuento de tráfico, particionado por el sistema operativo mediante la siguiente consulta:

[ Hagaclic para ejecutar la 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 in range(min_t, max_t, 1h) by OsVer
| render timechart 

• Utilice el operador make-series para crear un conjunto de tres series temporales, donde:
  • num=count(): serie temporal de tráfico
  • range(min_t, max_t, 1h): la serie temporal se crea en intervalos de 1 hora en el intervalo de tiempo (marcas de tiempo más recientes y más antiguas de los registros de la tabla)
  • default=0: especifique el método de relleno para los intervalos que faltan para crear series temporales regulares. También puede usar series_fill_const() , y para los series_fill_forward()series_fill_backward()series_fill_linear() cambios.
  • byOsVer: partición por sistema operativo
• La estructura de datos de series temporales reales es una matriz numérica del valor agregado por cada intervalo temporal. Usamos render timechart para la visualización.

En la tabla anterior, tenemos tres particiones. Podemos crear una serie temporal independiente: Windows 10 (rojo), 7 (azul) y 8.1 (verde) para cada versión de sistema operativo, tal y como se muestra en el gráfico:

Funciones de análisis de series temporales

En esta sección, realizaremos las funciones típicas de procesamiento en serie. Cuando se ha creado un conjunto de series temporales, Azure Data Explorer admite una lista creciente de funciones para procesar y analizarlas que se encuentran en la documentación de series temporales. Describiremos algunas funciones representativas para el procesamiento y análisis de series temporales.

Filtrado

El filtrado es una práctica común en el procesamiento de señales y muy útil para tareas de procesamiento de series temporales (por ejemplo, suavizar una señal con ruido o detectar cambios).

• Hay dos funciones de filtrado genéricas:
  • series_fir(): Aplicación de filtro FIR. Se utiliza para el cálculo simple de la media acumulada y la diferenciación de las series temporales para la detección de cambios.
  • series_iir(): Aplicación de filtro IIR. Se utiliza para el suavizado exponencial y la suma acumulativa.
• Extend la serie temporal establecida agregando una nueva serie de media móvil de tamaño 5 cubos (denominada Extend) a la consulta:

[ Hagaclic para ejecutar la 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 in range(min_t, max_t, 1h) by OsVer
| extend ma_num=series_fir(num, repeat(1, 5), true, true)
| render timechart

Análisis de regresión

Azure Data Explorer admite el análisis de regresión lineal segmentado para calcular la tendencia de la serie temporal.

• Utilice series_fit_line() para ajustar la mejor línea a una serie temporal para la detección general de tendencias.
• Utilice series_fit_2lines() para detectar cambios de tendencia, en relación con la línea de base, que sean útiles en los escenarios de supervisión.

Ejemplo de series_fit_line() funciones y en una consulta de serie series_fit_2lines() temporal:

[ Hagaclic para ejecutar la consulta]

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

• Azul: serie temporal original
• Verde: línea ajustada
• Rojo: dos líneas ajustadas

Detección de estacionalidad

Muchas métricas siguen los patrones estacionales (periódicos). El tráfico de usuarios de los servicios en la nube suele contener patrones diarios y semanales que son más altos en la mitad del día laborable y más bajos por la noche y durante el fin de semana. Medida de sensores de IoT en intervalos periódicos. Las medidas físicas, como temperatura, presión y humedad también pueden mostrar el comportamiento estacional.

En el ejemplo siguiente se aplica la detección de estacionalidad en el tráfico de un mes de un servicio web (intervalos de 2 horas):

[ Hagaclic para ejecutar la consulta]

demo_series3
| render timechart 

• Utilice series_periods_detect() para detectar automáticamente los períodos de la serie temporal.
• Utilice series_periods_validate() si sabemos que una métrica debe tener uno o varios períodos distintos específicos y queremos comprobar su existencia.

[ Hagaclic para ejecutar la consulta]

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 función detecta la estacionalidad diaria y semanal. La puntuación diaria es menor que la semanal porque los días de fin de semana son diferentes de los días de la semana.

Funciones por elemento

Las operaciones aritméticas y lógicas pueden realizarse en una serie temporal. Con series_subtract() podemos calcular una serie temporal residual, es decir, la diferencia entre la métrica sin procesar original y una suavizada, y buscar anomalías en la señal residual:

[ Hagaclic para ejecutar la 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 in range(min_t, max_t, 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: serie temporal original
• Rojo: series temporales suavizadas
• Verde: series temporales residuales

Flujo de trabajo de series temporales a escala

En el siguiente ejemplo se muestra cómo estas funciones pueden ejecutarse a escala en miles de series temporales en segundos para la detección de anomalías. Para ver algunos registros de telemetría de ejemplo de una métrica de recuento de lecturas de un servicio de base de datos durante cuatro días, ejecute la siguiente consulta:

[ Hagaclic para ejecutar la consulta]

demo_many_series1
| take 4 

Y estadísticas sencillas:

[ Hagaclic para ejecutar la consulta]

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

La creación de una serie temporal en intervalos de 1 hora de la métrica de lectura (total de cuatro días * 24 horas = 96 puntos) da como resultado una fluctuación normal del patrón:

[ Hagaclic para ejecutar la consulta]

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 in range(min_t, max_t, 1h)
| render timechart with(ymin=0) 

El comportamiento anterior es engañoso, ya que la única serie temporal normal se agrega a partir de miles de instancias diferentes que pueden tener patrones anormales. Por lo tanto, creamos una serie temporal por instancia. Una instancia se define por Loc (ubicación), anonOp (operación) y DB (máquina específica).

¿Cuántas series temporales podemos crear?

[ Hagaclic para ejecutar la consulta]

demo_many_series1
| summarize by Loc, Op, DB
| count

Ahora, vamos a crear un conjunto de 18339 series temporales de la métrica de recuento de lecturas. Agregamos la cláusula by a la instrucción make-series, aplicamos la regresión lineal y seleccionamos las dos primeras series temporales que tuvieron la tendencia decreciente más significativa:

[ Hagaclic para ejecutar la consulta]

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 in range(min_t, max_t, 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)')

Mostrar las instancias:

[ Hagaclic para ejecutar la consulta]

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 in range(min_t, max_t, 1h) by Loc, Op, DB
| extend (rsquare, slope) = series_fit_line(reads)
| top 2 by slope asc
| project Loc, Op, DB, slope 

En menos de dos minutos, Azure Data Explorer analizó aproximadamente 20 000 series temporales y detectó dos series temporales anormales en las que el recuento de lecturas bajó repentinamente.

Estas funcionalidades avanzadas, combinadas con el rápido rendimiento de Azure Data Explorer, proporcionan una solución única y eficaz para el análisis de series temporales.

Pasos siguientes

• Obtenga información sobre la detección y previsión de anomalías de series temporales en Azure Data Explorer.
• Obtenga información sobre las capacidades de aprendizaje automático en Azure Data Explorer.