Merlion: Eine Machine-Learning-Bibliothek für Zeitreihen

Inhaltsverzeichnis

1. Einführung
2. Vergleich mit verwandten Bibliotheken
3. Installation
4. Dokumentation
5. Erste Schritte
   1. Anomalieerkennung
   2. Prognose
6. Evaluierung und Benchmarking
7. Technischer Bericht und Zitieren von Merlion

Einführung

Merlion ist eine Python-Bibliothek für Zeitreihen-Intelligenz. Sie bietet ein End-to-End-Machine-Learning-Framework, das das Laden und Transformieren von Daten, das Erstellen und Trainieren von Modellen, die Nachbearbeitung von Modellausgaben sowie die Bewertung der Modellleistung umfasst. Es unterstützt verschiedene Aufgaben des Zeitreihenlernens, darunter Prognose, Anomalieerkennung und Change-Point-Erkennung für univariate und multivariate Zeitreihen. Diese Bibliothek soll Ingenieuren und Forschern eine Komplettlösung bieten, um schnell Modelle für ihre spezifischen Zeitreihenanforderungen zu entwickeln und sie über mehrere Zeitreihendatensätze hinweg zu benchmarken.

Die wichtigsten Merkmale von Merlion sind:

• Standardisiertes und einfach erweiterbares Laden von Daten und Benchmarking für eine breite Palette von Prognose- und Anomalieerkennungsdatensätzen. Dies beinhaltet transparente Unterstützung für benutzerdefinierte Datensätze.
• Eine Bibliothek vielfältiger Modelle für Anomalieerkennung, Prognose und Change-Point-Erkennung, die alle unter einer gemeinsamen Schnittstelle vereint sind. Die Modelle umfassen klassische statistische Methoden, Baum-Ensembles und Deep-Learning-Ansätze. Fortgeschrittene Benutzer können jedes Modell nach Wunsch vollständig konfigurieren.
• Abstrakte DefaultDetector- und DefaultForecaster-Modelle, die effizient sind, robust gute Leistungen erzielen und einen Ausgangspunkt für neue Benutzer bieten.
• AutoML für automatische Hyperparameter-Abstimmung und Modellauswahl.
• Einheitliche API zur Verwendung einer breiten Palette von Modellen für Prognosen mit exogenen Regressoren.
• Praktische, von der Industrie inspirierte Nachbearbeitungsregeln für Anomalieerkennungsmodelle, die Anomalie-Scores interpretierbarer machen und gleichzeitig die Anzahl falsch positiver Ergebnisse reduzieren.
• Benutzerfreundliche Ensembles, die die Ausgaben mehrerer Modelle kombinieren, um eine robustere Leistung zu erzielen.
• Flexible Evaluierungspipelines, die den Live-Einsatz und das Nachtrainieren eines Modells in der Produktion simulieren und die Leistung sowohl bei der Prognose als auch bei der Anomalieerkennung bewerten.
• Native Unterstützung für die Visualisierung von Modellvorhersagen, einschließlich einer klickbaren visuellen Benutzeroberfläche.
• Verteilter Berechnungs-Backend mit PySpark, das zur Bereitstellung von Zeitreihenanwendungen im industriellen Maßstab verwendet werden kann.

Vergleich mit verwandten Bibliotheken

Die folgende Tabelle bietet einen visuellen Überblick darüber, wie sich die wichtigsten Funktionen von Merlion im Vergleich zu anderen Bibliotheken für Zeitreihen-Anomalieerkennung und/oder -Prognose verhalten.

Die folgenden Funktionen sind neu in Merlion 2.0:

Installation

Merlion besteht aus zwei Unter-Repos: merlion implementiert die zentralen Zeitreihen-Intelligenzfunktionen der Bibliothek, und ts_datasets bietet standardisierte Datenlader für mehrere Zeitreihendatensätze. Diese Lader laden Zeitreihen als pandas.DataFrame-Objekte mit zugehörigen Metadaten.

