Détection d'anomalies open source en Python

Problème: Je travaille sur un projet qui implique des fichiers journaux similaires à ceux trouvés dans l'espace de surveillance informatique (à ma meilleure compréhension de l'espace informatique). Ces fichiers journaux sont des données chronologiques organisées en centaines / milliers de lignes de paramètres variés. Chaque paramètre est numérique (float) et il existe une valeur non triviale / non-erreur pour chaque point de temps. Ma tâche consiste à surveiller les fichiers journaux pour détecter les anomalies (pics, chutes, modèles inhabituels avec certains paramètres désynchronisés, comportement étrange des dérivées 1er / 2e / etc., etc.).

Sur une mission similaire, j'ai essayé Splunk avec Prelert, mais j'explore actuellement les options open source.

Contraintes: Je me limite à Python parce que je le connais bien et que je voudrais retarder le passage à R et à la courbe d’apprentissage associée. À moins que le support de R (ou des autres langages / logiciels) ne semble pas être supporté de manière écrasante, je voudrais m'en tenir à Python pour cette tâche.

De plus, je travaille dans un environnement Windows pour le moment. Je souhaite continuer à utiliser Sandbox sous Windows sur des fichiers journaux de petite taille, mais je peux également passer à l'environnement Linux si nécessaire.

Ressources: J'ai vérifié ce qui suit avec comme résultat des impasses:

1. Python ou R pour implémenter des algorithmes d’apprentissage automatique pour la détection des fraudes . Certaines informations ici sont utiles, mais malheureusement, j'ai du mal à trouver le bon forfait pour les raisons suivantes:

2. "AnomalyDetection" de Twitter est dans R, et je veux m'en tenir à Python. De plus, la pyculiarité de port Python semble poser des problèmes d’implémentation dans l’environnement Windows.

3. Skyline, ma prochaine tentative, semble avoir été à peu près interrompue (à partir de problèmes de github ). Je n'ai pas approfondi cette question, compte tenu du peu de soutien qui semble être disponible en ligne.

4. scikit-learn je suis toujours en train d'explorer, mais cela semble être beaucoup plus manuel. L’approche «dans les mauvaises herbes» me convient, mais mon niveau d’apprentissage des outils d’apprentissage est faible. Par conséquent, je souhaiterais avoir une sorte de boîte noire pour les aspects techniques tels que les algorithmes, similaires à Splunk + Prelert.

Définition du problème et questions: Je recherche un logiciel open source pouvant m'aider à automatiser le processus de détection des anomalies à partir de fichiers journaux de séries chronologiques en Python via des packages ou des bibliothèques.

5. De telles choses existent-elles pour m'aider dans ma tâche immédiate ou sont-elles imaginaires dans mon esprit?
6. Quelqu'un peut-il m'aider à prendre des mesures concrètes pour m'aider à atteindre mon objectif, y compris des notions de base ou des concepts de base?
7. S'agit-il de la meilleure communauté StackExchange à utiliser, ou bien Stats, Math, ou même Security ou Stackoverflow, sont-ils les meilleures options?

EDIT [2015-07-23] Notez que la dernière mise à jour de pyculiarity semble être corrigée pour l'environnement Windows! Je n'ai pas encore confirmé, mais cela devrait être un autre outil utile pour la communauté.

EDIT [2016-01-19] Une mise à jour mineure. Je n’ai pas eu le temps de travailler là-dessus et de faire de la recherche, mais j’ai pris du recul pour comprendre les fondements de ce problème avant de poursuivre mes recherches dans des détails spécifiques. Par exemple, je prends deux mesures concrètes:

1. Commençons par les articles de Wikipédia pour la détection des anomalies [ https://en.wikipedia.org/wiki/Anomaly_detection ], en comprenant parfaitement, puis en remontant ou en descendant dans la hiérarchie des concepts d’autres articles liés de Wikipedia, tels que [ https: // en.wikipedia.org/wiki/K-nearest_neighbors_algorithm ], puis sur [ https://en.wikipedia.org/wiki/Machine_learning ].

2. Techniques d'exploration dans les grandes enquêtes réalisées par Chandola et al. 2009 "Anomaly Detection: A Survey" [ http://www-users.cs.umn.edu/~banerjee/papers/09/anomaly.pdf ] et Hodge et al 2004 "Enquête sur les méthodes de détection des valeurs aberrantes" [ http://eprints.whiterose.ac.uk/767/1/hodgevj4.pdf ].

Une fois que les concepts sont mieux compris (j'espère jouer avec des exemples de jouets au fur et à mesure que je développe également l'aspect pratique), j'espère comprendre quels outils Python Open Source sont mieux adaptés à mes problèmes.

La détection d'anomalies ou la détection d'événements peuvent être effectuées de différentes manières:

Manière basique

Dérivé! Si l'écart de votre signal par rapport à son passé et à son avenir est élevé, vous avez probablement un événement. Ceci peut être extrait en trouvant des passages par zéro importants en dérivée du signal.

Voie statistique

La moyenne de tout est son comportement habituel, de base. si quelque chose s'écarte de méchant, cela signifie que c'est un événement. Veuillez noter que la moyenne dans les séries chronologiques n’est pas si triviale et n’est pas une constante mais qu’elle change en fonction des changements dans les séries chronologiques, vous devez donc voir la "moyenne mobile" au lieu de la moyenne. Cela ressemble à ceci:

Le code de la moyenne mobile peut être trouvé ici . Dans la terminologie du traitement du signal, vous appliquez un filtre "passe-bas" en appliquant la moyenne mobile.

Vous pouvez suivre le code ci-dessous:

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

Manière probabiliste

Ils sont plus sophistiqués, spécialement pour les débutants en Machine Learning. Kalman Filter est une excellente idée pour trouver les anomalies . Les approches probabilistes plus simples utilisant «l'estimation du maximum de vraisemblance» fonctionnent également bien, mais je suggère de rester avec l'idée de moyenne mobile. Cela fonctionne très bien dans la pratique.

J'espère que je pourrais aider :) Bonne chance!

H2O possède un module de détection des anomalies et, traditionnellement, le code est disponible en version R. Cependant, au-delà de la version 3, il dispose également d'un module similaire en python. De plus, h2o étant un logiciel libre, il pourrait correspondre à vos factures.

Vous pouvez voir un exemple de travail ici

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)

J'ai récemment développé une boîte à outils: Py thon O utlier D etection Toolbox ( PyOD ). Voir GitHub .

Il est conçu pour identifier les objets périphériques dans les données avec des approches supervisées et non supervisées. PyOD est présenté pour:

• API unifiées, documentation détaillée et exemples interactifs à travers différents algorithmes.
• Modèles avancés, y compris réseaux de neurones / apprentissage en profondeur et ensembles de valeurs aberrantes.
• Performances optimisées avec JIT et parallélisation si possible, en utilisant numba et joblib. Compatible à la fois avec Python 2 et 3 (également compatible avec scikit-learn).

Voici quelques liens importants:

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

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

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

• Cahiers interactifs Jupyter : https://mybinder.org/v2/gh/yzhao062/Pyod/master

Si vous utilisez PyOD dans une publication scientifique, nous vous serions reconnaissants de citer le texte suivant.

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

Il est actuellement à l’étude chez JMLR (logiciel d’apprentissage automatique à code source ouvert). Voir préimpression .

Introduction rapide

La boîte à outils PyOD comprend trois groupes principaux de fonctionnalités: (i) algorithmes de détection des valeurs aberrantes; (ii) des cadres d'ensemble aberrants et (iii) des fonctions utilitaires de détection des aberrations.

Algorithmes de détection individuels :

