Deteksi Anomali sumber terbuka dengan Python

Latar Belakang Masalah: Saya sedang mengerjakan proyek yang melibatkan file log mirip dengan yang ditemukan di ruang pemantauan TI (untuk pemahaman terbaik saya tentang ruang TI). File log ini adalah data deret waktu, disusun dalam ratusan / ribuan baris berbagai parameter. Setiap parameter bersifat numerik (float) dan ada nilai non-sepele / non-kesalahan untuk setiap titik waktu. Tugas saya adalah memonitor file-file log tersebut untuk pendeteksian anomali (paku, jatuh, pola yang tidak biasa dengan beberapa parameter tidak sinkron, aneh 1/2 / dll. Perilaku turunan, dll.).

Pada tugas yang sama, saya telah mencoba Splunk dengan Prelert, tetapi saya sedang mengeksplorasi opsi open-source saat ini.

Kendala: Saya membatasi diri untuk Python karena saya tahu betul, dan ingin menunda beralih ke R dan kurva belajar yang terkait. Kecuali jika tampaknya ada dukungan luar biasa untuk R (atau bahasa / perangkat lunak lain), saya ingin tetap menggunakan Python untuk tugas ini.

Juga, saya bekerja di lingkungan Windows untuk saat ini. Saya ingin melanjutkan ke sandbox di Windows pada file log berukuran kecil tetapi dapat pindah ke lingkungan Linux jika diperlukan.

Sumber: Saya telah memeriksa yang berikut dengan jalan buntu sebagai hasilnya:

1. Python atau R untuk mengimplementasikan algoritma pembelajaran mesin untuk deteksi penipuan . Beberapa info di sini bermanfaat, tetapi sayangnya, saya kesulitan menemukan paket yang tepat karena:

2. "AnomalyDetection" Twitter ada di R, dan saya ingin tetap menggunakan Python. Selanjutnya, port Python pyculiarity tampaknya menyebabkan masalah dalam menerapkan di lingkungan Windows untuk saya.

3. Skyline, upaya saya berikutnya, tampaknya telah cukup banyak dihentikan (dari masalah github ). Saya belum merenungkan hal ini, mengingat betapa sedikitnya dukungan yang ada untuk online.

4. scikit-belajar saya masih menjelajahi, tetapi ini tampaknya jauh lebih manual. Pendekatan down-in-the-weeds OK bagi saya, tetapi latar belakang saya dalam alat pembelajaran lemah, jadi ingin sesuatu seperti kotak hitam untuk aspek teknis seperti algoritma, mirip dengan Splunk + Prelert.

Definisi Masalah dan Pertanyaan: Saya mencari perangkat lunak open-source yang dapat membantu saya dengan mengotomatisasi proses deteksi anomali dari file log time-series dalam Python melalui paket atau pustaka.

5. Apakah hal-hal seperti itu ada untuk membantu tugas langsung saya, atau mereka imajiner dalam pikiran saya?
6. Adakah yang bisa membantu dengan langkah konkret untuk membantu saya mencapai tujuan saya, termasuk dasar-dasar atau konsep latar belakang?
7. Apakah ini komunitas StackExchange terbaik untuk ditanyakan, atau apakah Stats, Math, atau bahkan Security atau Stackoverflow adalah pilihan yang lebih baik?

EDIT [2015-07-23] Perhatikan bahwa pembaruan terbaru untuk kemewahan sepertinya diperbaiki untuk lingkungan Windows! Saya belum mengkonfirmasi, tetapi harus menjadi alat lain yang bermanfaat bagi masyarakat.

EDIT [2016-01-19] Pembaruan kecil. Saya tidak punya waktu untuk mengerjakan ini dan melakukan penelitian, tetapi saya mengambil langkah mundur untuk memahami dasar-dasar masalah ini sebelum melanjutkan penelitian dengan rincian spesifik. Sebagai contoh, dua langkah konkret yang saya ambil adalah:

