Detección de anomalías de código abierto en Python

Antecedentes del problema: estoy trabajando en un proyecto que involucra archivos de registro similares a los que se encuentran en el espacio de monitoreo de TI (para mi mejor comprensión del espacio de TI). Estos archivos de registro son datos de series temporales, organizados en cientos / miles de filas de varios parámetros. Cada parámetro es numérico (flotante) y hay un valor no trivial / sin error para cada punto de tiempo. Mi tarea es monitorear dichos archivos de registro para detectar anomalías (picos, caídas, patrones inusuales con algunos parámetros que no están sincronizados, comportamiento derivado extraño del 1er / 2do / etc., etc.).

En una tarea similar, probé Splunk con Prelert, pero estoy explorando opciones de código abierto en este momento.

Restricciones: me estoy limitando a Python porque lo conozco bien y me gustaría retrasar el cambio a R y la curva de aprendizaje asociada. A menos que parezca que existe un soporte abrumador para R (u otros lenguajes / software), me gustaría seguir con Python para esta tarea.

Además, estoy trabajando en un entorno Windows por el momento. Me gustaría continuar con sandbox en Windows en archivos de registro de pequeño tamaño, pero puedo pasar al entorno Linux si es necesario.

Recursos: He comprobado lo siguiente con callejones sin salida como resultados:

1. Python o R para implementar algoritmos de aprendizaje automático para la detección de fraudes . Alguna información aquí es útil, pero desafortunadamente, estoy luchando por encontrar el paquete correcto porque:

2. "AnomalyDetection" de Twitter está en R, y quiero seguir con Python. Además, la piratería del puerto de Python parece causar problemas en la implementación en el entorno de Windows para mí.

3. Skyline, mi próximo intento, parece haber sido descontinuado (de los problemas de github ). No me he sumergido profundamente en esto, dado el poco soporte que parece haber en línea.

4. scikit-learn Todavía estoy explorando, pero esto parece ser mucho más manual. El enfoque de abajo en la maleza está bien para mí, pero mi experiencia en herramientas de aprendizaje es débil, por lo que me gustaría algo así como un cuadro negro para los aspectos técnicos como los algoritmos, similar a Splunk + Prelert.

Definición del problema y preguntas: Estoy buscando un software de código abierto que pueda ayudarme a automatizar el proceso de detección de anomalías a partir de archivos de registro de series temporales en Python a través de paquetes o bibliotecas.

5. ¿Existen tales cosas para ayudar con mi tarea inmediata, o son imaginarias en mi mente?
6. ¿Alguien puede ayudarme con pasos concretos para ayudarme a alcanzar mi objetivo, incluidos los fundamentos o conceptos básicos?
7. ¿Es esta la mejor comunidad de StackExchange para preguntar, o es Stats, Math, o incluso Security o Stackoverflow las mejores opciones?

EDITAR [2015-07-23] ¡ Tenga en cuenta que la última actualización de pyculiarity parece estar arreglada para el entorno de Windows! Todavía tengo que confirmar, pero debería ser otra herramienta útil para la comunidad.

EDITAR [2016-01-19] Una actualización menor. No tuve tiempo para trabajar en esto e investigar, pero estoy dando un paso atrás para comprender los fundamentos de este problema antes de continuar investigando en detalles específicos. Por ejemplo, dos pasos concretos que estoy tomando son:

1. Comenzando con los artículos de Wikipedia para la detección de anomalías [ https://en.wikipedia.org/wiki/Anomaly_detection ], entendiendo completamente, y luego subiendo o bajando en la jerarquía conceptual de otros artículos de Wikipedia vinculados, como [ https: // en.wikipedia.org/wiki/K-nearest_neighours_algorithm ], y luego a [ https://en.wikipedia.org/wiki/Machine_learning ].

2. Explorando técnicas en las grandes encuestas realizadas por Chandola et al. 2009 "Anomaly Detection: A Survey" [ http://www-users.cs.umn.edu/~banerjee/papers/09/anomaly.pdf ] y Hodge et al 2004 "Una encuesta de metodologías de detección de valores atípicos" [ http://eprints.whiterose.ac.uk/767/1/hodgevj4.pdf ].

Una vez que se comprendan mejor los conceptos (espero jugar con ejemplos de juguetes a medida que avance para desarrollar el lado práctico también), espero comprender qué herramientas de Python de código abierto son más adecuadas para mis problemas.

La detección de anomalías o la detección de eventos se puede hacer de diferentes maneras:

Forma básica

¡Derivado! Si la desviación de su señal de su pasado y futuro es alta, lo más probable es que tenga un evento. Esto se puede extraer encontrando grandes cruces por cero en derivada de la señal.

Manera estadística

El significado de cualquier cosa es su comportamiento básico habitual. Si algo se desvía del significado, significa que es un evento. Tenga en cuenta que la media en las series temporales no es tan trivial y no es una constante, sino que cambia de acuerdo con los cambios en las series temporales, por lo que debe ver el "promedio móvil" en lugar del promedio. Se parece a esto:

El código de la media móvil se puede encontrar aquí . En la terminología del procesamiento de señales, está aplicando un filtro de "paso bajo " aplicando la media móvil.

Puedes seguir el siguiente código:

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

Camino probabilístico

Son más sofisticados especialmente para las personas nuevas en Machine Learning. Kalman Filter es una gran idea para encontrar las anomalías . Los enfoques probabilísticos más simples que utilizan la "Estimación de máxima verosimilitud" también funcionan bien, pero mi sugerencia es mantener la idea de la media móvil. Funciona en la práctica muy bien.

Espero poder ayudar :) ¡Buena suerte!

H2O tiene un módulo de detección de anomalías y, tradicionalmente, el código está disponible en R. Sin embargo, más allá de la versión 3, también tiene un módulo similar disponible en Python, y dado que H2O es de código abierto, podría ajustarse a su factura.

Puedes ver un ejemplo de trabajo aquí

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)

Recientemente desarrollé una caja de herramientas: Py thon O utlier D etection toolbox ( PyOD ). Ver GitHub .

Está diseñado para identificar objetos periféricos en datos con enfoques supervisados ​​y no supervisados. PyOD se presenta para:

• API unificadas, documentación detallada y ejemplos interactivos en varios algoritmos.
• Modelos avanzados, que incluyen redes neuronales / aprendizaje profundo y conjuntos atípicos.
• Rendimiento optimizado con JIT y paralelización cuando sea posible, utilizando numba y joblib. Compatible con Python 2 y 3 (también compatible con scikit-learn).

Aquí hay algunos enlaces importantes:

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

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

• Documentación : https://pyod.readthedocs.io

• Cuadernos interactivos Jupyter : https://mybinder.org/v2/gh/yzhao062/Pyod/master

Si usa PyOD en una publicación científica, agradeceríamos las citas al siguiente artículo

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

Actualmente está bajo revisión en JMLR (seguimiento de software de código abierto de aprendizaje automático). Ver preimpresión .

Introducción rapida

El kit de herramientas PyOD consta de tres grupos principales de funcionalidades: (i) algoritmos de detección de valores atípicos; (ii) marcos de conjuntos atípicos y (iii) funciones de utilidad de detección de valores atípicos.

Algoritmos de detección individual :

