diff options
Diffstat (limited to 'models/failure_prediction/jnotebooks/Decision_Tree.ipynb')
| -rw-r--r-- | models/failure_prediction/jnotebooks/Decision_Tree.ipynb | 892 |
1 files changed, 892 insertions, 0 deletions
diff --git a/models/failure_prediction/jnotebooks/Decision_Tree.ipynb b/models/failure_prediction/jnotebooks/Decision_Tree.ipynb new file mode 100644 index 0000000..d7cc012 --- /dev/null +++ b/models/failure_prediction/jnotebooks/Decision_Tree.ipynb @@ -0,0 +1,892 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Decision_Tree.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "FxPrqgIEVsdg" + }, + "source": [ + "Contributors: **Rohit Singh Rathaur, Girish L.** \n", + "\n", + "Copyright [2021](2021) [*Rohit Singh Rathaur, BIT Mesra and Girish L., CIT GUBBI, Karnataka*]\n", + "\n", + "Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "you may not use this file except in compliance with the License.\n", + "You may obtain a copy of the License at\n", + "\n", + " http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "Unless required by applicable law or agreed to in writing, software\n", + "distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "See the License for the specific language governing permissions and\n", + "limitations under the License." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sV1Drb9ccUFw" + }, + "source": [ + "We mounted the drive to access the data" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YQ6lT1e2hrx4", + "outputId": "df8b6b61-66a0-4bca-9ec5-c21216f5b46d" + }, + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yhhkDCI7cc43" + }, + "source": [ + "We are importing libraries to read the CSV and to train the models" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tLhroy5BnMnC" + }, + "source": [ + "# Importing libraries\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import pandas as pd\n", + "import numpy as np\n", + "import os" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9wFIhTogcl4z" + }, + "source": [ + "We are reading CSV file using `read_csv` function and dropping the `Timestamp` column and storing it in a DataFrame called `df_Ellis`." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "2-UpMVsSnfCI", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 419 + }, + "outputId": "38b85609-e8c4-493f-ee6d-43d1b627db7f" + }, + "source": [ + "df_Ellis = pd.read_csv(\"/content/drive/MyDrive/Failure/lstm/Ellis_FinalTwoConditionwithOR.csv\")\n", + "df_Ellis=df_Ellis.drop(columns='Timestamp')\n", + "df_Ellis" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>ellis-cpu.system_perc</th>\n", + " <th>ellis-cpu.wait_perc</th>\n", + " <th>ellis-load.avg_1_min</th>\n", + " <th>ellis-mem.free_mb</th>\n", + " <th>ellis-net.in_bytes_sec</th>\n", + " <th>ellis-net.out_packets_sec</th>\n", + " <th>Label</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>0.5</td>\n", + " <td>12.9</td>\n", + " <td>1.730</td>\n", + " <td>3949</td>\n", + " <td>5413.200</td>\n", + " <td>62.067</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>0.4</td>\n", + " <td>10.3</td>\n", + " <td>1.790</td>\n", + " <td>3950</td>\n", + " <td>5201.667</td>\n", + " <td>59.567</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>0.4</td>\n", + " <td>11.8</td>\n", + " <td>1.520</td>\n", + " <td>3950</td>\n", + " <td>5370.733</td>\n", + " <td>61.200</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>0.4</td>\n", + " <td>12.9</td>\n", + " <td>1.430</td>\n", + " <td>3949</td>\n", + " <td>5292.467</td>\n", + " <td>60.400</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>0.5</td>\n", + " <td>12.1</td>\n", + " <td>1.440</td>\n", + " <td>3950</td>\n", + " <td>5318.167</td>\n", + " <td>61.700</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>176995</th>\n", + " <td>0.4</td>\n", + " <td>0.3</td>\n", + " <td>0.030</td>\n", + " <td>3484</td>\n", + " <td>230.967</td>\n", + " <td>2.167</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>176996</th>\n", + " <td>0.2</td>\n", + " <td>0.3</td>\n", + " <td>0.018</td>\n", + " <td>3484</td>\n", + " <td>218.433</td>\n", + " <td>0.767</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>176997</th>\n", + " <td>0.6</td>\n", + " <td>0.3</td>\n", + " <td>0.010</td>\n", + " <td>3483</td>\n", + " <td>160.967</td>\n", + " <td>1.867</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>176998</th>\n", + " <td>0.6</td>\n", + " <td>0.3</td>\n", + " <td>0.007</td>\n", + " <td>3484</td>\n", + " <td>188.367</td>\n", + " <td>2.100</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>176999</th>\n", + " <td>0.4</td>\n", + " <td>0.1</td>\n", + " <td>0.040</td>\n", + " <td>3484</td>\n", + " <td>229.833</td>\n", + " <td>2.400</td>\n", + " <td>0</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>177000 rows × 7 columns</p>\n", + "</div>" + ], + "text/plain": [ + " ellis-cpu.system_perc ... Label\n", + "0 0.5 ... 1\n", + "1 0.4 ... 1\n", + "2 0.4 ... 1\n", + "3 0.4 ... 1\n", + "4 0.5 ... 1\n", + "... ... ... ...\n", + "176995 0.4 ... 0\n", + "176996 0.2 ... 0\n", + "176997 0.6 ... 0\n", + "176998 0.6 ... 0\n", + "176999 0.4 ... 0\n", + "\n", + "[177000 rows x 7 columns]" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o9SAQoIodC1V" + }, + "source": [ + "First we stored the `feature_cols` and defined the `X` matrix and `y` vector where `X` is a matrix and containing all the feature matrix and `y` is a vector which is having target value." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "27TqMF9VNQgh" + }, + "source": [ + "\n", + "# define X and y\n", + "feature_cols = ['ellis-cpu.wait_perc',\t'ellis-load.avg_1_min',\t'ellis-net.in_bytes_sec','ellis-cpu.system_perc','ellis-mem.free_mb']\n", + "\n", + "# X is a matrix, hence we use [] to access the features we want in feature_cols\n", + "X = df_Ellis[feature_cols]\n", + "\n", + "# y is a vector, hence we use dot to access 'label'\n", + "y = df_Ellis.Label" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lBGYYW2Fdsra" + }, + "source": [ + "We splitted `X` and `y` into `X_train`, `X_test`, `y_train`, and `y_test` using `train_test_split` function." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6YiG55Z8NqJR" + }, + "source": [ + "# split X and y into training and testing sets\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=5)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UfHBs8eweLT_" + }, + "source": [ + "We are training the model with Decision Tree." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r1LWPgeBNvMA", + "outputId": "3fb01e3e-9d22-4547-b5ec-355821675af6" + }, + "source": [ + "# train a logistic regression model on the training set\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn import tree\n", + "\n", + "# instantiate model\n", + "logreg=tree.DecisionTreeClassifier()\n", + "\n", + "# fit model\n", + "logreg.fit(X_train, y_train)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='gini',\n", + " max_depth=None, max_features=None, max_leaf_nodes=None,\n", + " min_impurity_decrease=0.0, min_impurity_split=None,\n", + " min_samples_leaf=1, min_samples_split=2,\n", + " min_weight_fraction_leaf=0.0, presort='deprecated',\n", + " random_state=None, splitter='best')" + ] + }, + "metadata": {}, + "execution_count": 119 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "koopvyUxe1BR" + }, + "source": [ + "We are making predictions for test set" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YNrCzlWVODRZ" + }, + "source": [ + "# make class predictions for the testing set\n", + "y_pred_class = logreg.predict(X_test)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "61cWU-hAejuK" + }, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r9XsgzK6e8Sj" + }, + "source": [ + "Here, we are calculating the accuracy using `sklearn` library" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nrmeurYhOF9A", + "outputId": "af9f0179-2e24-4b85-e702-09f8cf5dd176" + }, + "source": [ + "# calculate accuracy\n", + "from sklearn import metrics\n", + "print(metrics.accuracy_score(y_test, y_pred_class))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.6620338983050847\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "We67ligTfEyz" + }, + "source": [ + "We are examining the class distribution of the testing set using a `pandas` series method" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zdWWQ7p9OLuA", + "outputId": "d30b7eed-a72b-42dc-946b-6ce13f9d46e1" + }, + "source": [ + "# examine the class distribution of the testing set (using a Pandas Series method)\n", + "y_test.value_counts()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 33686\n", + "1 19414\n", + "Name: Label, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 122 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2mHqdHaOfPHh" + }, + "source": [ + "We counted the value for each lables" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5y6mGyYwOQf4", + "outputId": "d8aaf9cc-eb8a-417e-8804-4613e034e8a1" + }, + "source": [ + "y_train.value_counts()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 78460\n", + "1 45440\n", + "Name: Label, dtype: int64" + ] + }, + "metadata": {}, + "execution_count": 123 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gHYoAXK3fUNr" + }, + "source": [ + "We are calculating the percentage of ones because `y_test` only contains ones and zeroes, we can simply calculate the mean = percentage of ones" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bGLlh0lVOVMp", + "outputId": "f389d7cb-bf0b-4cf5-8b5b-6bf962c68717" + }, + "source": [ + "# calculate the percentage of ones\n", + "# because y_test only contains ones and zeros, we can simply calculate the mean = percentage of ones\n", + "y_test.mean()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.3656120527306968" + ] + }, + "metadata": {}, + "execution_count": 124 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vjerEaxJfhAw" + }, + "source": [ + "We are calculating the percentage of zeros" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GbU1cj6OOcGq", + "outputId": "8d1936a2-35c3-4813-be8f-9873c680f59f" + }, + "source": [ + "# calculate the percentage of zeros\n", + "1 - y_test.mean()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.6343879472693033" + ] + }, + "metadata": {}, + "execution_count": 125 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t8w_x6f4OgCL", + "outputId": "23b3fc85-aa56-4060-922d-cdb04dcbf75e" + }, + "source": [ + "# calculate null accuracy in a single line of code\n", + "# only for binary classification problems coded as 0/1\n", + "max(y_test.mean(), 1 - y_test.mean())" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.6343879472693033" + ] + }, + "metadata": {}, + "execution_count": 126 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iEsa9XIwOkX5", + "outputId": "9f890113-031a-48ef-f497-644550336b88" + }, + "source": [ + "# calculate null accuracy (for multi-class classification problems)\n", + "y_test.value_counts().head(1) / len(y_test)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 0.634388\n", + "Name: Label, dtype: float64" + ] + }, + "metadata": {}, + "execution_count": 127 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uYAoMBHPOqPB", + "outputId": "58da15d1-50c6-42cb-d09c-3f719e333b79" + }, + "source": [ + "\n", + "# print the first 25 true and predicted responses\n", + "print('True:', y_test.values[0:50])\n", + "print('False:', y_pred_class[0:50])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "True: [0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 1 1 1 0 0 0 1 0 0\n", + " 0 0 0 1 1 0 0 1 1 1 0 0 1]\n", + "False: [0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 0 1 1 1 0 0 1 1 0 1 0 0 0 0 0 0 0\n", + " 0 0 0 1 1 1 1 0 0 0 0 0 0]\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "puC1RxKmOw8C", + "outputId": "30df8b66-f7dc-4cb4-c869-179e2630c240" + }, + "source": [ + "# IMPORTANT: first argument is true values, second argument is predicted values\n", + "# this produces a 2x2 numpy array (matrix)\n", + "print(metrics.confusion_matrix(y_test, y_pred_class))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[24355 9331]\n", + " [ 8615 10799]]\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eXqJUVOlPA_z", + "outputId": "bbfb9a96-d2fc-4726-e4af-d87fcd9ef7ee" + }, + "source": [ + "# save confusion matrix and slice into four pieces\n", + "confusion = metrics.confusion_matrix(y_test, y_pred_class)\n", + "print(confusion)\n", + "#[row, column]\n", + "TP = confusion[1, 1]\n", + "TN = confusion[0, 0]\n", + "FP = confusion[0, 1]\n", + "FN = confusion[1, 0]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[24355 9331]\n", + " [ 8615 10799]]\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "klBfDQSgPG4C", + "outputId": "9928f546-6f0b-4aa9-e647-6a0c0487f798" + }, + "source": [ + "\n", + "# use float to perform true division, not integer division\n", + "print((TP + TN) / float(TP + TN + FP + FN))\n", + "print(metrics.accuracy_score(y_test, y_pred_class))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.6620338983050847\n", + "0.6620338983050847\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aeoA5XY_fyfU" + }, + "source": [ + "We are defining a function `print_results` to print the result of `y_test` and `y_pred`." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "D8GDuytFHL0o" + }, + "source": [ + "def print_results(y_test, y_pred):\n", + " \n", + " #f1-score\n", + " f1 = metrics.f1_score(y_test, y_pred)\n", + " print(\"F1 Score: \", f1)\n", + " print(classification_report(y_test, y_pred))\n", + " \n", + " conf_matrix = metrics.confusion_matrix(y_test, y_pred)\n", + " plt.figure(figsize=(12,12))\n", + " plt.subplot(221)\n", + " sns.heatmap(conf_matrix, fmt = \"d\",annot=True, cmap='Blues')\n", + " b, t = plt.ylim()\n", + " plt.ylim(b + 0.5, t - 0.5)\n", + " plt.title('Confuion Matrix')\n", + " plt.ylabel('True Values')\n", + " plt.xlabel('Predicted Values')\n", + "\n", + " #roc_auc_score\n", + " model_roc_auc = metrics.roc_auc_score(y_test, y_pred) \n", + " print (\"Area under curve : \",model_roc_auc,\"\\n\")\n", + " fpr,tpr,thresholds = metrics.roc_curve(y_test, y_pred)\n", + " gmeans = np.sqrt(tpr * (1-fpr))\n", + " ix = np.argmax(gmeans)\n", + " threshold = np.round(thresholds[ix],3)\n", + "\n", + " plt.subplot(222)\n", + " plt.plot(fpr, tpr, color='darkorange', lw=1, label = \"Auc : %.3f\" %model_roc_auc)\n", + " plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + " plt.scatter(fpr[ix], tpr[ix], marker='o', color='black', label='Best Threshold:' + str(threshold))\n", + " plt.xlim([0.0, 1.0])\n", + " plt.ylim([0.0, 1.05])\n", + " plt.xlabel('False Positive Rate')\n", + " plt.ylabel('True Positive Rate')\n", + " plt.title('Receiver operating characteristic')\n", + " plt.legend(loc=\"lower right\")" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 578 + }, + "id": "X2tMErOPHQZQ", + "outputId": "f6e44631-e5fe-4423-9cae-b6bed5c7a874" + }, + "source": [ + "import sklearn.metrics as metrics\n", + "import seaborn as sns\n", + "\n", + "from sklearn.metrics import classification_report\n", + "print_results(y_test, y_pred_class)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "F1 Score: 0.5461764110863848\n", + " precision recall f1-score support\n", + "\n", + " 0 0.74 0.72 0.73 33686\n", + " 1 0.54 0.56 0.55 19414\n", + "\n", + " accuracy 0.66 53100\n", + " macro avg 0.64 0.64 0.64 53100\n", + "weighted avg 0.66 0.66 0.66 53100\n", + "\n", + "Area under curve : 0.6396243607472745 \n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 864x864 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-NpF2Zc4lIdW" + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + } + ] +}
\ No newline at end of file |