1. Dimulai dengan artikel Wikipedia untuk deteksi anomali [ https://en.wikipedia.org/wiki/Anomaly_detection ], memahami sepenuhnya, dan kemudian bergerak naik atau turun dalam hierarki konsep artikel Wikipedia lainnya yang terhubung, seperti [ https: // en.wikipedia.org/wiki/K-nearest_neighbors_algorithm ], dan kemudian ke [ https://en.wikipedia.org/wiki/Machine_learning ].

2. Menjelajahi teknik dalam survei besar yang dilakukan oleh Chandola et al 2009 "Anomaly Detection: A Survey" [ http://www-users.cs.umn.edu/~banerjee/papers/09/anomaly.pdf ] dan Hodge et al 2004 "Sebuah Survei Metodologi Deteksi Outlier" [ http://eprints.whiterose.ac.uk/767/1/hodgevj4.pdf ].

Setelah konsep dipahami dengan lebih baik (saya berharap untuk bermain-main dengan contoh mainan saat saya pergi untuk mengembangkan sisi praktis juga), saya berharap untuk memahami alat Python open source yang lebih cocok untuk masalah saya.

Deteksi Anomali atau Deteksi Kejadian dapat dilakukan dengan berbagai cara:

Cara Dasar

Turunan! Jika penyimpangan sinyal Anda dari masa lalu & masa depannya tinggi, kemungkinan besar Anda memiliki suatu peristiwa. Ini dapat diekstraksi dengan menemukan penyilangan nol besar dalam turunan dari sinyal.

Jalan Statistik

Yang dimaksud dengan segala sesuatu adalah perilaku dasar yang biasa. jika sesuatu menyimpang dari berarti itu adalah suatu peristiwa. Harap dicatat bahwa mean dalam deret waktu tidak sepele dan tidak konstan tetapi berubah sesuai dengan perubahan deret waktu sehingga Anda perlu melihat "moving average" daripada rata-rata. Ini terlihat seperti ini:

Kode Moving Average dapat ditemukan di sini . Dalam terminologi pemrosesan sinyal, Anda menerapkan filter "Low-Pass" dengan menerapkan moving average.

Anda dapat mengikuti kode di bawah ini:

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

Cara Probabilistik

Mereka lebih canggih khusus untuk orang yang baru belajar Mesin. Filter Kalman adalah ide bagus untuk menemukan anomali . Pendekatan probabilistik yang lebih sederhana menggunakan "Estimasi Maximum-Likelihood" juga bekerja dengan baik tetapi saran saya adalah tetap dengan ide rata-rata bergerak. Ini bekerja dalam praktik dengan sangat baik.

Saya harap saya bisa membantu :) Semoga Sukses!

h2o memiliki modul deteksi anomali dan secara tradisional kode tersedia dalam R. Namun di luar versi 3 ia memiliki modul serupa yang tersedia dalam python juga, dan karena h2o adalah open source, mungkin sesuai dengan tagihan Anda.

Anda dapat melihat contoh kerja di sini

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)

Saya baru-baru ini mengembangkan toolbox: Py thon O utlier D etection toolbox ( PyOD ). Lihat GitHub .

Ini dirancang untuk mengidentifikasi objek-objek terpencil dalam data dengan pendekatan yang tidak diawasi dan diawasi. PyOD ditampilkan untuk:

• API terpadu, dokumentasi terperinci, dan contoh interaktif di berbagai algoritma.
• Model-model canggih, termasuk Neural Networks / Deep Learning dan Outlier Ensembles.
• Kinerja yang dioptimalkan dengan JIT dan paralelisasi bila memungkinkan, menggunakan numba dan joblib. Kompatibel dengan kedua Python 2 & 3 (scikit-belajar juga kompatibel).

Berikut ini beberapa tautan penting:

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

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

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

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

Jika Anda menggunakan PyOD dalam publikasi ilmiah, kami sangat menghargai kutipan untuk makalah berikut

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

Saat ini sedang ditinjau di JMLR (pembelajaran perangkat lunak jalur open-source pembelajaran mesin). Lihat pracetak .

Pendahuluan cepat

PyOD toolkit terdiri dari tiga kelompok fungsi utama: (i) algoritma deteksi pencilan; (ii) kerangka kerja ensemble outlier dan (iii) fungsi utilitas deteksi outlier.

Algoritma Deteksi Perorangan :