• PCA : Analyse en composantes principales (somme des distances projetées pondérées aux hyperplans de vecteurs propres)
• MCD : Détermination de la covariance minimale (utiliser les distances de mahalanobis comme scores aberrants)
• OCSVM : Machines à vecteurs de support à une classe
• LOF : facteur local aberrant
• CBLOF : facteur de valeur aberrante locale basé sur le clustering
• LOCI : LOCI: détection rapide des valeurs aberrantes à l'aide de l'intégrale de corrélation locale
• HBOS : Score des valeurs aberrantes basé sur un histogramme
• kNN : k voisins les plus proches (utilisez la distance au kième voisin le plus proche comme score - ** aberrant
• RNA moyen: Moyenne kNN (utilisez la distance moyenne par rapport à k voisins les plus proches comme score aberrant)
• MedKNN : kNN médian (utilisez la distance médiane à k voisins les plus proches comme score aberrant)
• ABOD : Détection des valeurs aberrantes basée sur l'angle
• FastABOD : Détection rapide de valeurs aberrantes basée sur l'angle selon approximation
• SOS : Sélection de valeurs aberrantes stochastiques
• IForest : Forêt d'isolement
• Mise en sac
• LSCP : LSCP: Combinaison localement sélective d'ensembles de valeurs aberrantes parallèles
• XGBOD : Détection des valeurs aberrantes basée sur un renforcement extrême (supervisée)
• AutoEncoder : AutoEncoder entièrement connecté (utilisez l'erreur de reconstruction comme score aberrant)
• SO_GAAL : Apprentissage actif de l'adversaire génératif à objectif unique
• MO_GAAL : Apprentissage actif de l'adversaire génératif à objectifs multiples

Combinaison de détecteurs de valeurs aberrantes et de partitions :

• Mise en sac
• LSCP : LSCP: Combinaison localement sélective d'ensembles de valeurs aberrantes parallèles
• Moyenne : combinaison simple en faisant la moyenne des scores
• Moyenne pondérée : combinaison simple en faisant la moyenne des scores avec les poids du détecteur
• Maximisation : combinaison simple en prenant les scores maximum
• AOM : moyenne du maximum
• MOA : Maximisation de la moyenne

Fonctions utilitaires pour la détection des valeurs aberrantes :

1. score_to_lable (): convertir les scores bruts en valeurs aberrantes en étiquettes binaires
2. precision_n_scores (): l'un des indicateurs d'évaluation les plus populaires pour l'extraction de valeurs aberrantes (precision @ rang n)
3. generate_data (): génère des pseudo données pour une expérience de détection de valeurs aberrantes
4. wpearsonr (): pearson pondéré est utile dans la génération de pseudo-vérités sur le terrain

La comparaison de tous les modèles mis en œuvre est disponible ci-dessous: ( Figure , Code , Jupyter Notebooks ):

Si vous êtes intéressé, veuillez consulter Github ( https://github.com/yzhao062/Pyod ) pour plus d'informations.

Je suis actuellement sur la même scène que toi. Je trouve la meilleure option pour la détection des anomalies, en effectuant des recherches.

Ce que j’ai trouvé, c’est que je pense que cela correspond le mieux à vos besoins et qu’il vaut mieux le comparer. c'est-à-dire TwitterAnomalyDetection, SkyLine.

J'ai trouvé mieux le NAB (Benchmark Anomaly Benchmark) de Numenta. Il a également un très bon support de la communauté et pour vous le point positif est son source ouverte et développé en python. Vous pouvez y ajouter votre algorithme.

En cas d'algorithme, j'ai trouvé que LOF ou CBLOF sont une bonne option.

alors, vérifiez une fois. Cela peut vous aider. https://github.com/numenta/nab

Si vous trouvez la meilleure option. s'il vous plaît dites-moi. Je suis aussi sur le même chemin.

Bonne chance !!

Peut-être que cela aide parce que vous avez mentionné les états stables: https://github.com/twitter/AnomalyDetection

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

Je suppose que la fonctionnalité que vous utilisez pour détecter une anomalie est une ligne de données dans un fichier journal. Si c'est le cas, Sklearn est votre bon ami et vous pouvez l'utiliser comme une boîte noire. Consultez le didacticiel sur la détection de SVM et de nouveauté à une classe .

Toutefois, si votre fonction est un fichier journal complet, vous devez d'abord la résumer en une caractéristique de la même dimension, puis appliquer la détection Novealty.

Il existe encore une version active et développée de Skyline, juste au cas où quelqu'un atterrirait ici et serait intéressé.

https://github.com/earthgecko/skyline

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

Je suis actuellement le responsable du projet et il est maintenant beaucoup plus avancé que la version originale d'Etsy, en termes de performances, d'interface utilisateur, de meilleure gestion de la saisonnalité et dispose des fonctionnalités supplémentaires d'une base de données d'anomalies, du calcul des corrélations et de la possibilité de détecter les empreintes digitales. et apprendre pas des modèles anormaux.

Étant donné que vous avez des séries chronologiques à plusieurs variables, je choisirais une implémentation LSTM-RNN qui modélise la dynamique de votre système en fonction des données de formation, qui sont généralement semi-supervisées (uniquement la classe normale incluse). Cela signifie que vous entraînez votre modèle à apprendre ce qui est "normal". Pendant le test, vous testez les conditions normales et anormales pour voir dans quelle mesure le modèle les distingue.

Un avantage des réseaux de neurones est qu'ils "apprennent" les corrélations croisées entre les signaux d'entrée par eux-mêmes; vous n'avez pas besoin de les explorer manuellement. Les RNN LSTM, en particulier, constituent un choix idéal pour la modélisation de séries chronologiques, simplement en raison de leur capacité à conserver la mémoire des entrées précédentes, similaire à un modèle d'espace d'état dans Control Theory (si vous voyez l'analogie).

En Python, il est presque trivial d'implémenter un RNST LSTM à l'aide de l' API Keras (au-dessus du backend Tensorflow). Ce réseau apprend à estimer le ou les signaux d’intérêt en fonction d’un nombre arbitraire d’entrées, que vous comparerez par la suite à la valeur mesurée réelle. S'il y a une "grosse" déviation, vous avez une anomalie (étant donné que le modèle est suffisamment précis)!