Sie können merlion von PyPI installieren, indem Sie pip install salesforce-merlion aufrufen. Sie können aus dem Quellcode installieren, indem Sie dieses Repo klonen und pip install Merlion/ aufrufen, oder pip install -e Merlion/ für die Installation im bearbeitbaren Modus (Editable Mode). Sie können zusätzliche Abhängigkeiten über pip install salesforce-merlion[all] installieren oder pip install "Merlion/[all]" aufrufen, wenn Sie aus dem Quellcode installieren. Zu den optionalen Abhängigkeiten gehören unter anderem dashboard für ein GUI-Dashboard, spark für ein verteiltes Berechnungs-Backend mit PySpark und deep-learning für alle Deep-Learning-Modelle.

Um das Datenladepaket ts_datasets zu installieren, klonen Sie dieses Repo und rufen Sie pip install -e Merlion/ts_datasets/ auf. Dieses Paket muss im bearbeitbaren Modus installiert werden (d. h. mit dem Flag -e), wenn Sie beim Initialisieren des Datenladers nicht das Stammverzeichnis jedes Datensatzes manuell angeben möchten.

Beachten Sie die folgenden externen Abhängigkeiten:

1. Einige unserer Prognosemodelle hängen von OpenMP ab. Wenn Sie conda verwenden, führen Sie bitte conda install -c conda-forge lightgbm aus, bevor Sie unser Paket installieren. Dadurch wird sichergestellt, dass OpenMP so konfiguriert ist, dass es mit dem Paket lightgbm (einer unserer Abhängigkeiten) in Ihrer conda- Umgebung funktioniert. Wenn Sie einen Mac verwenden, installieren Sie bitte Homebrew und rufen Sie brew install libomp auf, damit die OpenMP-Bibliothek für das Modell verfügbar ist.

2. Einige unserer Anomalieerkennungsmodelle hängen vom Java Development Kit (JDK) ab. Für Ubuntu rufen Sie sudo apt-get install openjdk-11-jdk auf. Für Mac OS installieren Sie Homebrew und rufen Sie brew tap adoptopenjdk/openjdk && brew install --cask adoptopenjdk11 auf. Stellen Sie außerdem sicher, dass java über Ihren PATH gefunden werden kann und dass die Umgebungsvariable JAVA_HOME gesetzt ist.

Dokumentation

Für Beispielcode und eine Einführung in Merlion finden Sie die Jupyter-Notebooks in examples und den geführten Walkthrough hier. Eine detaillierte API-Dokumentation (einschließlich des Beispielcodes) finden Sie hier. Der technische Bericht beschreibt die Gesamtarchitektur von Merlion und stellt experimentelle Ergebnisse zur Zeitreihen-Anomalieerkennung und -Prognose für univariate und multivariate Zeitreihen vor.

Erste Schritte

Der einfachste Weg, um loszulegen, ist die webbasierte GUI- Dashboard. Dieses Dashboard bietet eine großartige Möglichkeit, schnell mit vielen Modellen auf Ihren eigenen benutzerdefinierten Datensätzen zu experimentieren. Um es zu verwenden, installieren Sie Merlion mit der optionalen Abhängigkeit dashboard (d. h. pip install salesforce-merlion[dashboard]) und rufen Sie python -m merlion.dashboard von der Befehlszeile aus auf. Sie können das Dashboard unter http://localhost:8050 anzeigen. Unten zeigen wir einige Screenshots des Dashboards sowohl für die Anomalieerkennung als auch für die Prognose.

Um Ihnen den Einstieg in die Verwendung von Merlion in Ihrem eigenen Code zu erleichtern, finden Sie unten einige minimale Beispiele mit den Standardmodellen von Merlion für sowohl Anomalieerkennung als auch Prognose.

Anomalieerkennung

Hier zeigen wir den Code, um die Ergebnisse des obigen Anomalieerkennungs-Dashboards zu replizieren. Wir beginnen mit dem Import der TimeSeries-Klasse von Merlion und des Datenladers für das Numenta Anomaly Benchmark NAB. Wir können dann eine bestimmte Zeitreihe aus diesem Datensatz in Trainings- und Test-Splits aufteilen.

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

Wir können dann Merlions DefaultDetector initialisieren und trainieren, ein Anomalieerkennungsmodell, das Leistung und Effizienz ausbalanciert. Wir erhalten auch seine Vorhersagen auf dem Test-Split.

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)

Als Nächstes visualisieren wir die Vorhersagen des Modells.

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

