Open Source-Anomalieerkennung in Python

Problem Hintergrund: Ich arbeite an einem Projekt, das Protokolldateien umfasst, die denen im IT-Überwachungsbereich ähneln (nach meinem besten Verständnis des IT-Bereichs). Diese Protokolldateien sind Zeitreihendaten, die in Hunderten / Tausenden von Zeilen mit verschiedenen Parametern organisiert sind. Jeder Parameter ist numerisch (float) und es gibt einen nicht trivialen / fehlerfreien Wert für jeden Zeitpunkt. Meine Aufgabe ist es, diese Protokolldateien auf Anomalien zu überwachen (Spitzen, Stürze, ungewöhnliche Muster, bei denen einige Parameter nicht synchron sind, seltsames Verhalten der ersten / zweiten / usw. Ableitung usw.).

Bei einem ähnlichen Auftrag habe ich Splunk mit Prelert ausprobiert, aber ich untersuche derzeit Open-Source-Optionen.

Einschränkungen: Ich beschränke mich auf Python, weil ich es gut kenne, und möchte die Umstellung auf R und die damit verbundene Lernkurve verzögern. Sofern es keine überwältigende Unterstützung für R (oder andere Sprachen / Software) zu geben scheint, möchte ich mich bei dieser Aufgabe an Python halten.

Außerdem arbeite ich momentan in einer Windows-Umgebung. Ich möchte in Windows weiterhin mit kleinen Protokolldateien arbeiten, kann aber bei Bedarf auf eine Linux-Umgebung umsteigen.

Ressourcen: Ich habe Folgendes mit Sackgassen als Ergebnis überprüft:

1. Python oder R zur Implementierung maschineller Lernalgorithmen zur Betrugserkennung . Einige Informationen hier sind hilfreich, aber leider habe ich Probleme, das richtige Paket zu finden, weil:

2. Twitters "AnomalyDetection" ist in R und ich möchte mich an Python halten. Darüber hinaus scheint die Python-Port- Besonderheit Probleme bei der Implementierung in der Windows-Umgebung für mich zu verursachen.

3. Skyline, mein nächster Versuch, scheint ziemlich eingestellt worden zu sein (aufgrund von Github-Problemen ). Ich habe mich nicht eingehend damit befasst, da es anscheinend nur wenig Online-Support gibt.

4. scikit-learn erforsche ich noch, aber dies scheint viel mehr manuell zu sein. Der Down-in-the-Weeds-Ansatz ist für mich in Ordnung, aber mein Hintergrund in Bezug auf Lernwerkzeuge ist schwach. Daher hätte ich gerne eine Blackbox für technische Aspekte wie Algorithmen, ähnlich wie bei Splunk + Prelert.

Problemdefinition und Fragen: Ich suche Open-Source-Software, die mir bei der Automatisierung des Prozesses der Erkennung von Anomalien aus Zeitreihenprotokolldateien in Python über Pakete oder Bibliotheken helfen kann.

5. Gibt es solche Dinge, um meine unmittelbare Aufgabe zu unterstützen, oder sind sie in meinem Kopf imaginär?
6. Kann mir jemand bei konkreten Schritten helfen, um mein Ziel zu erreichen, einschließlich Hintergrundinformationen oder Konzepten?
7. Ist dies die beste StackExchange-Community, in der Sie nachfragen können, oder sind Statistik, Mathematik oder sogar Sicherheit oder Stapelüberlauf die besseren Optionen?

EDIT [2015.07.23] Beachten Sie, dass das neueste Update zu pyculiarity zu sein scheint festgelegt für die Windows - Umgebung! Ich muss noch bestätigen, sollte aber ein weiteres nützliches Werkzeug für die Community sein.

EDIT [2016-01-19] Ein kleines Update. Ich hatte keine Zeit, mich damit zu befassen und zu recherchieren, aber ich mache einen Schritt zurück, um die Grundlagen dieses Problems zu verstehen, bevor ich weiter in Einzelheiten recherchiere. Zum Beispiel sind zwei konkrete Schritte, die ich unternehme:

1. Beginnen Sie mit den Wikipedia-Artikeln zur Erkennung von Anomalien [ https://en.wikipedia.org/wiki/Anomaly_detection ], verstehen Sie alles und bewegen Sie sich dann in der Konzepthierarchie anderer verknüpfter Wikipedia-Artikel nach oben oder unten, z. B. [ https: // en.wikipedia.org/wiki/K-nearest_neighbors_algorithm ] und dann zu [ https://en.wikipedia.org/wiki/Machine_learning ].

2. Erkundungstechniken in den großartigen Umfragen von Chandola et al. 2009 "Anomaly Detection: A Survey" [ http://www-users.cs.umn.edu/~banerjee/papers/09/anomaly.pdf ] und Hodge et al. 2004 "Eine Übersicht über Methoden zur Erkennung von Ausreißern" [ http://eprints.whiterose.ac.uk/767/1/hodgevj4.pdf ].

Sobald die Konzepte besser verstanden sind (ich hoffe, bei der Entwicklung der praktischen Seite auch mit Spielzeugbeispielen herumzuspielen), hoffe ich zu verstehen, welche Open-Source-Python-Tools besser für meine Probleme geeignet sind.

Die Erkennung von Anomalien oder Ereignissen kann auf verschiedene Arten erfolgen:

Grundlegender Weg

Derivat! Wenn die Abweichung Ihres Signals von der Vergangenheit und Zukunft hoch ist, liegt höchstwahrscheinlich ein Ereignis vor. Dies kann extrahiert werden, indem große Nulldurchgänge in der Ableitung des Signals gefunden werden.

Statistischer Weg

Gemeint ist das übliche Grundverhalten. Wenn etwas von der Norm abweicht, bedeutet dies, dass es sich um ein Ereignis handelt. Bitte beachten Sie, dass der Mittelwert in Zeitreihen nicht so trivial ist und keine Konstante ist, sondern sich entsprechend den Änderungen in Zeitreihen ändert, sodass Sie den "gleitenden Durchschnitt" anstelle des Durchschnitts sehen müssen. Es sieht aus wie das:

Den Moving Average Code finden Sie hier . In der Signalverarbeitungsterminologie wenden Sie einen " Tiefpass " -Filter an, indem Sie den gleitenden Durchschnitt anwenden.

Sie können dem folgenden Code folgen:

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

Probabilistischer Weg

Sie sind speziell für Menschen, die noch nicht mit maschinellem Lernen vertraut sind, anspruchsvoller. Kalman Filter ist eine großartige Idee, um die Anomalien zu finden . Einfachere probabilistische Ansätze mit "Maximum-Likelihood Estimation" funktionieren ebenfalls gut, aber mein Vorschlag ist, bei der Idee des gleitenden Durchschnitts zu bleiben. Das funktioniert in der Praxis sehr gut.

Ich hoffe ich konnte helfen :) Viel Glück!

h2o hat ein Anomalieerkennungsmodul und traditionell ist der Code in R verfügbar. Ab Version 3 ist jedoch auch ein ähnliches Modul in Python verfügbar, und da h2o Open Source ist, passt es möglicherweise zu Ihrer Rechnung.

Ein funktionierendes Beispiel finden Sie hier

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)

Ich entwickelte kürzlich eine Toolbox: Py thon O utlier D etection Toolbox ( PyOD ). Siehe GitHub .

Es dient zum Identifizieren von Objekten in Daten mit unbeaufsichtigten und überwachten Ansätzen. PyOD ist verfügbar für:

• Einheitliche APIs, detaillierte Dokumentation und interaktive Beispiele für verschiedene Algorithmen.
• Fortgeschrittene Modelle, einschließlich neuronaler Netze / Deep Learning und Outlier Ensembles.
• Optimierte Leistung mit JIT und Parallelisierung, wenn möglich, unter Verwendung von numba und joblib. Kompatibel mit Python 2 und 3 (auch mit Scikit-Learn kompatibel).

