Merlion: Uma Biblioteca de Machine Learning para Séries Temporais

Sumário

1. Introdução
2. Comparação com Bibliotecas Relacionadas
3. Instalação
4. Documentação
5. Começando
   1. Detecção de Anomalias
   2. Previsão
6. Avaliação e Benchmarking
7. Relatório Técnico e Citação do Merlion

Introdução

Merlion é uma biblioteca Python para inteligência de séries temporais. Ela fornece um framework de machine learning de ponta a ponta que inclui carregamento e transformação de dados, construção e treinamento de modelos, pós-processamento das saídas dos modelos e avaliação do desempenho dos modelos. Ela suporta várias tarefas de aprendizado de séries temporais, incluindo previsão (forecasting), detecção de anomalias e detecção de pontos de mudança para séries temporais univariadas e multivariadas. Esta biblioteca tem como objetivo fornecer a engenheiros e pesquisadores uma solução completa para desenvolver rapidamente modelos para suas necessidades específicas de séries temporais e compará-los em múltiplos conjuntos de dados de séries temporais.

Os principais recursos do Merlion são:

• Carregamento de dados e benchmarking padronizados e facilmente extensíveis para uma ampla variedade de conjuntos de dados de previsão e detecção de anomalias. Isso inclui suporte transparente para conjuntos de dados personalizados.
• Uma biblioteca de diversos modelos para detecção de anomalias, previsão e detecção de pontos de mudança, todos unificados sob uma interface compartilhada. Os modelos incluem métodos estatísticos clássicos, ensembles de árvores e abordagens de deep learning. Usuários avançados podem configurar totalmente cada modelo conforme desejarem.
• Modelos abstratos DefaultDetector e DefaultForecaster que são eficientes, alcançam consistentemente bom desempenho e fornecem um ponto de partida para novos usuários.
• AutoML para ajuste automatizado de hiperparâmetros e seleção de modelos.
• API unificada para usar uma ampla gama de modelos para prever com regressores exógenos.
• Regras práticas de pós-processamento inspiradas na indústria para detectores de anomalias, que tornam os escores de anomalia mais interpretáveis e também reduzem o número de falsos positivos.
• Ensembles fáceis de usar que combinam as saídas de múltiplos modelos para alcançar um desempenho mais robusto.
• Pipelines de avaliação flexíveis que simulam a implantação ao vivo e o retreinamento de um modelo em produção e avaliam o desempenho tanto na previsão quanto na detecção de anomalias.
• Suporte nativo para visualizar previsões de modelos, inclusive com uma interface visual clicável.
• Backend de computação distribuída usando PySpark, que pode ser usado para servir aplicações de séries temporais em escala industrial.

Comparação com Bibliotecas Relacionadas

A tabela abaixo fornece uma visão geral de como os principais recursos do Merlion se comparam a outras bibliotecas de detecção de anomalias e/ou previsão de séries temporais.

Os seguintes recursos são novos no Merlion 2.0:

Instalação

O Merlion consiste em dois sub-repositórios: merlion implementa os recursos centrais de inteligência de séries temporais da biblioteca, e ts_datasets fornece data loaders padronizados para múltiplos conjuntos de dados de séries temporais. Esses loaders carregam séries temporais como objetos pandas.DataFrame com metadados associados.

Você pode instalar o merlion a partir do PyPI executando pip install salesforce-merlion. Você pode instalar a partir do código-fonte clonando este repositório e executando pip install Merlion/, ou pip install -e Merlion/ para instalar em modo editável. Você pode instalar dependências adicionais via pip install salesforce-merlion[all], ou executando pip install "Merlion/[all]" se estiver instalando a partir do código-fonte. Individualmente, as dependências opcionais incluem dashboard para um painel GUI, spark para um backend de computação distribuída com PySpark e deep-learning para todos os modelos de deep learning.

Para instalar o pacote de carregamento de dados ts_datasets, clone este repositório e execute pip install -e Merlion/ts_datasets/. Este pacote deve ser instalado em modo editável (ou seja, com a flag -e) se você não quiser especificar manualmente o diretório raiz de cada conjunto de dados ao inicializar seu data loader.

Observe as seguintes dependências externas:

1. Alguns de nossos modelos de previsão dependem de OpenMP. Se estiver usando conda, execute conda install -c conda-forge lightgbm antes de instalar nosso pacote. Isso garantirá que o OpenMP esteja configurado para funcionar com o pacote lightgbm (uma de nossas dependências) no seu ambiente conda. Se estiver usando Mac, instale o Homebrew e execute brew install libomp para que a biblioteca OpenMP esteja disponível para o modelo.

2. Alguns de nossos modelos de detecção de anomalias dependem do Java Development Kit (JDK). Para Ubuntu, execute sudo apt-get install openjdk-11-jdk. Para Mac OS, instale o Homebrew e execute brew tap adoptopenjdk/openjdk && brew install --cask adoptopenjdk11. Certifique-se também de que java possa ser encontrado no seu PATH e que a variável de ambiente JAVA_HOME esteja definida.

Documentação