Schließlich können wir das Modell quantitativ evaluieren. Die Precision und der Recall ergeben sich aus der Tatsache, dass das Modell 3 Alarme ausgelöst hat, mit 2 richtig positiven, 1 falsch negativen und 1 falsch positiven. Wir bewerten auch die mittlere Zeit, die das Modell benötigt hat, um jede Anomalie zu erkennen, die es korrekt erkannt hat.

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

Prognose

Hier zeigen wir den Code, um die Ergebnisse des obigen Prognose-Dashboards zu replizieren. Wir beginnen mit dem Import der TimeSeries-Klasse von Merlion und des Datenladers für den Datensatz M4. Wir können dann eine bestimmte Zeitreihe aus diesem Datensatz in Trainings- und Test-Splits aufteilen.

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

Wir können dann Merlions DefaultForecaster initialisieren und trainieren, ein Prognosemodell, das Leistung und Effizienz ausbalanciert. Wir erhalten auch seine Vorhersagen auf dem Test-Split.

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)

Als Nächstes visualisieren wir die Vorhersagen des Modells.

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

Schließlich evaluieren wir das Modell quantitativ. sMAPE misst den Fehler der Vorhersage auf einer Skala von 0 bis 100 (niedriger ist besser), während MSIS die Qualität des 95%-Konfidenzbands auf einer Skala von 0 bis 100 bewertet (niedriger ist besser).

# 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

Evaluierung und Benchmarking

Eines der wichtigsten Merkmale von Merlion ist eine Evaluierungspipeline, die den Live-Einsatz eines Modells auf historischen Daten simuliert. Dies ermöglicht es Ihnen, Modelle auf den für sie relevanten Datensätzen unter den Bedingungen zu vergleichen, denen sie in einer Produktionsumgebung begegnen können. Unsere Evaluierungspipeline läuft wie folgt ab:

1. Trainieren Sie ein erstes Modell auf aktuellen historischen Trainingsdaten (als Trainings-Split der Zeitreihe bezeichnet).
2. Trainieren Sie in regelmäßigen Abständen (z. B. einmal pro Tag) das gesamte Modell mit den aktuellsten Daten neu. Dies kann entweder die gesamte Historie der Zeitreihe oder ein begrenzteres Fenster (z. B. 4 Wochen) sein.
3. Ermitteln Sie die Vorhersagen des Modells (Anomalie-Scores oder Prognosen) für die Zeitreihenwerte, die zwischen den Neuläufen auftreten. Sie können anpassen, ob dies im Batch (alle Werte auf einmal vorhersagen), im Streaming (den internen Zustand des Modells nach jedem Datenpunkt aktualisieren, ohne es vollständig neu zu trainieren) oder in einem Zwischentakt erfolgen soll.
4. Vergleichen Sie die Vorhersagen des Modells mit der Ground Truth (gelabelte Anomalien für die Anomalieerkennung oder die tatsächlichen Zeitreihenwerte für die Prognose) und berichten Sie quantitative Bewertungsmetriken.

Wir stellen Skripte bereit, mit denen Sie diese Pipeline verwenden können, um beliebige Modelle auf beliebigen Datensätzen zu evaluieren. Zum Beispiel wird der Aufruf

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

die Anomalieerkennungsleistung des IsolationForest (einmal täglich neu trainiert) auf dem Subset "realAWSCloudwatch" des NAB-Datensatzes evaluieren. Ebenso wird der Aufruf

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

die Batch-Prognoseleistung (d. h. ohne Neulauf) von ETS auf dem Subset "Hourly" des M4-Datensatzes evaluieren. Sie finden die Ergebnisse, die durch die Ausführung dieser Skripte erzeugt werden, im Abschnitt Experimente des technischen Berichts.

Technischer Bericht und Zitieren von Merlion

Weitere Details finden Sie in unserem technischen Bericht: https://arxiv.org/abs/2109.09265

Wenn Sie Merlion in Ihrer Forschung oder Ihren Anwendungen verwenden, zitieren Sie bitte mit diesem 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}
}

To Dos

Wir arbeiten daran, die Zeitreihenmodellierung mit GPUs zu nutzen, um die Geschwindigkeit und den Durchsatz von Merlion weiter zu verbessern. Bleiben Sie dran ...