Hier sind einige wichtige Links:

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

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

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

• Interaktive Jupyter-Notizbücher : https://mybinder.org/v2/gh/yzhao062/Pyod/master

Wenn Sie PyOD in einer wissenschaftlichen Publikation verwenden, würden wir uns über Zitate zu dem folgenden Artikel freuen

@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}
}

Es wird derzeit bei JMLR (Machine Learning Open Source Software Track) geprüft . Siehe Vorabdruck .

Schnelle Einführung

Das PyOD-Toolkit besteht aus drei Hauptfunktionalitätsgruppen: (i) Algorithmen zur Erkennung von Ausreißern; (ii) Ausreißer-Ensemble-Frameworks und (iii) Dienstprogrammfunktionen zur Erkennung von Ausreißern.

Individuelle Erkennungsalgorithmen :

• PCA : Principal Component Analysis (die Summe der gewichteten projizierten Abstände zu den Eigenvektor-Hyperebenen)
• MCD : Minimum Covariance Determinant (verwenden Sie die Mahalanobis-Abstände als Ausreißer-Scores)
• OCSVM : Vektorcomputer mit erstklassiger Unterstützung
• LOF : Lokaler Ausreißerfaktor
• CBLOF : Clusterbasierter lokaler Ausreißerfaktor
• LOCI : LOCI: Schnelle Erkennung von Ausreißern mithilfe des lokalen Korrelationsintegrals
• HBOS : Histogrammbasierter Ausreißer-Score
• kNN : k Nächste Nachbarn (Verwenden Sie die Entfernung zum k-ten nächsten Nachbarn als - ** Ausreißer-Punktzahl
• AvgKNN : Average kNN (Verwenden Sie die durchschnittliche Entfernung zu k nächsten Nachbarn als Ausreißer-Punktzahl)
• MedKNN : Median kNN (Verwenden Sie den Medianabstand zu k nächsten Nachbarn als Ausreißer-Punktzahl)
• ABOD : Winkelbasierte Ausreißererkennung
• FastABOD : Schnelle winkelbasierte Ausreißererkennung mittels Approximation
• SOS : Stochastische Ausreißerauswahl
• IForest : Isolationswald
• Feature Absacken
• LSCP : LSCP: Lokal selektive Kombination paralleler Ausreißer-Ensembles
• XGBOD : Extreme Boosting-basierte Ausreißererkennung (überwacht)
• AutoEncoder : Vollständig verbundener AutoEncoder (verwenden Sie den Rekonstruktionsfehler als Ausreißer-Punktzahl)
• SO_GAAL : Single-Objective-Generative-Adversarial-Active-Learning
• MO_GAAL : Multiple-Objective-Generative-Adversarial-Active-Learning

Ausreißerdetektor / Scores-Kombinations-Frameworks :

• Feature Absacken
• LSCP : LSCP: Lokal selektive Kombination paralleler Ausreißer-Ensembles
• Durchschnitt : Einfache Kombination durch die Partituren von durchschnittlich
• Gewichteter Durchschnitt : Einfache Kombination durch Mittelung der Punktzahlen mit Detektorgewichten
• Maximierung : Einfache Kombination durch Ermitteln der maximalen Punktzahl
• AOM : Durchschnitt des Maximums
• MOA : Maximierung des Durchschnitts

Hilfsprogrammfunktionen zur Erkennung von Ausreißern :

1. score_to_lable (): Konvertiert rohe Ausreißer-Scores in binäre Bezeichnungen
2. precision_n_scores (): Eine der beliebtesten Bewertungsmetriken für das Ausreißer-Mining (precision @ rank n)
3. generate_data (): Generiert Pseudodaten für ein Ausreißererkennungsexperiment
4. wpearsonr (): gewichteter Pearson ist nützlich bei der Erzeugung von Pseudo-Grundwahrheiten

Ein Vergleich aller implementierten Modelle wird nachfolgend zur Verfügung gestellt: ( Abbildung , Code , Jupyter Notebooks ):

Wenn Sie interessiert sind, überprüfen Sie bitte Github ( https://github.com/yzhao062/Pyod ) für weitere Informationen.

Ich bin derzeit auf der gleichen Bühne wie Sie. Ich finde die beste Option für die Erkennung von Anomalien und mache Nachforschungen.

Was ich gefunden habe, ist, dass ich denke, dass es am besten zu Ihrem Bedarf passt und besser mit dem vergleichbar ist, was Sie gesehen haben. dh TwitterAnomalyDetection, SkyLine.

Ich habe festgestellt, dass Numentas NAB (Numenta Anomaly Benchmark) besser ist. Es hat auch eine sehr gute Community-Unterstützung und für Sie ist Pluspunkt seine Open Source & in Python entwickelt. Sie können Ihren Algorithmus hinzufügen.

Im Falle eines Algorithmus fand ich, dass LOF oder CBLOF eine gute Option sind.

Probieren Sie es einmal aus. Es kann Ihnen helfen. https://github.com/numenta/nab

Wenn Sie eine bessere Option finden. Erzähl es mir bitte. Ich bin auch auf dem gleichen Weg.

Bestes Glück!!

Vielleicht hilft das, weil Sie über den eingeschwungenen Zustand gesprochen haben: https://github.com/twitter/AnomalyDetection

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

Ich gehe davon aus, dass die Funktion, die Sie zum Erkennen von Abnormalitäten verwenden, eine Datenzeile in einer Protokolldatei ist. In diesem Fall ist Sklearn Ihr guter Freund und Sie können es als Blackbox verwenden. Lesen Sie das Tutorial zur SVM- und Neuheitserkennung für eine Klasse .

Wenn es sich bei Ihrer Funktion jedoch um eine vollständige Protokolldatei handelt, müssen Sie diese zunächst zu einer Funktion derselben Dimension zusammenfassen und dann die Novealty-Erkennung anwenden.

Es gibt immer noch eine aktive und entwickelte Version von Skyline, für den Fall, dass jemand hier landet und interessiert ist.

https://github.com/earthgecko/skyline

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

Ich bin der derzeitige Projektbetreuer und es ist jetzt viel weiter fortgeschritten als die ursprüngliche Etsy-Version, was Leistung, Benutzeroberfläche, besseren Umgang mit der Saisonalität und die zusätzlichen Funktionen einer Anomaliedatenbank, die Berechnung von Korrelationen und die Möglichkeit des Fingerabdrucks anbelangt und lernen nicht anomale Muster.

Da Sie über multivariate Zeitreihen verfügen, würde ich eine LSTM-RNN-Implementierung wählen, die die Dynamik Ihres Systems anhand von Trainingsdaten modelliert, die in der Regel halbüberwacht sind (nur normale Klassen eingeschlossen). Dies bedeutet, dass Sie Ihr Modell trainieren, um zu lernen, was "normal" ist. Während des Tests testen Sie sowohl normale als auch anomale Bedingungen, um festzustellen, wie gut das Modell sie voneinander unterscheidet.

Ein Vorteil neuronaler Netze besteht darin, dass sie die Kreuzkorrelationen zwischen Eingangssignalen selbst "lernen". Sie müssen sie nicht manuell durchsuchen. Insbesondere LSTM-RNNs sind eine ideale Wahl, wenn es um die Modellierung von Zeitreihen geht, da sie ähnlich wie ein Zustandsraummodell in der Steuerungstheorie (wenn Sie die Analogie sehen) die Möglichkeit bieten, die Erinnerung an frühere Eingaben zu behalten.

In Python ist es fast trivial, ein LSTM-RNN mithilfe der Keras- API (zusätzlich zum Tensorflow-Backend) zu implementieren . Dieses Netzwerk lernt, das / die interessierende (n) Signal (e) bei einer beliebigen Anzahl von Eingängen zu schätzen, die Sie anschließend mit dem tatsächlichen Messwert vergleichen. Wenn es eine "große" Abweichung gibt, haben Sie eine Anomalie (vorausgesetzt, das Modell ist genau genug)!