Para exemplos de código e uma introdução ao Merlion, consulte os notebooks Jupyter em examples e o passo a passo guiado aqui. Você pode encontrar documentação detalhada da API (incluindo os exemplos de código) aqui. O relatório técnico descreve a arquitetura geral do Merlion e apresenta resultados experimentais sobre detecção de anomalias e previsão de séries temporais, tanto para séries temporais univariadas quanto multivariadas.

Começando

A maneira mais fácil de começar é usar o dashboard web baseado em GUI. Esse dashboard fornece uma ótima maneira de experimentar rapidamente muitos modelos em seus próprios conjuntos de dados personalizados. Para usá-lo, instale o Merlion com a dependência opcional dashboard (ou seja, pip install salesforce-merlion[dashboard]) e execute python -m merlion.dashboard a partir da linha de comando. Você pode visualizar o dashboard em http://localhost:8050. Abaixo, mostramos algumas capturas de tela do dashboard para detecção de anomalias e previsão.

Para ajudar você a começar a usar o Merlion em seu próprio código, fornecemos abaixo alguns exemplos mínimos usando os modelos padrão do Merlion para detecção de anomalias e previsão.

Detecção de Anomalias

Aqui, mostramos o código para replicar os resultados do dashboard de detecção de anomalias acima. Começamos importando a classe TimeSeries do Merlion e o data loader para o Numenta Anomaly Benchmark NAB. Em seguida, podemos dividir uma série temporal específica desse conjunto de dados em divisões de treinamento e teste.

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

Podemos então inicializar e treinar o DefaultDetector do Merlion, que é um modelo de detecção de anomalias que equilibra desempenho com eficiência. Também obtemos suas previsões na divisão de teste.

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)

Em seguida, visualizamos as previsões do 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()

Por fim, podemos avaliar o modelo quantitativamente. A precisão e o recall vêm do fato de que o modelo disparou 3 alarmes, com 2 verdadeiros positivos, 1 falso negativo e 1 falso positivo. Também avaliamos o tempo médio que o modelo levou para detectar cada anomalia que detectou corretamente.

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

Previsão

Aqui, mostramos o código para replicar os resultados do dashboard de previsão acima. Começamos importando a classe TimeSeries do Merlion e o data loader para o conjunto de dados M4. Em seguida, podemos dividir uma série temporal específica desse conjunto de dados em divisões de treinamento e teste.

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

Podemos então inicializar e treinar o DefaultForecaster do Merlion, que é um modelo de previsão que equilibra desempenho com eficiência. Também obtemos suas previsões na divisão de teste.

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)

Em seguida, visualizamos as previsões do modelo.

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

Por fim, avaliamos o modelo quantitativamente. O sMAPE mede o erro da previsão em uma escala de 0 a 100 (quanto menor, melhor), enquanto o MSIS avalia a qualidade da banda de confiança de 95% em uma escala de 0 a 100 (quanto menor, melhor).

# 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

Avaliação e Benchmarking

Um dos principais recursos do Merlion é um pipeline de avaliação que simula a implantação ao vivo de um modelo em dados históricos. Isso permite comparar modelos nos conjuntos de dados relevantes para eles, sob as condições que podem encontrar em um ambiente de produção. Nosso pipeline de avaliação funciona da seguinte forma:

1. Treinar um modelo inicial em dados históricos de treinamento recentes (designados como a divisão de treinamento da série temporal)
2. Em um intervalo regular (por exemplo, uma vez por dia), retreinar o modelo inteiro com os dados mais recentes. Isso pode ser todo o histórico da série temporal ou uma janela mais limitada (por exemplo, 4 semanas).
3. Obter as previsões do modelo (escores de anomalia ou previsões) para os valores da série temporal que ocorrem entre os retreinamentos. Você pode personalizar se isso deve ser feito em lote (prevendo todos os valores de uma vez), em streaming (atualizando o estado interno do modelo após cada ponto de dados sem retreiná-lo completamente) ou em alguma cadência intermediária.
4. Comparar as previsões do modelo com a verdade absoluta (ground truth) (anomalias rotuladas para detecção de anomalias, ou os valores reais da série temporal para previsão) e relatar métricas de avaliação quantitativas.

Fornecemos scripts que permitem usar esse pipeline para avaliar modelos arbitrários em conjuntos de dados arbitrários. Por exemplo, executar

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

avaliará o desempenho de detecção de anomalias do IsolationForest (retreinado uma vez por dia) no subconjunto "realAWSCloudwatch" do conjunto de dados NAB. Da mesma forma, executar

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

avaliará o desempenho de previsão em lote (ou seja, sem retreinamento) do ETS no subconjunto "Hourly" do conjunto de dados M4. Você pode encontrar os resultados produzidos pela execução desses scripts na seção Experiments do relatório técnico.

Relatório Técnico e Citação do Merlion

Você pode encontrar mais detalhes em nosso relatório técnico: https://arxiv.org/abs/2109.09265

Se você estiver usando o Merlion em suas pesquisas ou aplicações, 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}
}

Tarefas Pendentes

Estamos nos dedicando a aproveitar a modelagem de séries temporais com GPUs para melhorar ainda mais a velocidade e a taxa de transferência do Merlion. Fique ligado ...