Rilevazione di anomalie open source in Python

Contesto del problema: sto lavorando a un progetto che prevede file di registro simili a quelli presenti nello spazio di monitoraggio IT (per la mia migliore comprensione dello spazio IT). Questi file di registro sono dati di serie temporali, organizzati in centinaia / migliaia di righe di vari parametri. Ogni parametro è numerico (float) e esiste un valore non banale / non errore per ogni punto temporale. Il mio compito è monitorare i suddetti file di registro per il rilevamento di anomalie (picchi, cadute, schemi insoliti con alcuni parametri non sincronizzati, strano comportamento derivato 1 ° / 2 ° / ecc., Ecc.).

Su un incarico simile, ho provato Splunk con Prelert, ma al momento sto esplorando le opzioni open source.

Vincoli: mi sto limitando a Python perché lo conosco bene e vorrei ritardare il passaggio a R e la curva di apprendimento associata. A meno che non sembri esserci un supporto schiacciante per R (o altri linguaggi / software), vorrei attenermi a Python per questo compito.

Inoltre, sto lavorando in un ambiente Windows per il momento. Vorrei continuare a sandbox in Windows su file di registro di piccole dimensioni ma, se necessario, posso passare all'ambiente Linux.

Risorse: ho verificato quanto segue con i vicoli ciechi:

1. Python o R per l'implementazione di algoritmi di machine learning per il rilevamento di frodi . Alcune informazioni qui sono utili, ma sfortunatamente, faccio fatica a trovare il pacchetto giusto perché:

2. "AnomalyDetection" di Twitter è in R e voglio attenermi a Python. Inoltre, la ciclicità della porta Python sembra causare problemi nell'implementazione in ambiente Windows per me.

3. Skyline, il mio prossimo tentativo, sembra essere stato praticamente interrotto (da problemi di github ). Non mi sono tuffato in profondità in questo, dato quanto poco supporto sembra esserci online.

4. scikit-learn Sto ancora esplorando, ma questo sembra essere molto più manuale. L'approccio down-in-the-weeds è OK per me, ma il mio background negli strumenti di apprendimento è debole, quindi vorrei qualcosa come una scatola nera per gli aspetti tecnici come gli algoritmi, simile a Splunk + Prelert.

Definizione del problema e domande: sto cercando un software open source che possa aiutarmi ad automatizzare il processo di rilevamento delle anomalie dai file di registro delle serie temporali in Python tramite pacchetti o librerie.

5. Esistono cose del genere che mi aiutano nel mio compito immediato o sono immaginarie nella mia mente?
6. Qualcuno può aiutarmi con passi concreti per aiutarmi a raggiungere il mio obiettivo, inclusi concetti o concetti di base?
7. È la migliore community di StackExchange a cui rivolgersi o Stat, Math o persino Security o Stackoverflow sono le opzioni migliori?

EDIT [23-07-2015] Si noti che l'ultimo aggiornamento alla ciculiarità sembra essere stato risolto per l'ambiente Windows! Devo ancora confermare, ma dovrebbe essere un altro strumento utile per la comunità.

EDIT [19-01-2016] Un aggiornamento minore. Non ho avuto il tempo di lavorare su questo e sulla ricerca, ma sto facendo un passo indietro per capire i fondamenti di questo problema prima di continuare a ricercare in dettagli specifici. Ad esempio, due passi concreti che sto prendendo sono:

1. A partire dagli articoli di Wikipedia per il rilevamento di anomalie [ https://en.wikipedia.org/wiki/Anomaly_detection ], comprendendo appieno e quindi spostandosi verso l'alto o verso il basso nella gerarchia dei concetti di altri articoli di Wikipedia collegati, come [ https: // en.wikipedia.org/wiki/K-nearest_neighbors_algorithm ], quindi su [ https://en.wikipedia.org/wiki/Machine_learning ].

2. Esplorazione delle tecniche nei grandi sondaggi condotti da Chandola et al 2009 "Anomaly Detection: A Survey" [ http://www-users.cs.umn.edu/~banerjee/papers/09/anomaly.pdf ] e Hodge et al 2004 "Un sondaggio sulle metodologie di rilevamento anomalo" [ http://eprints.whiterose.ac.uk/767/1/hodgevj4.pdf ].

Una volta che i concetti saranno meglio compresi (spero di giocare con esempi di giocattoli mentre vado a sviluppare anche il lato pratico), spero di capire quali strumenti Python open source sono più adatti ai miei problemi.

Anomaly Detection o Event Detection può essere eseguito in diversi modi:

Modo base

Derivato! Se la deviazione del segnale dal suo passato e futuro è elevata, molto probabilmente hai un evento. Questo può essere estratto trovando grandi incroci di zero in derivata del segnale.

Modo statistico

Media di tutto è il suo solito, comportamento di base. se qualcosa si discosta dalla media significa che è un evento. Si noti che la media nelle serie temporali non è così banale e non è una costante, ma cambia in base ai cambiamenti nelle serie storiche, quindi è necessario vedere la "media mobile" anziché la media. Sembra così:

Il codice della media mobile è disponibile qui . Nella terminologia di elaborazione del segnale si applica un filtro "passa-basso" applicando la media mobile.

Puoi seguire il seguente codice:

MOV = movingaverage(TimeSEries,5).tolist()
STD = np.std(MOV)
events= []
ind = []
for ii in range(len(TimeSEries)):
    if TimeSEries[ii] > MOV[ii]+STD:
        events.append(TimeSEries[ii])

Modo probabilistico

Sono più sofisticati specialmente per le persone che non conoscono Machine Learning. Kalman Filter è un'ottima idea per trovare le anomalie . Anche gli approcci probabilistici più semplici che utilizzano la "stima della massima verosimiglianza" funzionano bene, ma il mio suggerimento è di rimanere con un'idea media mobile. Funziona molto bene in pratica.

Spero di poterti aiutare :) Buona fortuna!

h2o ha un modulo di rilevamento delle anomalie e tradizionalmente il codice è disponibile in R. Tuttavia, oltre alla versione 3, ha un modulo simile disponibile anche in Python, e poiché h2o è open source potrebbe adattarsi al conto.

Puoi vedere un esempio funzionante qui

import sys
sys.path.insert(1,"../../../")
import h2o

def anomaly(ip, port):
    h2o.init(ip, port)

    print "Deep Learning Anomaly Detection MNIST"

    train = h2o.import_frame(h2o.locate("bigdata/laptop/mnist/train.csv.gz"))
    test = h2o.import_frame(h2o.locate("bigdata/laptop/mnist/test.csv.gz"))

    predictors = range(0,784)
    resp = 784

    # unsupervised -> drop the response column (digit: 0-9)
    train = train[predictors]
    test = test[predictors]

    # 1) LEARN WHAT'S NORMAL
    # train unsupervised Deep Learning autoencoder model on train_hex
    ae_model = h2o.deeplearning(x=train[predictors], training_frame=train, activation="Tanh", autoencoder=True,
                                hidden=[50], l1=1e-5, ignore_const_cols=False, epochs=1)

    # 2) DETECT OUTLIERS
    # anomaly app computes the per-row reconstruction error for the test data set
    # (passing it through the autoencoder model and computing mean square error (MSE) for each row)
    test_rec_error = ae_model.anomaly(test)

    # 3) VISUALIZE OUTLIERS
    # Let's look at the test set points with low/median/high reconstruction errors.
    # We will now visualize the original test set points and their reconstructions obtained
    # by propagating them through the narrow neural net.

    # Convert the test data into its autoencoded representation (pass through narrow neural net)
    test_recon = ae_model.predict(test)

    # In python, the visualization could be done with tools like numpy/matplotlib or numpy/PIL

if __name__ == '__main__':
    h2o.run_test(sys.argv, anomaly)

Di recente ho sviluppato una cassetta degli attrezzi: Py thon O utlier D etection toolbox ( PyOD ). Vedi GitHub .

È progettato per identificare oggetti periferici nei dati con approcci sia non supervisionati che supervisionati. PyOD è descritto per:

• API unificate, documentazione dettagliata ed esempi interattivi attraverso vari algoritmi.
• Modelli avanzati, tra cui reti neurali / deep learning e complessi anomali.
• Prestazioni ottimizzate con JIT e parallelizzazione quando possibile, usando numba e joblib. Compatibile con Python 2 e 3 (compatibile anche con scikit-learn).

Ecco alcuni link importanti:

• Github : https://github.com/yzhao062/Pyod

• PyPI : https://pypi.org/project/pyod/

• Documentazione : https://pyod.readthedocs.io

• Notebook interattivi Jupyter : https://mybinder.org/v2/gh/yzhao062/Pyod/master

Se usi PyOD in una pubblicazione scientifica, apprezzeremmo citazioni al seguente documento

@article{zhao2019pyod,
  title={PyOD: A Python Toolbox for Scalable Outlier Detection},
  author={Zhao, Yue and Nasrullah, Zain and Li, Zheng},
  journal={arXiv preprint arXiv:1901.01588},
  year={2019},
  url={https://arxiv.org/abs/1901.01588}
}

È attualmente in fase di revisione presso JMLR (traccia software open source di apprendimento automatico). Vedi prestampa .

Introduzione veloce

Il toolkit PyOD è costituito da tre gruppi principali di funzionalità: (i) algoritmi di rilevamento anomali; (ii) strutture di insiemi anomali e (iii) funzioni di utilità di rilevazione anomale.

Algoritmi di rilevamento individuali :

• PCA : Analisi dei componenti principali (la somma delle distanze proiettate ponderate rispetto agli iperpiani autovettori)
• MCD : Determinante minimo di covarianza (utilizzare le distanze mahalanobis come punteggi anomali)
• OCSVM : Macchine vettoriali di supporto di una classe
• LOF : fattore anomalo locale
• CBLOF : fattore anomalo locale basato sul cluster
• LOCI : LOCI: rilevamento veloce anomalo utilizzando l'integrale di correlazione locale
• HBOS : punteggio anomalo basato sull'istogramma
• kNN : k Vicini vicini più vicini (utilizzare la distanza dal kth vicino più vicino come punteggio esterno **
• AvgKNN : kNN medio (utilizzare la distanza media per i k vicini più vicini come punteggio anomalo)
• MedKNN : kNN mediano (utilizzare la distanza mediana per k i vicini più vicini come punteggio anomalo)
• ABOD : Rilevamento anomalo basato sull'angolo
• FastABOD : Rilevamento anomalo rapido ad angolo basato sull'approssimazione
• SOS : selezione anomala stocastica
• IForest : Foresta di isolamento
• Insaccamento delle funzioni
• LSCP : LSCP: combinazione selettiva a livello locale di insiemi anomali paralleli
• XGBOD : Extreme Boosting Based Outlier Detection (supervisionato)
• AutoEncoder : AutoEncoder completamente collegato (utilizzare l'errore di ricostruzione come punteggio anomalo)
• SO_GAAL : apprendimento attivo contraddittorio generativo a singolo obiettivo
• MO_GAAL : apprendimento attivo contraddittorio generativo a più obiettivi

Strutture di combinazione di rivelatori / punteggi anomali :

• Insaccamento delle funzioni
• LSCP : LSCP: combinazione selettiva a livello locale di insiemi anomali paralleli
• Media : combinazione semplice calcolando la media dei punteggi
• Media ponderata : combinazione semplice calcolando la media dei punteggi con i pesi del rivelatore
• Massimizzazione : combinazione semplice prendendo i punteggi massimi
• AOM : media del massimo
• MOA : Massimizzazione della media

Funzioni di utilità per il rilevamento anomalo :

1. score_to_lable (): converte i punteggi errati grezzi in etichette binarie
2. precision_n_scores (): una delle metriche di valutazione più diffuse per il mining anomalo (precision @ rank n)
3. generate_data (): genera pseudo dati per esperimento di rilevamento anomalo
4. wpearsonr (): ponderato pearson è utile nella generazione di verità pseudo-fondali

Il confronto di tutti i modelli implementati è reso disponibile di seguito: ( Figura , Codice , Notebook di Jupyter ):

Se sei interessato, controlla Github ( https://github.com/yzhao062/Pyod ) per ulteriori informazioni.

Attualmente sono sullo stesso palco come te. Sto trovando la migliore opzione per il rilevamento di anomalie, facendo qualche ricerca.

Quello che ho trovato è che penso corrisponda meglio alle tue esigenze ed è meglio confrontarlo con quello che hai visto. ad esempio TwitterAnomalyDetection, SkyLine.

Ho trovato di meglio è il NAB di Numenta (Numenta Anomaly Benchmark). Ha anche un ottimo supporto per la comunità e per te il punto in più è il suo open source e sviluppato in Python. Puoi aggiungere il tuo algoritmo in esso.

In caso di algoritmo, ho scoperto che LOF o CBLOF sono una buona opzione.

quindi, dai un'occhiata una volta. Potrebbe aiutarti. https://github.com/numenta/nab

Se trovi l'opzione migliore. dimmelo, ti prego. Sono anche sullo stesso percorso.

Buona fortuna!!

Forse questo aiuta a farti menzionare degli stati stazionari: https://github.com/twitter/AnomalyDetection

https://blog.twitter.com/2015/introducing-practical-and-robust-anomaly-detection-in-a-time-series

Presumo che la funzionalità utilizzata per rilevare l'anomalia sia una riga di dati in un file di registro. Se è così, Sklearn è il tuo buon amico e puoi usarlo come blackbox. Controlla il tutorial sul rilevamento SVM di una classe e Novità .

Tuttavia, nel caso in cui la tua funzionalità sia un intero file di log, devi prima riassumere in una funzionalità della stessa dimensione, quindi applicare il rilevamento Novealty.

Esiste ancora una versione attiva e sviluppata di Skyline, nel caso in cui qualcuno arrivi qui e sia interessato.

https://github.com/earthgecko/skyline

https://earthgecko-skyline.readthedocs.io/en/latest

Sono l'attuale manutentore del progetto e ora è molto più avanzato rispetto alla versione originale di Etsy, in termini di prestazioni, interfaccia utente, migliore gestione della stagionalità e ha le funzionalità aggiuntive di un database di anomalie, calcolo delle correlazioni e capacità di impronte digitali e apprendere schemi non anomali.

Dato che hai serie temporali multivariate, sceglierei un'implementazione LSTM-RNN che modella le dinamiche del tuo sistema in base ai dati di addestramento, che di solito sono semi supervisionati (inclusa solo la classe normale). Ciò significa che ti alleni il tuo modello per imparare ciò che è "normale". Durante il test, si verificano sia condizioni normali che anomale per vedere quanto bene il modello li distingue.

Un vantaggio delle reti neurali è che "apprendono" da soli le correlazioni incrociate tra segnali di input; non è necessario esplorarli manualmente. Gli LSTM-RNN, in particolare, sono la scelta ideale quando si tratta di modellare serie temporali semplicemente per la loro capacità di conservare la memoria degli input precedenti, simile a un modello dello spazio degli stati in Control Theory (se vedi l'analogia).

In Python, è quasi banale implementare un LSTM-RNN usando l' API di Keras (in cima al backend di Tensorflow). Questa rete impara a stimare il / i segnale / i di interesse dato un numero arbitrario di ingressi, che successivamente si confronta con il valore misurato effettivo. Se c'è una deviazione "grande", hai un'anomalia (dato che il modello è abbastanza preciso)!