• PCA : Analisis Komponen Utama (jumlah jarak yang diproyeksikan tertimbang ke hiperektor vektor eigen)
• MCD : Minimum Covariance Determinant (gunakan jarak mahalanobis sebagai skor outlier)
• OCSVM : Mesin Vektor Dukungan Satu-Kelas
• LOF : Faktor Pencilan Lokal
• CBLOF : Faktor Pencilan Lokal Berbasis Clustering
• LOCI : LOCI: Deteksi outlier cepat menggunakan integral korelasi lokal
• HBOS : Skor Outlier Berbasis Histogram
• kNN : k Tetangga Terdekat (gunakan jarak ke tetangga terdekat k sebagai nilai ** outlier
• AvgKNN : Rata-rata kNN (gunakan jarak rata-rata ke k tetangga terdekat sebagai skor outlier)
• MedKNN : Median kNN (gunakan jarak median ke k tetangga terdekat sebagai skor outlier)
• ABOD : Deteksi Outlier Berbasis Sudut
• FastABOD : Deteksi Outlier Berbasis Sudut Cepat menggunakan pendekatan
• SOS : Pilihan Outlier Stochastic
• IForest : Hutan Isolasi
• Fitur mengantongi
• LSCP : LSCP: Kombinasi Selektif Lokal untuk Ensembel Paralel Paralel
• XGBOD : Deteksi Outlier Berbasis Ekstrim Boosting (Dibimbing)
• AutoEncoder : AutoEncoder yang terhubung penuh (gunakan kesalahan rekonstruksi sebagai skor outlier)
• SO_GAAL : Pembelajaran Aktif Adversarial Generatif-Objektif Tunggal
• MO_GAAL : Pembelajaran Aktif Adversarial Generatif Multi-Objective

Kerangka Kerja Kombinasi Detektor Outlier / Skor :

• Fitur mengantongi
• LSCP : LSCP: Kombinasi Selektif Lokal untuk Ensembel Paralel Paralel
• Rata-rata : Kombinasi sederhana dengan rata-rata skor
• Weighted Average : Kombinasi sederhana dengan rata-rata skor dengan bobot detektor
• Maksimalisasi : Kombinasi sederhana dengan mengambil skor maksimum
• AOM : Rata-rata Maksimum
• MOA : Maksimalisasi Rata-Rata

Fungsi Utilitas untuk Deteksi Outlier :

1. score_to_lable (): mengonversi skor outlier mentah ke label biner
2. precision_n_scores (): salah satu metrik evaluasi populer untuk penambangan outlier (precision @ rank n)
3. generate_data (): menghasilkan data pseudo untuk eksperimen deteksi outlier
4. wpearsonr (): pearson tertimbang berguna dalam pembuatan kebenaran dasar pseudo

Perbandingan semua model yang diterapkan tersedia di bawah ini: ( Gambar , Kode , Notebook Jupyter ):

Jika Anda tertarik, silakan periksa Github ( https://github.com/yzhao062/Pyod ) untuk informasi lebih lanjut.

Saya saat ini di panggung yang sama seperti Anda. Saya menemukan opsi terbaik untuk deteksi anomali, melakukan penelitian.

Apa yang saya temukan adalah saya pikir paling cocok dengan kebutuhan Anda dan lebih baik dibandingkan dengan apa yang Anda lihat. yaitu, TwitterAnomalyDetection, SkyLine.

Yang saya temukan lebih baik adalah NAB NAB (Numenta Anomaly Benchmark). Ini juga memiliki dukungan komunitas yang sangat baik dan bagi Anda poin plus adalah open source & dikembangkan dengan python. Anda dapat menambahkan algoritma Anda di dalamnya.

Dalam hal algoritma, saya menemukan LOF atau CBLOF adalah opsi yang baik.

jadi, periksa sekali. Ini dapat membantu Anda. https://github.com/numenta/nab

Jika Anda menemukan opsi yang lebih baik. tolong beritahu aku. Saya juga di jalan yang sama.

Keberuntungan terbaik !!

Mungkin ini membantu karena Anda menyebutkan tentang kondisi stabil: https://github.com/twitter/AnomalyDetection

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

Saya berasumsi fitur yang Anda gunakan untuk mendeteksi ketidaknormalan adalah satu baris data dalam logfile. Jika demikian, Sklearn adalah teman baik Anda dan Anda dapat menggunakannya sebagai kotak hitam. Periksa tutorial SVM satu kelas dan deteksi Baru .

Namun, jika fitur Anda adalah seluruh file log, Anda harus meringkasnya terlebih dahulu ke beberapa fitur dengan dimensi yang sama, dan kemudian menerapkan deteksi Novealty.

Masih ada versi Skyline yang aktif dan dikembangkan, untuk berjaga-jaga seandainya seseorang mendarat di sini dan tertarik.

https://github.com/earthgecko/skyline

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

Saya adalah pemelihara proyek saat ini dan sekarang jauh lebih maju daripada versi Etsy asli, dalam hal kinerja, UI, penanganan musiman yang lebih baik dan memiliki fungsi tambahan dari database anomali, menghitung korelasi dan kemampuan untuk sidik jari dan belajar bukan pola anomali.

Karena Anda memiliki deret waktu multivarian, saya akan menerapkan LSTM-RNN yang memodelkan dinamika sistem Anda berdasarkan data pelatihan, yang biasanya semi-diawasi (hanya kelas normal yang disertakan). Ini berarti Anda melatih model Anda untuk mempelajari apa yang "normal". Selama pengujian, Anda menguji kondisi normal dan anomali untuk melihat seberapa baik model membedakan mereka.

Keuntungan dari jaringan saraf adalah mereka "mempelajari" korelasi silang antara sinyal input sendiri; Anda tidak perlu menjelajahinya secara manual. LSTM-RNNs, khususnya, adalah pilihan ideal ketika datang ke pemodelan deret waktu hanya karena kemampuan mereka untuk menyimpan memori dari input sebelumnya, mirip dengan model ruang keadaan dalam Control Theory (jika Anda melihat analoginya).

Dalam Python, hampir sepele untuk mengimplementasikan LSTM-RNN menggunakan Keras API (di atas backend Tensorflow). Jaringan ini belajar memperkirakan sinyal yang diinginkan dengan jumlah input yang berubah-ubah, yang kemudian Anda bandingkan dengan nilai terukur aktual. Jika ada penyimpangan "besar", Anda mendapat anomali (mengingat bahwa modelnya cukup akurat)!