Detecção de anomalia de código aberto em Python

Histórico do problema: Estou trabalhando em um projeto que envolve arquivos de log semelhantes aos encontrados no espaço de monitoramento de TI (para minha melhor compreensão do espaço de TI). Esses arquivos de log são dados de séries temporais, organizados em centenas / milhares de linhas de vários parâmetros. Cada parâmetro é numérico (flutuante) e há um valor não trivial / sem erro para cada ponto no tempo. Minha tarefa é monitorar os arquivos de log para detecção de anomalias (picos, quedas, padrões incomuns com alguns parâmetros fora de sincronia, comportamento derivado estranho do 1º / 2º / etc., Etc.).

Em uma tarefa semelhante, tentei o Splunk com a Prelert, mas estou explorando opções de código aberto no momento.

Restrições: Estou me limitando ao Python porque o conheço bem e gostaria de atrasar a mudança para R e a curva de aprendizado associada. A menos que pareça haver um suporte esmagador ao R (ou outras línguas / software), eu gostaria de me ater ao Python para esta tarefa.

Além disso, estou trabalhando em um ambiente Windows no momento. Gostaria de continuar com o sandbox no Windows em arquivos de log de tamanho pequeno, mas posso passar para o ambiente Linux, se necessário.

Recursos: Verifiquei o seguinte com becos sem saída como resultados:

1. Python ou R para implementar algoritmos de aprendizado de máquina para detecção de fraudes . Algumas informações aqui são úteis, mas infelizmente estou lutando para encontrar o pacote certo porque:

2. "AnomalyDetection" do Twitter está em R, e eu quero me ater ao Python. Além disso, a pyculiarity da porta Python parece causar problemas na implementação no ambiente Windows para mim.

3. Skyline, minha próxima tentativa, parece ter sido praticamente descontinuada (devido a problemas no github ). Eu não mergulhei nisso, dado o pouco apoio que parece estar online.

4. Ainda estou explorando o scikit-learn, mas isso parece ser muito mais manual. A abordagem básica é aceitável para mim, mas minha formação em ferramentas de aprendizado é fraca, por isso gostaria de algo parecido com uma caixa preta para aspectos técnicos, como algoritmos, semelhantes ao Splunk + Prelert.

Definição e perguntas dos problemas: Estou procurando um software de código aberto que possa me ajudar a automatizar o processo de detecção de anomalias de arquivos de log de séries temporais no Python por meio de pacotes ou bibliotecas.

5. Essas coisas existem para ajudar na minha tarefa imediata ou são imaginárias em minha mente?
6. Alguém pode ajudar com medidas concretas para me ajudar a alcançar minha meta, incluindo conceitos ou fundamentos básicos?
7. Essa é a melhor comunidade do StackExchange para perguntar, ou Estatísticas, Matemática ou mesmo Segurança ou Stackoverflow são as melhores opções?

EDIT [2015-07-23] Observe que a atualização mais recente da pyculiarity parece estar corrigida para o ambiente Windows! Ainda tenho que confirmar, mas deve ser outra ferramenta útil para a comunidade.

EDIT [2016-01-19] Uma pequena atualização. Não tive tempo de trabalhar nisso e pesquisar, mas estou dando um passo para trás para entender os fundamentos desse problema antes de continuar pesquisando em detalhes específicos. Por exemplo, duas etapas concretas que estou tomando são:

1. Começando com os artigos da Wikipedia para detecção de anomalias [ https://en.wikipedia.org/wiki/Anomaly_detection ], entendendo completamente e, em seguida, subindo ou descendo na hierarquia de conceitos de outros artigos vinculados da Wikipedia, como [ https: // pt.wikipedia.org/wiki/K-nearest_neighbors_algorithm ] e, em seguida, para [ https://en.wikipedia.org/wiki/Machine_learning ].

2. Explorando técnicas nas grandes pesquisas realizadas por Chandola et al 2009 "Anomaly Detection: A Survey" [ http://www-users.cs.umn.edu/~banerjee/papers/09/anomaly.pdf ] e Hodge et al 2004 "Um levantamento das metodologias de detecção de outlier" [ http://eprints.whiterose.ac.uk/767/1/hodgevj4.pdf ].

Uma vez que os conceitos sejam melhor compreendidos (espero brincar com exemplos de brinquedos à medida que desenvolvo o lado prático), espero entender quais ferramentas Python de código aberto são mais adequadas para meus problemas.

A detecção de anomalias ou detecção de eventos pode ser feita de diferentes maneiras:

Caminho Básico

Derivado! Se o desvio do seu sinal do passado e do futuro for alto, você provavelmente terá um evento. Isso pode ser extraído encontrando-se grandes cruzamentos de zero na derivada do sinal.

Caminho Estatístico

A média de qualquer coisa é o seu comportamento básico usual. se algo se desvia do meio, significa que é um evento. Observe que a média nas séries temporais não é tão trivial e não é uma constante, mas muda de acordo com as alterações nas séries temporais; portanto, você precisa ver a "média móvel" em vez da média. Se parece com isso:

O código da Média Móvel pode ser encontrado aqui . Na terminologia do processamento de sinal, você está aplicando um filtro "passa-baixo" aplicando a média móvel.

Você pode seguir o código abaixo:

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

Caminho probabilístico

Eles são mais sofisticados, especialmente para pessoas novas no Machine Learning. O Kalman Filter é uma ótima idéia para encontrar as anomalias . Abordagens probabilísticas mais simples usando "Estimativa de máxima verossimilhança" também funcionam bem, mas minha sugestão é permanecer com a ideia da média móvel. Funciona muito bem na prática.

Espero poder ajudar :) Boa sorte!

O h2o possui um módulo de detecção de anomalias e, tradicionalmente, o código está disponível no R. No entanto, além da versão 3, ele também possui um módulo semelhante disponível em python, e, como o h2o é de código aberto, pode ser adequado à sua conta.

Você pode ver um exemplo de trabalho aqui

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)

Recentemente, desenvolvi uma caixa de ferramentas: Py thon O utlier D etection toolbox ( PyOD ). Veja GitHub .

Ele foi projetado para identificar objetos externos nos dados com abordagens não supervisionadas e supervisionadas. O PyOD é apresentado para:

• APIs unificadas, documentação detalhada e exemplos interativos em vários algoritmos.
• Modelos avançados, incluindo Redes Neurais / Deep Learning e Outlier Ensembles.
• Desempenho otimizado com JIT e paralelização, quando possível, usando numba e joblib. Compatível com o Python 2 e 3 (também compatível com o scikit-learn).

Aqui estão alguns links importantes:

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

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

• Documentação : https://pyod.readthedocs.io

• Notebooks interativos Jupyter : https://mybinder.org/v2/gh/yzhao062/Pyod/master

Se você usa o PyOD em uma publicação científica, gostaríamos de citar o seguinte artigo

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

Atualmente, ele está em revisão no JMLR (faixa de software de código aberto do aprendizado de máquina). Veja pré-impressão .

Introdução Rápida

O kit de ferramentas PyOD consiste em três grandes grupos de funcionalidades: (i) algoritmos de detecção de outlier; (ii) estruturas de conjunto outlier e (iii) funções de utilitário de detecção de outlier.

Algoritmos de detecção individual :

