Merlion: Una librería de aprendizaje automático para series temporales

Tabla de contenidos

1. Introducción
2. Comparación con librerías relacionadas
3. Instalación
4. Documentación
5. Primeros pasos
   1. Detección de anomalías
   2. Pronóstico
6. Evaluación y benchmarking
7. Informe técnico y cómo citar Merlion

Introducción

Merlion es una librería de Python para inteligencia de series temporales. Proporciona un framework de aprendizaje automático de extremo a extremo que incluye carga y transformación de datos, construcción y entrenamiento de modelos, post-procesamiento de salidas de modelos y evaluación del rendimiento de los modelos. Admite diversas tareas de aprendizaje sobre series temporales, incluyendo pronóstico, detección de anomalías y detección de puntos de cambio, tanto para series temporales univariantes como multivariantes. Esta librería pretende ofrecer a ingenieros e investigadores una solución integral para desarrollar rápidamente modelos adaptados a sus necesidades específicas de series temporales, y evaluarlos en múltiples conjuntos de datos de series temporales.

Las características clave de Merlion son:

• Carga de datos y benchmarking estandarizados y fácilmente extensibles para una amplia gama de conjuntos de datos de pronóstico y detección de anomalías. Esto incluye soporte transparente para conjuntos de datos personalizados.
• Una librería de diversos modelos para detección de anomalías, pronóstico y detección de puntos de cambio, todos unificados bajo una interfaz compartida. Los modelos incluyen métodos estadísticos clásicos, ensembles de árboles y enfoques de aprendizaje profundo. Los usuarios avanzados pueden configurar completamente cada modelo según lo deseen.
• Modelos abstractos DefaultDetector y DefaultForecaster que son eficientes, logran robustamente un buen rendimiento y proporcionan un punto de partida para nuevos usuarios.
• AutoML para el ajuste automático de hiperparámetros y la selección de modelos.
• API unificada para usar una amplia gama de modelos para pronosticar con regresores exógenos.
• Reglas prácticas de post-procesamiento inspiradas en la industria para detectores de anomalías que hacen que las puntuaciones de anomalía sean más interpretables, al tiempo que reducen el número de falsos positivos.
• Ensembles fáciles de usar que combinan las salidas de múltiples modelos para lograr un rendimiento más robusto.
• Pipelines de evaluación flexibles que simulan el despliegue en vivo y el reentrenamiento de un modelo en producción, y evalúan el rendimiento tanto en pronóstico como en detección de anomalías.
• Soporte nativo para visualizar las predicciones de los modelos, incluyendo una interfaz visual clicable.
• Backend de cómputo distribuido mediante PySpark, que puede utilizarse para servir aplicaciones de series temporales a escala industrial.

Comparación con librerías relacionadas

La tabla siguiente ofrece una visión general de cómo las características clave de Merlion se comparan con otras librerías de detección de anomalías y/o pronóstico de series temporales.

Las siguientes características son nuevas en Merlion 2.0:

Instalación

Merlion consta de dos sub-repositorios: merlion implementa las características principales de inteligencia de series temporales de la librería, y ts_datasets proporciona cargadores de datos estandarizados para múltiples conjuntos de datos de series temporales. Estos cargadores cargan series temporales como pandas.DataFrame con metadatos adjuntos.

Puede instalar merlion desde PyPI ejecutando pip install salesforce-merlion. También puede instalar desde el código fuente clonando este repositorio y ejecutando pip install Merlion/, o pip install -e Merlion/ para instalarlo en modo editable. Puede instalar dependencias adicionales mediante pip install salesforce-merlion[all], o ejecutando pip install "Merlion/[all]" si instala desde el código fuente. Individualmente, las dependencias opcionales incluyen dashboard para un panel de control GUI, spark para un backend de cómputo distribuido con PySpark, y deep-learning para todos los modelos de aprendizaje profundo.

Para instalar el paquete de carga de datos ts_datasets, clone este repositorio y ejecute pip install -e Merlion/ts_datasets/. Este paquete debe instalarse en modo editable (es decir, con la bandera -e) si no desea especificar manualmente el directorio raíz de cada conjunto de datos al inicializar su cargador de datos.

Tenga en cuenta las siguientes dependencias externas:

1. Algunos de nuestros modelos de pronóstico dependen de OpenMP. Si usa conda, ejecute conda install -c conda-forge lightgbm antes de instalar nuestro paquete. Esto asegurará que OpenMP esté configurado para funcionar con el paquete lightgbm (una de nuestras dependencias) en su entorno conda. Si usa Mac, instale Homebrew y ejecute brew install libomp para que la librería OpenMP esté disponible para el modelo.

2. Algunos de nuestros modelos de detección de anomalías dependen del Java Development Kit (JDK). Para Ubuntu, ejecute sudo apt-get install openjdk-11-jdk. Para Mac OS, instale Homebrew y ejecute brew tap adoptopenjdk/openjdk && brew install --cask adoptopenjdk11. Asegúrese también de que java se pueda encontrar en su PATH y de que la variable de entorno JAVA_HOME esté definida.