• PCA : Análisis de componentes principales (la suma de las distancias proyectadas ponderadas a los hiperplanos de vectores propios)
• MCD : determinante de covarianza mínima (use las distancias mahalanobis como puntajes atípicos)
• OCSVM : Máquinas de vectores de soporte de una clase
• LOF : factor de valor atípico local
• CBLOF : factor de valor atípico local basado en clústeres
• LOCI : LOCI: detección rápida de valores atípicos utilizando la integral de correlación local
• HBOS : puntaje atípico basado en histograma
• kNN : k Vecinos más cercanos (use la distancia al késimo vecino más cercano como puntaje atípico - **
• AvgKNN : kNN promedio (use la distancia promedio a k vecinos más cercanos como puntaje atípico)
• MedKNN : Mediana de kNN (use la distancia media de k vecinos más cercanos como puntaje atípico)
• ABOD : detección de valores atípicos basados ​​en ángulos
• FastABOD : detección rápida de valores atípicos basados ​​en ángulos mediante aproximación
• SOS : Selección de valores atípicos estocásticos
• IForest : bosque de aislamiento
• Característica de embolsado
• LSCP : LSCP: combinación localmente selectiva de conjuntos de valores atípicos paralelos
• XGBOD : detección de valores atípicos basados ​​en impulso extremo (supervisado)
• AutoEncoder : AutoEncoder totalmente conectado (use el error de reconstrucción como puntaje atípico)
• SO_GAAL : Aprendizaje Activo Adversario Generativo de Un Solo Objetivo
• MO_GAAL : Aprendizaje Activo Adversario Generativo de Objetivos Múltiples

Detector de valores atípicos / Marcos de combinación de puntajes :

• Característica de embolsado
• LSCP : LSCP: combinación localmente selectiva de conjuntos de valores atípicos paralelos
• Promedio : combinación simple promediando los puntajes
• Promedio ponderado : combinación simple promediando los puntajes con pesos de detectores
• Maximización : combinación simple al tomar los puntajes máximos
• AOM : promedio de máximo
• MOA : Maximización del promedio

Funciones de utilidad para detección de valores atípicos :

1. score_to_lable (): convierte puntuaciones atípicas sin procesar en etiquetas binarias
2. precision_n_scores (): una de las métricas de evaluación populares para la minería de valores atípicos (precision @ rank n)
3. generate_data (): genera pseudo datos para el experimento de detección de valores atípicos
4. wpearsonr (): pearson ponderado es útil en la generación de verdad pseudo-tierra

La comparación de todos los modelos implementados está disponible a continuación: ( Figura , Código , Cuadernos Jupyter ):

Si está interesado, consulte Github ( https://github.com/yzhao062/Pyod ) para obtener más información.

Actualmente estoy en el mismo escenario como tú. Estoy buscando la mejor opción para la detección de anomalías, investigando un poco.

Lo que he encontrado es que creo que se adapta mejor a tus necesidades y se compara mejor con lo que has visto. es decir, TwitterAnomalyDetection, SkyLine.

He encontrado mejor es NAB de Numenta (Numenta Anomaly Benchmark). También tiene un muy buen soporte de la comunidad y para usted el punto más es su código abierto y desarrollado en python. Puedes agregar tu algoritmo en él.

En caso de algoritmo, encontré que LOF o CBLOF son una buena opción.

así que échale un vistazo. Puede ayudarte. https://github.com/numenta/nab

Si encuentras una mejor opción. por favor dime. También estoy en el mismo camino.

¡¡La mejor de las suertes!!

Tal vez esto ayude a que mencione sobre los estados estables: https://github.com/twitter/AnomalyDetection

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

Supongo que la característica que usa para detectar anomalías es una fila de datos en un archivo de registro. Si es así, Sklearn es tu buen amigo y puedes usarlo como una caja negra. Consulte el tutorial de detección de novedad y SVM de una clase .

Sin embargo, en caso de que su característica sea un archivo de registro completo, primero debe resumirla en alguna característica de la misma dimensión y luego aplicar la detección Novealty.

Todavía hay una versión activa y desarrollada de Skyline, en caso de que alguien aterrice aquí y esté interesado.

https://github.com/earthgecko/skyline

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

Soy el responsable actual del proyecto y ahora es mucho más avanzado que la versión original de Etsy, en términos de rendimiento, interfaz de usuario, mejor manejo de la estacionalidad y tiene las funcionalidades adicionales de una base de datos de anomalías, el cálculo de correlaciones y la capacidad de huella digital y aprender patrones no anómalos.

Dado que tiene series de tiempo multivariadas, optaría por una implementación LSTM-RNN que modele la dinámica de su sistema en función de los datos de entrenamiento, que generalmente son semi-supervisados ​​(solo se incluye la clase normal). Esto significa que usted entrena su modelo para aprender lo que es "normal". Durante la prueba, prueba condiciones normales y anómalas para ver qué tan bien el modelo las distingue.

Una ventaja de las redes neuronales es que "aprenden" las correlaciones cruzadas entre las señales de entrada por sí mismas; no necesita explorarlos manualmente. Los LSTM-RNN, en particular, son una opción ideal cuando se trata de modelar series de tiempo simplemente por su capacidad de mantener la memoria de entradas anteriores, similar a un modelo de espacio de estado en Control Theory (si ve la analogía).

En Python, es casi trivial implementar un LSTM-RNN usando la API de Keras (además del backend de Tensorflow). Esta red aprende a estimar la (s) señal (es) de interés dada una cantidad arbitraria de entradas, que luego se compara con el valor medido real. Si hay una "gran" desviación, ¡tienes una anomalía (dado que el modelo es lo suficientemente preciso)!