code_jupyter_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sb\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from IPython.display import display, Markdown, Latex\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, classification_report, f1_score, roc_curve\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyse(df, string):\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(df, target, test_size = 0.25, random_state = 25)\n",
    "    str = \"Accuracy, Precision, Recall, F1 Score for:  \"+string\n",
    "    \n",
    "    display(Markdown('## '+str))\n",
    "    # RandomForestClassifier\n",
    "    model = RandomForestClassifier(random_state = 25)\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    y_pred = model.predict(X_test)\n",
    "    acc = round(accuracy_score(y_pred, y_test)*100, 2)\n",
    "    prec = round(precision_score(y_pred, y_test)*100, 2)\n",
    "    recall = round(recall_score(y_pred, y_test)*100, 2)\n",
    "    f1 = round(f1_score(y_pred, y_test)*100, 2)\n",
    "    \n",
    "    display(Markdown(\"### Random Forest Classifier\"))\n",
    "    print(\"Accuracy:\",acc)\n",
    "    print(\"Precision:\",prec)\n",
    "    print(\"Recall:\",recall)\n",
    "    print(\"F1 Score:\",f1)\n",
    "    # Decision Tree\n",
    "\n",
    "    model = DecisionTreeClassifier(random_state = 25)\n",
    "\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    y_pred = model.predict(X_test)\n",
    "    \n",
    "    acc = round(accuracy_score(y_pred, y_test)*100, 2)\n",
    "    prec = round(precision_score(y_pred, y_test)*100, 2)\n",
    "    recall = round(recall_score(y_pred, y_test)*100, 2)\n",
    "    f1 = round(f1_score(y_pred, y_test)*100, 2)\n",
    "\n",
    "    display(Markdown(\"### Decision tree Classifier\"))\n",
    "    print(\"Accuracy:\",acc)\n",
    "    print(\"Precision:\",prec)\n",
    "    print(\"Recall:\",recall)\n",
    "    print(\"F1 Score:\",f1,\"\\n\")\n",
    "    \n",
    "    display(Markdown(\"### ROC Curve\"))\n",
    "    y_pred_proba = model.predict_proba(X_test)\n",
    "    fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba[:,1])\n",
    "\n",
    "    plt.plot(fpr, tpr)\n",
    "    plt.plot([0, 1], [0, 1], linestyle='--')\n",
    "    plt.xlim([0.0, 1.0])\n",
    "    plt.ylim([0.0, 1.0])\n",
    "    plt.xlabel('1 - specificity')\n",
    "    plt.ylabel('sensitivity')\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    cm = confusion_matrix(y_test, y_pred, labels = [1,0])\n",
    "    \n",
    "    display(Markdown(\"### Classification Report\"))\n",
    "    print(classification_report(y_test, y_pred))\n",
    "    \n",
    "    display(Markdown(\"### Confusion Matrix\"))\n",
    "    ax = sb.heatmap(cm, annot=True, fmt='g') \n",
    "    bottom, top = ax.get_ylim()\n",
    "    ax.set_ylim(bottom + 0.5, top - 0.5)\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load dataset\n",
    "df = pd.read_csv('data/dataset.csv')\n",
    "\n",
    "# ip and target (numpy arrays)\n",
    "df_ip = df['IP'].values\n",
    "target = df['target'].values\n",
    "\n",
    "# separate the 4 octets\n",
    "arr = np.array(list(map(lambda x: x.split('.'), df_ip))).astype(np.int)\n",
    "\n",
    "# convert numpy array `arr` to pandas DataFrame\n",
    "new_df = pd.DataFrame(data = arr, columns = ['X1', 'X2', 'X3', 'X4'])\n",
    "\n",
    "\n",
    "# ---- Feature Extraction ----\n",
    "\n",
    "# Adding new features according to Octet Method\n",
    "new_df['N2'] = 256 + new_df['X2']\n",
    "new_df['N3'] = 512 + new_df['X3']\n",
    "new_df['N4'] = 768 + new_df['X4']\n",
    "\n",
    "# Additional features according to Ex-Octet Method\n",
    "new_df['N5'] = 768 + (new_df['X1']+new_df['X2'])%256\n",
    "new_df['N6'] = 1024 + (new_df['X1']+new_df['X2']+new_df['X3'])%256\n",
    "new_df['N7'] = 1280 + (new_df['X1']+new_df['X2']+new_df['X3']+new_df['X4'])%256\n",
    "new_df['target'] = df['target']\n",
    "\n",
    "\n",
    "# final dataframe used for train/test\n",
    "\n",
    "df0 = new_df[['X1']].values\n",
    "df1 = new_df[['X1', 'N2']].values\n",
    "df2 = new_df[['X1', 'N2', 'N3']].values\n",
    "df3 = new_df[['X1', 'N2', 'N3', 'N4']].values\n",
    "df4 = new_df[['X1', 'N2', 'N3', 'N4', 'N5']].values\n",
    "df5 = new_df[['X1', 'N2', 'N3', 'N4', 'N5', 'N6']].values\n",
    "df6 = new_df[['X1', 'N2', 'N3', 'N4', 'N5', 'N6', 'N7']].values\n",
    "\n",
    "df7 = new_df[['X1', 'X2']].values\n",
    "df8 = new_df[['X1', 'X2', 'X3']].values\n",
    "df9 = new_df[['X1', 'X2', 'X3', 'X4']].values\n",
    "\n",
    "df10 = new_df[['X1', 'X2', 'N2']].values\n",
    "df11 = new_df[['X1', 'X2', 'N3']].values\n",
    "df12 = new_df[['X1', 'X2', 'N4']].values\n",
    "df13 = new_df[['X1', 'X2', 'N2', 'N3']].values\n",
    "df14 = new_df[['X1', 'X2', 'N2', 'N3', 'N4']].values\n",
    "\n",
    "df15 = new_df[['X1', 'X2', 'X3', 'N2', 'N3']].values\n",
    "\n",
    "df27 = new_df[['X1', 'X2', 'N5']].values\n",
    "df28 = new_df[['X1', 'X2', 'N6']].values\n",
    "df29 = new_df[['X1', 'X2', 'N7']].values\n",
    "\n",
    "df30 = new_df[['X1', 'X2', 'X3', 'N6']].values\n",
    "df31 = new_df[['X1', 'X2', 'X3', 'X4', 'N7']].values\n",
    "\n",
    "df32 = new_df[['X1', 'N2', 'N5']].values\n",
    "df33 = new_df[['X1', 'N2', 'N6']].values\n",
    "df34 = new_df[['X1', 'N2', 'N7']].values\n",
    "\n",
    "df35 = new_df[['X1', 'N2', 'N3', 'N6']].values\n",
    "df36 = new_df[['X1', 'N2', 'N3', 'N4', 'N7']].values\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Accuracy, Precision, Recall, F1 Score for:  X1, X2"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "### Random Forest Classifier"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 91.37\n",
      "Precision: 79.45\n",
      "Recall: 85.67\n",
      "F1 Score: 82.45\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Decision tree Classifier"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 91.5\n",
      "Precision: 79.65\n",
      "Recall: 86.01\n",
      "F1 Score: 82.71 \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### ROC Curve"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "### Classification Report"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.93      0.96      0.94     17663\n",
      "           1       0.86      0.80      0.83      6050\n",
      "\n",
      "    accuracy                           0.92     23713\n",
      "   macro avg       0.90      0.88      0.89     23713\n",
      "weighted avg       0.91      0.92      0.91     23713\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Confusion Matrix"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We have tried many permutations and combinations and thereafter finalised the feature set which gave us the best results\n",
    "\n",
    "# analyse(df0, 'X1')\n",
    "# analyse(df1, 'X1, N2')\n",
    "# analyse(df2, 'X1, N2, N3')\n",
    "# analyse(df3, 'X1, N2, N3, N4')\n",
    "# analyse(df4, 'X1, N2, N3, N4, N5')\n",
    "# analyse(df5, 'X1, N2, N3, N4, N5, N6')\n",
    "# analyse(df6, 'X1, N2, N3, N4, N5, N6, N7')\n",
    "\n",
    "analyse(df7, 'X1, X2') # gives best results\n",
    "# analyse(df8, 'X1, X2, X3')\n",
    "# analyse(df9, 'X1, X2, X3, X4')\n",
    "\n",
    "# analyse(df10, 'X1, X2, N2')\n",
    "# analyse(df11, 'X1, X2, N3') \n",
    "# analyse(df12, 'X1, X2, N4')\n",
    "# analyse(df13, 'X1, X2, N2, N3')\n",
    "# analyse(df14, 'X1, X2, N2, N3, N4')\n",
    "\n",
    "# analyse(df15, 'X1, X2, X3, N2, N3')\n",
    "\n",
    "# analyse(df27, 'X1, X2, N5') # gives best results\n",
    "\n",
    "# analyse(df28, 'X1, X2, N6')\n",
    "# analyse(df29, 'X1, X2, N7')\n",
    "\n",
    "# analyse(df30, 'X1, X2, X3, N6')\n",
    "# analyse(df31, 'X1, X2, X3, X4, N7')\n",
    "\n",
    "# analyse(df32, 'X1, N2, N5')\n",
    "# analyse(df33, 'X1, N2, N6')\n",
    "# analyse(df34, 'X1, N2, N7')\n",
    "\n",
    "# analyse(df35, 'X1, N2, N3, N6')\n",
    "# analyse(df36, 'X1, N2, N3, N4, N7')\n"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}