Documentación

Para ver ejemplos de código y una introducción a Merlion, consulte los cuadernos de Jupyter en examples y el recorrido guiado aquí. Puede encontrar documentación detallada de la API (incluido el código de ejemplo) aquí. El informe técnico describe la arquitectura general de Merlion y presenta resultados experimentales sobre detección de anomalías y pronóstico de series temporales, tanto univariantes como multivariantes.

Primeros pasos

La forma más fácil de empezar es usar el panel de control web basado en GUI. Este panel ofrece una excelente manera de experimentar rápidamente con muchos modelos en sus propios conjuntos de datos personalizados. Para usarlo, instale Merlion con la dependencia opcional dashboard (es decir, pip install salesforce-merlion[dashboard]) y ejecute python -m merlion.dashboard desde la línea de comandos. Puede ver el panel en http://localhost:8050. A continuación mostramos algunas capturas de pantalla del panel tanto para detección de anomalías como para pronóstico.

Para ayudarle a comenzar a usar Merlion en su propio código, proporcionamos a continuación algunos ejemplos mínimos usando los modelos predeterminados de Merlion tanto para detección de anomalías como para pronóstico.

Detección de anomalías

Aquí mostramos el código para replicar los resultados del panel de detección de anomalías anterior. Comenzamos importando la clase TimeSeries de Merlion y el cargador de datos para el benchmark de anomalías de Numenta NAB. Luego podemos dividir una serie temporal específica de este conjunto de datos en particiones de entrenamiento y prueba.

from merlion.utils import TimeSeries
from ts_datasets.anomaly import NAB

# Data loader returns pandas DataFrames, which we convert to Merlion TimeSeries
time_series, metadata = NAB(subset="realKnownCause")[3]
train_data = TimeSeries.from_pd(time_series[metadata.trainval])
test_data = TimeSeries.from_pd(time_series[~metadata.trainval])
test_labels = TimeSeries.from_pd(metadata.anomaly[~metadata.trainval])

A continuación, podemos inicializar y entrenar el DefaultDetector de Merlion, que es un modelo de detección de anomalías que equilibra rendimiento y eficiencia. También obtenemos sus predicciones sobre la partición de prueba.

from merlion.models.defaults import DefaultDetectorConfig, DefaultDetector
model = DefaultDetector(DefaultDetectorConfig())
model.train(train_data=train_data)
test_pred = model.get_anomaly_label(time_series=test_data)

Después, visualizamos las predicciones del modelo.

from merlion.plot import plot_anoms
import matplotlib.pyplot as plt
fig, ax = model.plot_anomaly(time_series=test_data)
plot_anoms(ax=ax, anomaly_labels=test_labels)
plt.show()

Finalmente, podemos evaluar el modelo cuantitativamente. La precisión y el recall provienen del hecho de que el modelo disparó 3 alarmas, con 2 verdaderos positivos, 1 falso negativo y 1 falso positivo. También evaluamos el tiempo medio que tardó el modelo en detectar cada anomalía que detectó correctamente.

from merlion.evaluate.anomaly import TSADMetric
p = TSADMetric.Precision.value(ground_truth=test_labels, predict=test_pred)
r = TSADMetric.Recall.value(ground_truth=test_labels, predict=test_pred)
f1 = TSADMetric.F1.value(ground_truth=test_labels, predict=test_pred)
mttd = TSADMetric.MeanTimeToDetect.value(ground_truth=test_labels, predict=test_pred)
print(f"Precision: {p:.4f}, Recall: {r:.4f}, F1: {f1:.4f}\n"
      f"Mean Time To Detect: {mttd}")

Precision: 0.6667, Recall: 0.6667, F1: 0.6667
Mean Time To Detect: 1 days 10:22:30

Pronóstico

Aquí mostramos el código para replicar los resultados del panel de pronóstico anterior. Comenzamos importando la clase TimeSeries de Merlion y el cargador de datos para el conjunto de datos M4. Luego podemos dividir una serie temporal específica de este conjunto de datos en particiones de entrenamiento y prueba.

from merlion.utils import TimeSeries
from ts_datasets.forecast import M4

# Data loader returns pandas DataFrames, which we convert to Merlion TimeSeries
time_series, metadata = M4(subset="Hourly")[0]
train_data = TimeSeries.from_pd(time_series[metadata.trainval])
test_data = TimeSeries.from_pd(time_series[~metadata.trainval])

A continuación, podemos inicializar y entrenar el DefaultForecaster de Merlion, que es un modelo de pronóstico que equilibra rendimiento y eficiencia. También obtenemos sus predicciones sobre la partición de prueba.