• PCA : Análise de Componentes Principais (a soma das distâncias projetadas ponderadas para os hiperplanos de vetores próprios)
• MCD : determinante mínimo de covariância (use as distâncias de mahalanobis como as pontuações externas)
• OCSVM : Máquinas de Vetor de Suporte de Uma Classe
• LOF : Fator Outlier Local
• CBLOF : Fator externo externo baseado em cluster
• LOCI : LOCI: Detecção rápida de outlier usando a integral de correlação local
• HBOS : Pontuação Outlier baseada em histograma
• kNN : k Vizinhos mais próximos (use a distância até o quinto vizinho mais próximo como a pontuação externa - **
• AvgKNN : kNN médio (use a distância média para k vizinhos mais próximos como a pontuação externa)
• MedKNN : mediana kNN (use a distância mediana para k vizinhos mais próximos como a pontuação externa)
• ABOD : Detecção de Outlier baseada em ângulo
• FastABOD : Detecção rápida de outlier baseada em ângulo usando aproximação
• SOS : Seleção estocástica de outlier
• IForest : Floresta de isolamento
• Ensacamento
• LSCP : LSCP: combinação localmente seletiva de conjuntos outlier paralelos
• XGBOD : Detecção de Outlier Baseada em Impulso Extremo (Supervisionada)
• AutoEncoder : AutoEncoder totalmente conectado (use o erro de reconstrução como a pontuação externa)
• SO_GAAL : Aprendizagem Ativa Adversarial Geradora de Objetivo Único
• MO_GAAL : Aprendizagem Ativa Adversarial Gerativa de Múltiplos Objetivos

Estruturas de combinação de detectores / escores discrepantes :

• Ensacamento
• LSCP : LSCP: combinação localmente seletiva de conjuntos outlier paralelos
• Média : combinação simples calculando a média das pontuações
• Média ponderada : combinação simples calculando a média das pontuações com pesos dos detectores
• Maximização : combinação simples, obtendo as pontuações máximas
• OMA : Média do Máximo
• MOA : Maximização da Média

Funções de utilitário para detecção de outlier :

1. score_to_lable (): converte pontuações outlier brutas em rótulos binários
2. precision_n_scores (): uma das métricas de avaliação populares para mineração outlier (precision @ rank n)
3. generate_data (): gera pseudo dados para experimentos de detecção outlier
4. wpearsonr (): pearson ponderado é útil na geração de verdade em pseudo terreno

A comparação de todos os modelos implementados é disponibilizada abaixo: ( Figura , Código , Notebooks Jupyter ):

Se você estiver interessado, consulte o Github ( https://github.com/yzhao062/Pyod ) para obter mais informações.

Atualmente, estou no mesmo palco que você. Estou encontrando a melhor opção para detecção de anomalias, fazendo algumas pesquisas.

O que eu descobri é que acho que melhor corresponde à sua necessidade e é melhor comparado ao que você viu. ou seja, TwitterAnomalyDetection, SkyLine.

Eu descobri melhor é o NAB da Numenta (Numenta Anomaly Benchmark). Ele também tem um excelente suporte da comunidade e, para você, o ponto positivo é o código aberto e desenvolvido em python. Você pode adicionar seu algoritmo nele.

Em caso de algoritmo, achei LOF ou CBLOF são uma boa opção.

então, confira uma vez. Isso pode ajudá-lo. https://github.com/numenta/nab

Se você encontrar a melhor opção. por favor, diga. Eu também estou no mesmo caminho.

Boa sorte!!

Talvez isso ajude a fazer você mencionar os estados estacionários: https://github.com/twitter/AnomalyDetection

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

Presumo que o recurso usado para detectar anormalidades seja uma linha de dados em um arquivo de log. Nesse caso, o Sklearn é seu bom amigo e você pode usá-lo como uma caixa preta. Verifique o tutorial de detecção de SVM e novidade de uma classe .

No entanto, caso o seu recurso seja um arquivo de log inteiro, primeiro é necessário resumi-lo em algum recurso da mesma dimensão e, em seguida, aplicar a detecção de novidade.

Ainda existe uma versão ativa e desenvolvida do Skyline, caso alguém chegue aqui e esteja interessado.

https://github.com/earthgecko/skyline

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

Sou o atual mantenedor do projeto e agora é muito mais avançado que a versão original do Etsy, em termos de desempenho, interface do usuário, melhor tratamento da sazonalidade e possui as funcionalidades adicionais de um banco de dados de anomalias, calculando correlações e a capacidade de impressão digital e aprender padrões não anômalos.

Como você tem séries temporais multivariadas, eu usaria uma implementação LSTM-RNN que modela a dinâmica do seu sistema com base em dados de treinamento, que geralmente são semi-supervisionados (apenas a classe normal incluída). Isso significa que você treina seu modelo para aprender o que é "normal". Durante o teste, você testa condições normais e anômalas para ver até que ponto o modelo as diferencia.

Uma vantagem das redes neurais é que elas "aprendem" as correlações cruzadas entre os sinais de entrada; você não precisa explorá-los manualmente. Os LSTM-RNNs, em particular, são uma escolha ideal quando se trata de modelagem de séries temporais, simplesmente devido à sua capacidade de manter a memória de entradas anteriores, semelhante a um modelo de espaço de estado na Teoria do Controle (se você vir a analogia).

No Python, é quase trivial implementar um LSTM-RNN usando a API Keras (no topo do back-end do Tensorflow). Essa rede aprende a estimar o (s) sinal (ais) de interesse, considerando um número arbitrário de entradas, que você compara posteriormente com o valor real medido. Se houver um desvio "grande", você terá uma anomalia (dado que o modelo é preciso o suficiente)!