Análisis de series temporales
Los servicios en la nube y los dispositivos IoT generan datos de telemetría que se pueden usar para obtener información, como supervisar el estado del servicio, los procesos de producción físicos y las tendencias de uso. Realizar análisis de series temporales es una manera de identificar las desviaciones en el patrón de estas métricas en comparación con su patrón de línea de base típico.
Lenguaje de consulta Kusto (KQL) contiene compatibilidad nativa para la creación, manipulación y análisis de varias series temporales. En este artículo, aprenderá cómo se usa KQL para crear y analizar miles de series temporales en segundos, lo que permite soluciones y flujos de trabajo 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. 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 dimensiones contextuales y ninguna métrica:
TimeStamp | BrowserVer | OsVer | País/región |
---|---|---|---|
2016-08-25 09:12:35.4020000 | Chrome 51.0 | Windows 7 | Reino Unido |
2016-08-25 09:12:41.1120000 | Chrome 52.0 | Windows 10 | |
2016-08-25 09:12:46.2300000 | Chrome 52.0 | Windows 7 | Reino Unido |
2016-08-25 09:12:46.5100000 | Chrome 52.0 | Windows 10 | Reino Unido |
2016-08-25 09:12:46.5570000 | Chrome 52.0 | Windows 10 | República de Lituania |
2016-08-25 09:12:47.0470000 | Chrome 52.0 | Windows 8.1 | India |
2016-08-25 09:12:51.3600000 | Chrome 52.0 | Windows 10 | Reino Unido |
2016-08-25 09:12:51.6930000 | Chrome 52.0 | Windows 7 | Países Bajos |
2016-08-25 09:12:56.4240000 | Chrome 52.0 | Windows 10 | Reino Unido |
2016-08-25 09:13:08.7230000 | Chrome 52.0 | Windows 10 | India |
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:
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
- Utilice el operador
make-series
para crear un conjunto de tres series temporales, donde:num=count()
: serie temporal de tráficofrom min_t to max_t step 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. O bien useseries_fill_const()
,series_fill_forward()
,series_fill_backward()
yseries_fill_linear()
para los cambios.by OsVer
: 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. Una vez creado un conjunto de series temporales, KQL admite una creciente lista de funciones para procesarlas y analizarlas. Describiremos algunas funciones representativas para procesar y analizar 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 mediante la adición de una nueva serie de media acumulada de intervalos de tamaño 5 (denominada 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
Azure Data Explorer admite el análisis de regresión lineal segmentada 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 las 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
Nota
La función ha detectado con precisión el punto de salto (cambio de nivel).
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):
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.
Nota
Es una anomalía si no existen períodos específicos distintos.
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
periods | scores | days |
---|---|---|
84 | 0.820622786055595 | 7 |
12 | 0.764601405803502 | 1 |
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:
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 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: 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:
demo_many_series1
| take 4
timestamp | Loc | Op | DB | DataRead |
---|---|---|---|---|
2016-09-11 21:00:00.0000000 | Loc 9 | 5117853934049630089 | 262 | 0 |
2016-09-11 21:00:00.0000000 | Loc 9 | 5117853934049630089 | 241 | 0 |
2016-09-11 21:00:00.0000000 | Loc 9 | -865998331941149874 | 262 | 279862 |
2016-09-11 21:00:00.0000000 | Loc 9 | 371921734563783410 | 255 | 0 |
Y estadísticas sencillas:
demo_many_series1
| summarize num=count(), min_t=min(TIMESTAMP), max_t=max(TIMESTAMP)
num | min_t | max_t |
---|---|---|
2177472 | 2016-09-08 00:00:00.0000000 | 2016-09-11 23:00:00.0000000 |
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:
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)
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 mediante Loc (ubicación), Op (operación) y DB (máquina específica).
¿Cuántas series temporales podemos crear?
demo_many_series1
| summarize by Loc, Op, DB
| count
Count |
---|
18339 |
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:
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
Loc | Op | DB | slope |
---|---|---|---|
Loc 15 | 37 | 1151 | -102743.910227889 |
Loc 13 | 37 | 1249 | -86303.2334644601 |
En menos de dos minutos, cerca de 20 000 series temporales se analizaron y se detectaron dos series temporales anómalas en las que se detectó repentinamente el recuento de lecturas.
Estas funcionalidades avanzadas combinadas con un rendimiento rápido proporcionan una solución única y eficaz para el análisis de series temporales.
Contenido relacionado
- Obtenga información sobre la detección y previsión de anomalías con KQL.
- Obtenga información sobre las funcionalidades de Aprendizaje automático con KQL.
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta:Enviar y ver comentarios de