from merlion.models.defaults import DefaultForecasterConfig, DefaultForecaster
model = DefaultForecaster(DefaultForecasterConfig())
model.train(train_data=train_data)
test_pred, test_err = model.forecast(time_stamps=test_data.time_stamps)

Después, visualizamos las predicciones del modelo.

import matplotlib.pyplot as plt
fig, ax = model.plot_forecast(time_series=test_data, plot_forecast_uncertainty=True)
plt.show()

Finalmente, evaluamos el modelo cuantitativamente. sMAPE mide el error de la predicción en una escala de 0 a 100 (cuanto menor, mejor), mientras que MSIS evalúa la calidad de la banda de confianza del 95% en una escala de 0 a 100 (cuanto menor, mejor).

# Evaluate the model's predictions quantitatively
from scipy.stats import norm
from merlion.evaluate.forecast import ForecastMetric

# Compute the sMAPE of the predictions (0 to 100, smaller is better)
smape = ForecastMetric.sMAPE.value(ground_truth=test_data, predict=test_pred)

# Compute the MSIS of the model's 95% confidence interval (0 to 100, smaller is better)
lb = TimeSeries.from_pd(test_pred.to_pd() + norm.ppf(0.025) * test_err.to_pd().values)
ub = TimeSeries.from_pd(test_pred.to_pd() + norm.ppf(0.975) * test_err.to_pd().values)
msis = ForecastMetric.MSIS.value(ground_truth=test_data, predict=test_pred,
                                 insample=train_data, lb=lb, ub=ub)
print(f"sMAPE: {smape:.4f}, MSIS: {msis:.4f}")

sMAPE: 4.1944, MSIS: 18.9331

Evaluación y benchmarking

Una de las características clave de Merlion es un pipeline de evaluación que simula el despliegue en vivo de un modelo sobre datos históricos. Esto permite comparar modelos en los conjuntos de datos relevantes para ellos, bajo las condiciones que podrían encontrar en un entorno de producción. Nuestro pipeline de evaluación procede de la siguiente manera:

1. Entrenar un modelo inicial con datos históricos de entrenamiento recientes (designados como la partición de entrenamiento de la serie temporal)
2. A intervalos regulares (por ejemplo, una vez al día), reentrenar el modelo completo con los datos más recientes. Esto puede ser o bien todo el historial de la serie temporal, o una ventana más limitada (por ejemplo, 4 semanas).
3. Obtener las predicciones del modelo (puntuaciones de anomalía o pronósticos) para los valores de la serie temporal que ocurren entre reentrenamientos. Puede personalizar si esto debe hacerse por lotes (prediciendo todos los valores a la vez), en streaming (actualizando el estado interno del modelo después de cada punto de datos sin reentrenarlo por completo), o con alguna cadencia intermedia.
4. Comparar las predicciones del modelo con la verdad fundamental (anomalías etiquetadas para detección de anomalías, o los valores reales de la serie temporal para pronóstico) e informar métricas de evaluación cuantitativas.

Proporcionamos scripts que le permiten usar este pipeline para evaluar modelos arbitrarios en conjuntos de datos arbitrarios. Por ejemplo, ejecutando

python benchmark_anomaly.py --dataset NAB_realAWSCloudwatch --model IsolationForest --retrain_freq 1d

se evaluará el rendimiento de detección de anomalías del IsolationForest (reentrenado una vez al día) en el subconjunto "realAWSCloudwatch" del conjunto de datos NAB. De manera similar, ejecutando

python benchmark_forecast.py --dataset M4_Hourly --model ETS

se evaluará el rendimiento de pronóstico por lotes (es decir, sin reentrenamiento) de ETS en el subconjunto "Hourly" del conjunto de datos M4. Puede encontrar los resultados producidos al ejecutar estos scripts en la sección Experiments del informe técnico.

Informe técnico y cómo citar Merlion

Puede encontrar más detalles en nuestro informe técnico: https://arxiv.org/abs/2109.09265

Si está usando Merlion en su investigación o aplicaciones, por favor cite usando este BibTeX:

@article{bhatnagar2021merlion,
      title={Merlion: A Machine Learning Library for Time Series},
      author={Aadyot Bhatnagar and Paul Kassianik and Chenghao Liu and Tian Lan and Wenzhuo Yang
              and Rowan Cassius and Doyen Sahoo and Devansh Arpit and Sri Subramanian and Gerald Woo
              and Amrita Saha and Arun Kumar Jagota and Gokulakrishnan Gopalakrishnan and Manpreet Singh
              and K C Krithika and Sukumar Maddineni and Daeki Cho and Bo Zong and Yingbo Zhou
              and Caiming Xiong and Silvio Savarese and Steven Hoi and Huan Wang},
      year={2021},
      eprint={2109.09265},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

Tareas pendientes

Nos esforzamos por aprovechar el modelado de series temporales con GPUs para mejorar aún más la velocidad y el rendimiento de Merlion. Manténgase atento...