diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b5f2b45 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.ipynb_checkpoints +.DS_Store diff --git a/ML_anomaly_detection.ipynb b/ML_anomaly_detection.ipynb new file mode 100644 index 0000000..dd45ff5 --- /dev/null +++ b/ML_anomaly_detection.ipynb @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 337, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from sklearn.svm import OneClassSVM\n", + "from sklearn.ensemble import IsolationForest\n", + "from sklearn.metrics import roc_auc_score, average_precision_score\n", + "\n", + "import tensorflow as tf\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from keras.datasets import mnist" + ] + }, + { + "cell_type": "code", + "execution_count": 338, + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.RandomState(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 339, + "metadata": {}, + "outputs": [], + "source": [ + "def prepare_mnist_mlfetch():\n", + " (x_train, x_trainLabels), (x_test, x_testLabels) = mnist.load_data()\n", + " labels = x_trainLabels\n", + " data = x_train\n", + "\n", + " ## 4859 digit- 4\n", + " k_four = np.where(labels == 4)\n", + " label_four = labels[k_four]\n", + " data_four = data[k_four]\n", + "\n", + " k_zeros = np.where(labels == 0)\n", + " k_sevens = np.where(labels == 7)\n", + " k_nine = np.where(labels == 9)\n", + "\n", + " ## 265 (0,7,9)\n", + " label_zeros = labels[k_zeros]\n", + " data_zeros = data[k_zeros]\n", + "\n", + " label_sevens = labels[k_sevens]\n", + " data_sevens = data[k_sevens]\n", + "\n", + " label_nine = labels[k_nine]\n", + " data_nines = data[k_nine]\n", + "\n", + "\n", + " data_four = data_four[:220]\n", + "\n", + " data_zeros = data_zeros[:5]\n", + " data_sevens = data_sevens[:3]\n", + " data_nines = data_nines[:3]\n", + "\n", + " data_sevens = data_sevens[:11]\n", + "\n", + " normal = data_four\n", + " anomalies = np.concatenate((data_zeros, data_sevens, data_nines), axis=0)\n", + "\n", + "\n", + " normal = np.reshape(normal, (len(normal), 784))\n", + " anomalies = np.reshape(anomalies, (len(anomalies), 784))\n", + "\n", + " return [normal, anomalies]" + ] + }, + { + "cell_type": "code", + "execution_count": 340, + "metadata": {}, + "outputs": [], + "source": [ + "def sklearn_IsolationForest(data_train, data_test):\n", + " clf = IsolationForest(max_samples=50, random_state=rng)\n", + " clf.fit(data_train)\n", + " pos_decisionScore = clf.predict(data_train)\n", + " neg_decisionScore = clf.predict(data_test)\n", + " \n", + " return [pos_decisionScore, neg_decisionScore]" + ] + }, + { + "cell_type": "code", + "execution_count": 341, + "metadata": {}, + "outputs": [], + "source": [ + "def sklearn_OCSVM_linear(data_train, data_test, nu):\n", + " ocSVM = OneClassSVM(nu = nu, kernel = 'linear')\n", + " ocSVM.fit(data_train)\n", + " pos_decisionScore = ocSVM.decision_function(data_train)\n", + " neg_decisionScore = ocSVM.decision_function(data_test)\n", + " \n", + " return [pos_decisionScore, neg_decisionScore]" + ] + }, + { + "cell_type": "code", + "execution_count": 342, + "metadata": {}, + "outputs": [], + "source": [ + "def au_roc(y_true, y_score):\n", + " roc_score = roc_auc_score(y_true, y_score)\n", + " print('ROC score: {0:0.4f}'.format(roc_score))\n", + " \n", + " return roc_score" + ] + }, + { + "cell_type": "code", + "execution_count": 343, + "metadata": {}, + "outputs": [], + "source": [ + "def au_prc(y_true, y_score):\n", + " average_precision = average_precision_score(y_true, y_score)\n", + " print('Average precision-recall score: {0:0.4f}'.format(average_precision))\n", + " \n", + " return average_precision" + ] + }, + { + "cell_type": "code", + "execution_count": 344, + "metadata": {}, + "outputs": [], + "source": [ + "y_true_pos = np.ones(X_train.shape[0])\n", + "y_true_neg = np.zeros(X_test.shape[0])\n", + "y_true = np.concatenate((y_true_pos, y_true_neg))" + ] + }, + { + "cell_type": "code", + "execution_count": 345, + "metadata": {}, + "outputs": [], + "source": [ + "[X_train, X_test] = prepare_mnist_mlfetch()" + ] + }, + { + "cell_type": "code", + "execution_count": 346, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROC score: 0.6773\n", + "Average precision-recall score: 0.9688\n" + ] + } + ], + "source": [ + "[y_scores_pos_IF, y_scores_neg_IF] = sklearn_IsolationForest(X_train, X_test)\n", + "\n", + "y_score_IF = np.concatenate((y_scores_pos_IF, y_scores_neg_IF))\n", + "\n", + "isolation_forest_roc = au_roc(y_true, y_score_IF)\n", + "isolation_forest_prc = au_prc(y_true, y_score_IF)" + ] + }, + { + "cell_type": "code", + "execution_count": 347, + "metadata": {}, + "outputs": [], + "source": [ + "nu = 0.04" + ] + }, + { + "cell_type": "code", + "execution_count": 348, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROC score: 0.5740\n", + "Average precision-recall score: 0.9686\n" + ] + } + ], + "source": [ + "[y_scores_pos_OCSVM_linear, y_scores_neg_OCSVM_linear] = sklearn_OCSVM_linear(X_train, X_test, nu)\n", + "\n", + "y_score_OCSVM_linear = np.concatenate((y_scores_pos_OCSVM_linear, y_scores_neg_OCSVM_linear))\n", + "\n", + "OCSVM_linear_roc = au_roc(y_true, y_score_OCSVM_linear)\n", + "OCSVM_linear_prc = au_prc(y_true, y_score_OCSVM_linear)" + ] + }, + { + "cell_type": "code", + "execution_count": 349, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(y_scores_pos_OCSVM_linear, bins = 25, label = 'Normal')\n", + "plt.hist(y_scores_neg_OCSVM_linear, bins = 25, label = 'Anomaly')\n", + "plt.title(\"ocsvm: linear\");\n", + "plt.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 350, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(y_scores_pos_IF, bins = 25, label = 'Normal')\n", + "plt.hist(y_scores_neg_IF, bins = 25, label = 'Anomaly')\n", + "plt.title(\"Isolation forest\");\n", + "plt.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 351, + "metadata": {}, + "outputs": [], + "source": [ + "def tf_OneClass_NN_sigmoid(data_train, data_test):\n", + " tf.reset_default_graph()\n", + "\n", + " train_X = data_train\n", + "\n", + " RANDOM_SEED = 42\n", + " tf.set_random_seed(RANDOM_SEED)\n", + "\n", + " # Layer's sizes\n", + " x_size = train_X.shape[1] # Number of input nodes: 4 features and 1 bias\n", + " h_size = 32 # Number of hidden nodes\n", + " y_size = 1 # Number of outcomes (3 iris flowers)\n", + " D = x_size\n", + " K = h_size\n", + "\n", + " theta = np.random.normal(0, 1, K + K*D + 1)\n", + " rvalue = np.random.normal(0, 1, (len(train_X), y_size))\n", + " nu = 0.04\n", + "\n", + " def init_weights(shape):\n", + " \"\"\" Weight initialization \"\"\"\n", + " weights = tf.random_normal(shape,mean=0, stddev=0.00001)\n", + " return tf.Variable(weights)\n", + "\n", + " def forwardprop(X, w_1, w_2):\n", + " \"\"\"\n", + " Forward-propagation.\n", + " IMPORTANT: yhat is not softmax since TensorFlow's softmax_cross_entropy_with_logits() does that internally.\n", + " \"\"\"\n", + " X = tf.cast(X, tf.float32)\n", + " w_1 = tf.cast(w_1, tf.float32)\n", + " w_2 = tf.cast(w_2, tf.float32)\n", + " h = tf.nn.sigmoid(tf.matmul(X, w_1)) # The sigma function\n", + " yhat = tf.matmul(h, w_2) # The varphi function\n", + " return yhat\n", + "\n", + " g = lambda x : 1 / (1 + tf.exp(-x))\n", + "\n", + " def nnScore(X, w, V, g):\n", + " X = tf.cast(X, tf.float32)\n", + " w = tf.cast(w, tf.float32)\n", + " V = tf.cast(V, tf.float32)\n", + " return tf.matmul(g((tf.matmul(X, w))), V)\n", + "\n", + " def relu(x):\n", + " y = x # y[y < 0] = 0\n", + " return y\n", + "\n", + " def ocnn_obj(theta, X, nu, w1, w2, g,r):\n", + " w = w1\n", + " V = w2\n", + "\n", + " X = tf.cast(X, tf.float32)\n", + " w = tf.cast(w1, tf.float32)\n", + " V = tf.cast(w2, tf.float32)\n", + "\n", + " term1 = 0.5 * tf.reduce_sum(w**2)\n", + " term2 = 0.5 * tf.reduce_sum(V**2)\n", + " term3 = 1/nu * tf.reduce_mean(relu(r - nnScore(X, w, V, g)))\n", + " term4 = -r\n", + "\n", + " return term1 + term2 + term3 + term4\n", + "\n", + " # For testing the algorithm\n", + " test_X = data_test\n", + "\n", + "\n", + " # Symbols\n", + " X = tf.placeholder(\"float32\", shape = [None, x_size])\n", + "\n", + " r = tf.get_variable(\"r\", dtype = tf.float32, shape = (), trainable = False)\n", + "\n", + " # Weight initializations\n", + " w_1 = init_weights((x_size, h_size))\n", + " w_2 = init_weights((h_size, y_size))\n", + "\n", + " # Forward propagation\n", + " yhat = forwardprop(X, w_1, w_2)\n", + " predict = tf.argmax(yhat, axis = 1)\n", + "\n", + "\n", + " # Backward propagation\n", + " cost = ocnn_obj(theta, X, nu, w_1, w_2, g, r)\n", + " updates = tf.train.GradientDescentOptimizer(0.0001).minimize(cost)\n", + "\n", + " # Run SGD\n", + " sess = tf.Session()\n", + " init = tf.global_variables_initializer()\n", + " sess.run(init)\n", + " rvalue = 0.1\n", + " for epoch in range(30):\n", + " # Train with each example\n", + " sess.run(updates, feed_dict = {X: train_X, r:rvalue})\n", + " rvalue = nnScore(train_X, w_1, w_2, g)\n", + " with sess.as_default():\n", + " rvalue = rvalue.eval()\n", + " rvalue = np.percentile(rvalue,q = 100*0.04)\n", + " print(\"Epoch = %d, r = %f\" % (epoch + 1,rvalue))\n", + "\n", + "\n", + " train = nnScore(train_X, w_1, w_2, g)\n", + " test = nnScore(test_X, w_1, w_2, g)\n", + " with sess.as_default():\n", + " arrayTrain = train.eval()\n", + " arrayTest = test.eval()\n", + "\n", + " rstar = rvalue\n", + " sess.close()\n", + " print(\"Session Closed!!!\")\n", + "\n", + " pos_decisionScore = arrayTrain - rstar\n", + " neg_decisionScore = arrayTest - rstar\n", + "\n", + " return [pos_decisionScore, neg_decisionScore]" + ] + }, + { + "cell_type": "code", + "execution_count": 352, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch = 1, r = 0.019881\n", + "Epoch = 2, r = 0.061114\n", + "Epoch = 3, r = 0.133869\n", + "Epoch = 4, r = 0.212051\n", + "Epoch = 5, r = 0.291868\n", + "Epoch = 6, r = 0.372199\n", + "Epoch = 7, r = 0.452624\n", + "Epoch = 8, r = 0.533001\n", + "Epoch = 9, r = 0.613309\n", + "Epoch = 10, r = 0.693517\n", + "Epoch = 11, r = 0.773710\n", + "Epoch = 12, r = 0.853920\n", + "Epoch = 13, r = 0.934096\n", + "Epoch = 14, r = 1.014242\n", + "Epoch = 15, r = 1.094359\n", + "Epoch = 16, r = 1.174450\n", + "Epoch = 17, r = 1.254516\n", + "Epoch = 18, r = 1.334560\n", + "Epoch = 19, r = 1.414583\n", + "Epoch = 20, r = 1.494586\n", + "Epoch = 21, r = 1.574571\n", + "Epoch = 22, r = 1.654538\n", + "Epoch = 23, r = 1.734489\n", + "Epoch = 24, r = 1.814424\n", + "Epoch = 25, r = 1.894344\n", + "Epoch = 26, r = 1.974250\n", + "Epoch = 27, r = 2.054142\n", + "Epoch = 28, r = 2.134021\n", + "Epoch = 29, r = 2.213887\n", + "Epoch = 30, r = 2.293741\n", + "Session Closed!!!\n", + "ROC score: 0.6116\n", + "Average precision-recall score: 0.9710\n" + ] + } + ], + "source": [ + "[y_scores_pos_tf_OneClass_NN_sigmoid, y_scores_neg_tf_OneClass_NN_sigmoid] = tf_OneClass_NN_sigmoid(X_train, X_test)\n", + "\n", + "y_score_tf_OneClass_NN_sigmoid = np.concatenate((y_scores_pos_tf_OneClass_NN_sigmoid, y_scores_neg_tf_OneClass_NN_sigmoid))\n", + "\n", + "tf_OneClass_NN_sigmoid_roc = au_roc(y_true, y_score_tf_OneClass_NN_sigmoid)\n", + "tf_OneClass_NN_sigmoid_prc = au_prc(y_true, y_score_tf_OneClass_NN_sigmoid)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 353, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(y_scores_pos_tf_OneClass_NN_sigmoid, bins = 25, label = 'Normal')\n", + "plt.hist(y_scores_neg_tf_OneClass_NN_sigmoid, bins = 25, label = 'Anomaly')\n", + "plt.title(\"OneClass NN sigmoid\");\n", + "plt.legend(loc='upper right')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.5" + }, + "toc": { + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "toc_cell": false, + "toc_position": {}, + "toc_section_display": "block", + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}