Merlion: una libreria di machine learning per serie temporali

Indice

1. Introduzione
2. Confronto con librerie correlate
3. Installazione
4. Documentazione
5. Per iniziare
   1. Rilevamento delle anomalie
   2. Previsione
6. Valutazione e benchmark
7. Report tecnico e citazione di Merlion

Introduzione

Merlion è una libreria Python per l'intelligenza delle serie temporali. Fornisce un framework di machine learning end-to-end che include caricamento e trasformazione dei dati, costruzione e addestramento dei modelli, post-elaborazione degli output dei modelli e valutazione delle prestazioni dei modelli. Supporta vari compiti di apprendimento su serie temporali, tra cui previsione, rilevamento delle anomalie, e rilevamento dei punti di cambiamento per serie temporali sia univariate che multivariate. Questa libreria mira a fornire a ingegneri e ricercatori una soluzione completa per sviluppare rapidamente modelli per le loro specifiche esigenze sulle serie temporali, e valutarli su più dataset di serie temporali.

Le caratteristiche principali di Merlion sono

• Caricamento dei dati e benchmark standardizzati e facilmente estendibili per un'ampia gamma di dataset di previsione e rilevamento delle anomalie. Include supporto trasparente per dataset personalizzati.
• Una libreria di modelli eterogenei per il rilevamento delle anomalie, la previsione e il rilevamento dei punti di cambiamento, tutti unificati sotto un'interfaccia condivisa. I modelli includono metodi statistici classici, ensemble di alberi e approcci di deep learning. Gli utenti avanzati possono configurare completamente ogni modello come desiderano.
• Modelli astratti DefaultDetector e DefaultForecaster efficienti, che ottengono buone prestazioni in modo robusto, e forniscono un punto di partenza per i nuovi utenti.
• AutoML per la regolazione automatica degli iperparametri e la selezione dei modelli.
• API unificata per utilizzare un'ampia gamma di modelli per fare previsioni con regressori esogeni.
• Regole di post-elaborazione pratiche, ispirate all'industria, per i rilevatori di anomalie che rendono i punteggi di anomalia più interpretabili, riducendo anche il numero di falsi positivi.
• Ensemble facili da usare che combinano gli output di più modelli per ottenere prestazioni più robuste.
• Pipeline di valutazione flessibili che simulano la distribuzione live e il ri-addestramento di un modello in produzione, e valutano le prestazioni sia per la previsione che per il rilevamento delle anomalie.
• Supporto nativo per la visualizzazione delle previsioni dei modelli, anche tramite un'interfaccia visiva cliccabile.
• Backend di calcolo distribuito basato su PySpark, che può essere utilizzato per servire applicazioni su serie temporali a scala industriale.

Confronto con librerie correlate

La tabella seguente fornisce una panoramica visiva di come le caratteristiche principali di Merlion si confrontano con altre librerie per il rilevamento delle anomalie e/o la previsione di serie temporali.

Le seguenti funzionalità sono nuove in Merlion 2.0:

Installazione

Merlion è composto da due sotto-repository: merlion implementa le funzionalità principali di intelligenza per serie temporali della libreria, e ts_datasets fornisce loader di dati standardizzati per diversi dataset di serie temporali. Questi loader caricano le serie temporali come pandas.DataFrame con i relativi metadati.

Puoi installare merlion da PyPI eseguendo pip install salesforce-merlion. Puoi installare dal sorgente clonando questo repository ed eseguendo pip install Merlion/, oppure pip install -e Merlion/ per installare in modalità modificabile (editable). Puoi installare dipendenze aggiuntive tramite pip install salesforce-merlion[all], oppure eseguendo pip install "Merlion/[all]" se installi dal sorgente. Singolarmente, le dipendenze opzionali includono dashboard per una dashboard GUI, spark per un backend di calcolo distribuito con PySpark e deep-learning per tutti i modelli di deep learning.

Per installare il pacchetto di caricamento dati ts_datasets, clona questo repository ed esegui pip install -e Merlion/ts_datasets/. Questo pacchetto deve essere installato in modalità modificabile (cioè con il flag -e) se non vuoi specificare manualmente la directory principale di ogni dataset durante l'inizializzazione del suo data loader.

Nota le seguenti dipendenze esterne:

1. Alcuni dei nostri modelli di previsione dipendono da OpenMP. Se usi conda, esegui conda install -c conda-forge lightgbm prima di installare il nostro pacchetto. Questo garantirà che OpenMP sia configurato per funzionare con il pacchetto lightgbm (una delle nostre dipendenze) nel tuo ambiente conda. Se usi Mac, installa Homebrew ed esegui brew install libomp in modo che la libreria OpenMP sia disponibile per il modello.

2. Alcuni dei nostri modelli di rilevamento delle anomalie dipendono dal Java Development Kit (JDK). Per Ubuntu, esegui sudo apt-get install openjdk-11-jdk. Per Mac OS, installa Homebrew ed esegui brew tap adoptopenjdk/openjdk && brew install --cask adoptopenjdk11. Assicurati inoltre che java sia reperibile nel tuo PATH e che la variabile d'ambiente JAVA_HOME sia impostata.

Documentazione

