Merlion : une bibliothèque d'apprentissage automatique pour les séries temporelles

Table des matières

Introduction
Comparaison avec les bibliothèques associées
Installation
Documentation
Pour commencer
1. Détection d'anomalies
2. Prévision
Évaluation et benchmarking
Rapport technique et citation de Merlion

Introduction

Merlion est une bibliothèque Python pour l'intelligence des séries temporelles. Elle fournit un cadre d'apprentissage automatique de bout en bout qui comprend le chargement et la transformation des données, la construction et l'entraînement de modèles, le post-traitement des sorties de modèles et l'évaluation des performances des modèles. Elle prend en charge diverses tâches d'apprentissage sur séries temporelles, notamment la prévision, la détection d'anomalies et la détection de points de changement, pour les séries temporelles univariées et multivariées. Cette bibliothèque vise à fournir aux ingénieurs et aux chercheurs une solution tout-en-un pour développer rapidement des modèles adaptés à leurs besoins spécifiques en matière de séries temporelles, et pour les évaluer sur plusieurs jeux de données de séries temporelles.

Les principales fonctionnalités de Merlion sont

Chargement de données et benchmarking standardisés et facilement extensibles pour un large éventail de jeux de données de prévision et de détection d'anomalies. Cela inclut un support transparent pour les jeux de données personnalisés.
Une bibliothèque de modèles variés pour la détection d'anomalies, la prévision et la détection de points de changement, tous unifiés sous une interface commune. Les modèles incluent des méthodes statistiques classiques, des ensembles d'arbres et des approches d'apprentissage profond. Les utilisateurs avancés peuvent configurer entièrement chaque modèle comme ils le souhaitent.
Des modèles abstraits DefaultDetector et DefaultForecaster qui sont efficaces, obtiennent de bonnes performances de manière robuste, et constituent un point de départ pour les nouveaux utilisateurs.
AutoML pour le réglage automatisé des hyperparamètres et la sélection de modèles.
API unifiée pour utiliser un large éventail de modèles de prévision avec des régresseurs exogènes.
Des règles de post-traitement pratiques, inspirées de l'industrie, pour les détecteurs d'anomalies, qui rendent les scores d'anomalie plus interprétables, tout en réduisant le nombre de faux positifs.
Des ensembles faciles à utiliser qui combinent les sorties de plusieurs modèles pour obtenir des performances plus robustes.
Des pipelines d'évaluation flexibles qui simulent le déploiement en direct et le ré-entraînement d'un modèle en production, et évaluent les performances à la fois en prévision et en détection d'anomalies.
Support natif pour la visualisation des prédictions des modèles, y compris avec une interface visuelle cliquable.
Un backend de calcul distribué utilisant PySpark, qui peut être utilisé pour servir des applications de séries temporelles à l'échelle industrielle.

Comparaison avec les bibliothèques associées

Le tableau ci-dessous donne un aperçu visuel de la façon dont les principales fonctionnalités de Merlion se comparent à d'autres bibliothèques de détection d'anomalies et/ou de prévision de séries temporelles.

Les fonctionnalités suivantes sont nouvelles dans Merlion 2.0 :

Installation

Merlion se compose de deux sous-dépôts : merlion implémente les fonctionnalités principales d'intelligence des séries temporelles de la bibliothèque, et ts_datasets fournit des chargeurs de données standardisés pour plusieurs jeux de données de séries temporelles. Ces chargeurs chargent les séries temporelles sous forme de pandas.DataFrame avec leurs métadonnées.

Vous pouvez installer merlion depuis PyPI en exécutant pip install salesforce-merlion. Vous pouvez installer à partir des sources en clonant ce dépôt et en exécutant pip install Merlion/, ou pip install -e Merlion/ pour une installation en mode éditable. Vous pouvez installer des dépendances supplémentaires via pip install salesforce-merlion[all], ou en exécutant pip install "Merlion/[all]" si vous installez à partir des sources. Individuellement, les dépendances optionnelles incluent dashboard pour un tableau de bord graphique, spark pour un backend de calcul distribué avec PySpark, et deep-learning pour tous les modèles d'apprentissage profond.

Pour installer le paquet de chargement de données ts_datasets, clonez ce dépôt et exécutez pip install -e Merlion/ts_datasets/. Ce paquet doit être installé en mode éditable (c'est-à-dire avec l'option -e) si vous ne souhaitez pas spécifier manuellement le répertoire racine de chaque jeu de données lors de l'initialisation de son chargeur de données.

Notez les dépendances externes suivantes :

Certains de nos modèles de prévision dépendent d'OpenMP. Si vous utilisez conda, veuillez conda install -c conda-forge lightgbm avant d'installer notre paquet. Cela garantira qu'OpenMP est configuré pour fonctionner avec le paquet lightgbm (l'une de nos dépendances) dans votre environnement conda. Si vous utilisez un Mac, veuillez installer Homebrew et exécuter brew install libomp afin que la bibliothèque OpenMP soit disponible pour le modèle.
Certains de nos modèles de détection d'anomalies dépendent du Java Development Kit (JDK). Pour Ubuntu, exécutez sudo apt-get install openjdk-11-jdk. Pour Mac OS, installez Homebrew et exécutez brew tap adoptopenjdk/openjdk && brew install --cask adoptopenjdk11. Assurez-vous également que java peut être trouvé sur votre PATH, et que la variable d'environnement JAVA_HOME est définie.

Documentation

Pour des exemples de code et une introduction à Merlion, consultez les notebooks Jupyter dans examples, et la visite guidée ici. Vous trouverez une documentation API détaillée (y compris les exemples de code) ici. Le rapport technique décrit l'architecture globale de Merlion et présente des résultats expérimentaux sur la détection d'anomalies et la prévision de séries temporelles, à la fois univariées et multivariées.

