Análisis de series temporales

Cambie los servicios mediante la lista desplegable Versión . Más información sobre la navegación.
Se aplica a: ✅ Microsoft Fabric ✅ Azure Data Explorer ✅ Azure Monitor ✅ Microsoft Sentinel

Los servicios en la nube y los dispositivos IoT generan telemetría que puede usar para obtener información sobre el estado del servicio, los procesos de producción y las tendencias de uso. El análisis de series temporales le ayuda a identificar las desviaciones de los patrones típicos de línea base.

Kusto Query Language (KQL) tiene compatibilidad nativa para crear, manipular y analizar varias series temporales. En este artículo se muestra cómo usar KQL para crear y analizar miles de series temporales en segundos para habilitar soluciones y flujos de trabajo de supervisión casi en tiempo real.

Creación de series temporales

Cree un gran conjunto de series temporales regulares mediante el make-series operador y rellene los valores que faltan según sea necesario. Cree particiones y transforme la tabla de telemetría en un conjunto de series temporales. La tabla normalmente 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 600 000 registros de tráfico arbitrario de servicio web. Use el siguiente comando para muestrear 10 registros:

demo_make_series1 | take 10 

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

Dado que no hay métricas, construya series temporales que representen el conteo de tráfico, particionadas por 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 

• Use el make-series operador para crear tres series temporales, donde:
  • num=count(): recuento de tráfico.
  • from min_t to max_t step 1h: crea la serie temporal en intervalos de una hora desde la marca de tiempo más antigua a la más reciente de la tabla.
  • default=0: especifica el método de relleno de los contenedores que faltan para crear series temporales normales. Como alternativa, use series_fill_const(), series_fill_forward(), series_fill_backward()y series_fill_linear() para un comportamiento de relleno diferente.
  • by OsVer: particiones por sistema operativo.
• La estructura de datos de serie temporal es una matriz numérica de valores agregados para cada intervalo de tiempo. Se usa render timechart para la visualización.

La tabla anterior tiene tres particiones (Windows 10, Windows 7 y Windows 8.1). El gráfico muestra una serie temporal independiente para cada versión del sistema operativo:

Funciones de análisis de series temporales

En esta sección, realizaremos funciones de procesamiento de series típicas. Una vez creado un conjunto de series temporales, KQL admite una lista creciente de funciones para procesarlas y analizarlas. Describiremos algunas funciones representativas para procesar y analizar series temporales.

Filtros

El filtrado es una práctica común en el procesamiento de señales y resulta útil para las tareas de procesamiento de series temporales (por ejemplo, suavizar una señal ruidosa, detección de cambios).

• Hay dos funciones de filtrado genéricas:
  • series_fir(): aplicación del filtro FIR. Se usa para el cálculo sencillo de la media móvil y la diferenciación de la serie temporal para la detección de cambios.
  • series_iir(): aplicación del filtro IIR. Se utiliza para el suavizado exponencial y la suma acumulativa.
• Extend el conjunto de series temporales agregando una nueva serie media móvil de tamaño 5 cubos ( denominados ma_num) a 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 from min_t to max_t step 1h by OsVer
| extend ma_num=series_fir(num, repeat(1, 5), true, true)
| render timechart

Análisis de regresión

Se puede usar un análisis de regresión lineal segmentado para calcular la tendencia de la serie temporal.

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

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

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 patrones estacionales (periódicos). El tráfico de usuarios de servicios en la nube normalmente contiene patrones diarios y semanales que son más altos alrededor del medio del día laborable y más bajo por la noche y durante el fin de semana. Los sensores de IoT miden en intervalos periódicos. Las medidas físicas, como la temperatura, la presión o la humedad, también pueden mostrar un comportamiento estacional.

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

demo_series3
| render timechart 

• Use series_periods_detect() para detectar automáticamente los períodos de la serie temporal, donde:
  • num: serie temporal que se va a analizar
  • 0.: la duración mínima del período en días (0 significa que no es mínimo)
  • 14d/2h: la duración máxima del período en días, que es de 14 días dividida en intervalos de 2 horas.
  • 2: el número de períodos a detectar.
• Use series_periods_validate() si sabemos que una métrica debe tener períodos distintos específicos y queremos comprobar que existen.

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 estacionalidad diaria y semanal. Las puntuaciones diarias son menores que las semanales porque los días de fin de semana son diferentes a los días laborables.

Funciones orientadas a elementos

Las operaciones aritméticas y lógicas se pueden realizar 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:

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: serie temporal original
• Rojo: serie temporal suavizada
• Verde: serie temporal residual

Flujo de trabajo de series temporales a escala

Este ejemplo muestra cómo la detección de anomalías se ejecuta a gran escala en miles de series temporales en cuestión de segundos. Para ver registros de telemetría de ejemplo para una métrica de conteo de lecturas del servicio de base de datos durante cuatro días, ejecute la siguiente consulta:

demo_many_series1
| take 4 

Ver estadísticas simples:

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

Una serie temporal en intervalos de 1 hora de la métrica de lectura (cuatro días × 24 horas = 96 puntos) muestra una fluctuación horaria normal:

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) 

Este comportamiento es engañoso porque la única serie temporal normal se agrega a partir de miles de instancias que pueden tener patrones anómalos. Cree una serie temporal por instancia definida por Loc (ubicación), Op (operación) y BASE de datos (máquina específica).

¿Cuántas series temporales se pueden crear?

demo_many_series1
| summarize by Loc, Op, DB
| count

Cree una serie temporal de 18 339 para la métrica de recuento de lecturas. Agregue la by cláusula a la instrucción make-series, aplique la regresión lineal y seleccione las dos series temporales principales con la tendencia de disminución más 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)')

Mostrar las instancias:

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 

En menos de dos minutos, la consulta analiza casi 20 000 series temporales y detecta dos con una caída repentina del recuento de lecturas.

Estas funcionalidades y el rendimiento de la plataforma proporcionan una solución eficaz para el análisis de series temporales.

Contenido relacionado

• Detección y previsión de anomalías con KQL.
• Funcionalidades de aprendizaje automático con KQL.