Per esempi di codice e un'introduzione a Merlion, consulta i notebook Jupyter in examples e la guida guidata qui. Puoi trovare la documentazione API dettagliata (inclusi gli esempi di codice) qui. Il report tecnico illustra l'architettura complessiva di Merlion e presenta risultati sperimentali su rilevamento di anomalie e previsione di serie temporali, sia univariate che multivariate.

Per iniziare

Il modo più semplice per iniziare è usare la dashboard web basata su GUI. Questa dashboard offre un ottimo modo per sperimentare rapidamente con molti modelli sui tuoi dataset personalizzati. Per usarla, installa Merlion con la dipendenza opzionale dashboard (cioè pip install salesforce-merlion[dashboard]) ed esegui python -m merlion.dashboard dalla riga di comando. Puoi visualizzare la dashboard all'indirizzo http://localhost:8050. Di seguito mostriamo alcuni screenshot della dashboard sia per il rilevamento delle anomalie che per la previsione.

Per aiutarti a iniziare a usare Merlion nel tuo codice, forniamo di seguito alcuni esempi minimi che utilizzano i modelli predefiniti di Merlion sia per il rilevamento delle anomalie che per la previsione.

Rilevamento delle anomalie

Qui mostriamo il codice per replicare i risultati della dashboard di rilevamento delle anomalie sopra. Iniziamo importando la classe TimeSeries di Merlion e il data loader per il Numenta Anomaly Benchmark NAB. Possiamo quindi dividere una specifica serie temporale di questo dataset in partizioni di addestramento e 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])

Possiamo quindi inizializzare e addestrare DefaultDetector di Merlion, un modello di rilevamento delle anomalie che bilancia prestazioni ed efficienza. Otteniamo anche le sue previsioni sulla partizione di 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)

Successivamente, visualizziamo le previsioni del modello.

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

Infine, possiamo valutare quantitativamente il modello. La precision e il recall derivano dal fatto che il modello ha attivato 3 allarmi, con 2 veri positivi, 1 falso negativo e 1 falso positivo. Valutiamo anche il tempo medio impiegato dal modello per rilevare ogni anomalia che ha correttamente individuato.

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

Previsione

Qui mostriamo il codice per replicare i risultati della dashboard di previsione sopra. Iniziamo importando la classe TimeSeries di Merlion e il data loader per il dataset M4. Possiamo quindi dividere una specifica serie temporale di questo dataset in partizioni di addestramento e 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])

Possiamo quindi inizializzare e addestrare DefaultForecaster di Merlion, un modello di previsione che bilancia prestazioni ed efficienza. Otteniamo anche le sue previsioni sulla partizione di 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)

Successivamente, visualizziamo le previsioni del modello.

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

Infine, valutiamo quantitativamente il modello. Lo sMAPE misura l'errore della previsione su una scala da 0 a 100 (più basso è meglio), mentre il MSIS valuta la qualità della banda di confidenza al 95% su una scala da 0 a 100 (più basso è meglio).

# 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

Valutazione e benchmark

Una delle caratteristiche principali di Merlion è una pipeline di valutazione che simula la distribuzione live di un modello su dati storici. Questo ti consente di confrontare i modelli sui dataset pertinenti, nelle condizioni che potrebbero incontrare in un ambiente di produzione. La nostra pipeline di valutazione procede come segue:

1. Addestrare un modello iniziale sui dati di addestramento storici recenti (designati come partizione di addestramento della serie temporale)
2. A intervalli regolari (ad esempio una volta al giorno), ri-addestrare l'intero modello sui dati più recenti. Questo può essere l'intera storia della serie temporale o una finestra più limitata (ad esempio 4 settimane).
3. Ottenere le previsioni del modello (punteggi di anomalia o previsioni) per i valori della serie temporale che si verificano tra un ri-addestramento e l'altro. Puoi personalizzare se eseguire questa operazione in batch (prevedendo tutti i valori in una volta), in streaming (aggiornando lo stato interno del modello dopo ogni punto dati senza ri-addestrarlo completamente), o con una cadenza intermedia.
4. Confrontare le previsioni del modello con il ground truth (anomalie etichettate per il rilevamento delle anomalie, o i valori effettivi della serie temporale per la previsione) e riportare metriche di valutazione quantitative.

Forniamo script che ti permettono di usare questa pipeline per valutare modelli arbitrari su dataset arbitrari. Ad esempio, eseguendo

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

verrà valutata la performance di rilevamento delle anomalie di IsolationForest (ri-addestrato una volta al giorno) sul sottoinsieme "realAWSCloudwatch" del dataset NAB. Analogamente, eseguendo

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

verrà valutata la performance di previsione in batch (cioè senza ri-addestramento) di ETS sul sottoinsieme "Hourly" del dataset M4. Puoi trovare i risultati prodotti eseguendo questi script nella sezione Esperimenti del report tecnico.

Report tecnico e citazione di Merlion

Puoi trovare maggiori dettagli nel nostro report tecnico: https://arxiv.org/abs/2109.09265

Se stai usando Merlion nelle tue ricerche o applicazioni, ti preghiamo di citarlo usando questo 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 Do

Stiamo cercando di sfruttare la modellazione delle serie temporali con GPU per migliorare ulteriormente la velocità e il throughput di Merlion. Resta sintonizzato ...