Pour commencer

Le moyen le plus simple de commencer est d'utiliser le tableau de bord web à interface graphique dashboard. Ce tableau de bord offre un excellent moyen d'expérimenter rapidement avec de nombreux modèles sur vos propres jeux de données personnalisés. Pour l'utiliser, installez Merlion avec la dépendance optionnelle dashboard (c'est-à-dire pip install salesforce-merlion[dashboard]), puis exécutez python -m merlion.dashboard à partir de la ligne de commande. Vous pouvez consulter le tableau de bord à l'adresse http://localhost:8050. Ci-dessous, nous montrons quelques captures d'écran du tableau de bord pour la détection d'anomalies et la prévision.

anomaly dashboard

forecast dashboard

Pour vous aider à commencer à utiliser Merlion dans votre propre code, nous fournissons ci-dessous quelques exemples minimaux utilisant les modèles par défaut de Merlion pour la détection d'anomalies et la prévision.

Détection d'anomalies

Nous montrons ici le code permettant de reproduire les résultats du tableau de bord de détection d'anomalies ci-dessus. Nous commençons par importer la classe TimeSeries de Merlion et le chargeur de données du Numenta Anomaly Benchmark NAB. Nous pouvons ensuite diviser une série temporelle spécifique de ce jeu de données en ensembles d'entraînement et de test.

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])

Nous pouvons ensuite initialiser et entraîner le DefaultDetector de Merlion, qui est un modèle de détection d'anomalies qui équilibre performances et efficacité. Nous obtenons également ses prédictions sur l'ensemble de test.

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)

Ensuite, nous visualisons les prédictions du modèle.

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()

anomaly figure

Enfin, nous pouvons évaluer le modèle quantitativement. La précision et le rappel proviennent du fait que le modèle a déclenché 3 alarmes, avec 2 vrais positifs, 1 faux négatif et 1 faux positif. Nous évaluons également le temps moyen mis par le modèle pour détecter chaque anomalie qu'il a correctement détectée.

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

Prévision

Nous montrons ici le code permettant de reproduire les résultats du tableau de bord de prévision ci-dessus. Nous commençons par importer la classe TimeSeries de Merlion et le chargeur de données du jeu de données M4. Nous pouvons ensuite diviser une série temporelle spécifique de ce jeu de données en ensembles d'entraînement et de test.

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])

Nous pouvons ensuite initialiser et entraîner le DefaultForecaster de Merlion, qui est un modèle de prévision qui équilibre performances et efficacité. Nous obtenons également ses prédictions sur l'ensemble de test.

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)

Ensuite, nous visualisons les prédictions du modèle.

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

forecast figure

Enfin, nous évaluons le modèle quantitativement. Le sMAPE mesure l'erreur de la prédiction sur une échelle de 0 à 100 (plus c'est bas, mieux c'est), tandis que le MSIS évalue la qualité de la bande de confiance de 95 % sur une échelle de 0 à 100 (plus c'est bas, mieux c'est).

# 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

Évaluation et benchmarking

L'une des principales fonctionnalités de Merlion est un pipeline d'évaluation qui simule le déploiement en direct d'un modèle sur des données historiques. Cela vous permet de comparer des modèles sur les jeux de données qui leur sont pertinents, dans les conditions qu'ils peuvent rencontrer dans un environnement de production. Notre pipeline d'évaluation se déroule comme suit :

Entraîner un modèle initial sur des données d'entraînement historiques récentes (désignées comme l'ensemble d'entraînement de la série temporelle)
À intervalles réguliers (par exemple une fois par jour), ré-entraîner l'ensemble du modèle sur les données les plus récentes. Cela peut être soit l'historique complet de la série temporelle, soit une fenêtre plus limitée (par exemple 4 semaines).
Obtenir les prédictions du modèle (scores d'anomalie ou prévisions) pour les valeurs de la série temporelle qui surviennent entre les ré-entraînements. Vous pouvez personnaliser si cela doit être fait par lots (prédire toutes les valeurs en une fois), en streaming (mettre à jour l'état interne du modèle après chaque point de données sans le ré-entraîner complètement), ou selon une cadence intermédiaire.
Comparer les prédictions du modèle avec la vérité terrain (anomalies étiquetées pour la détection d'anomalies, ou les valeurs réelles de la série temporelle pour la prévision), et rapporter des métriques d'évaluation quantitatives.

Nous fournissons des scripts qui vous permettent d'utiliser ce pipeline pour évaluer des modèles arbitraires sur des jeux de données arbitraires. Par exemple, l'exécution de

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

évaluera les performances de détection d'anomalies de IsolationForest (ré-entraîné une fois par jour) sur le sous-ensemble "realAWSCloudwatch" du jeu de données NAB. De même, l'exécution de

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

évaluera les performances de prévision par lots (c'est-à-dire sans ré-entraînement) de ETS sur le sous-ensemble "Hourly" du jeu de données M4. Vous pouvez trouver les résultats produits par l'exécution de ces scripts dans la section Expériences du rapport technique.

Rapport technique et citation de Merlion

Vous pouvez trouver plus de détails dans notre rapport technique : https://arxiv.org/abs/2109.09265

Si vous utilisez Merlion dans vos recherches ou applications, veuillez le citer en utilisant ce 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}
}

À faire

Nous nous efforçons de tirer parti de la modélisation des séries temporelles avec des GPU pour améliorer encore la vitesse et le débit de Merlion. Restez à l'écoute...

Merlion

Populaires