usnw_nb15.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from numpy import array\n",
    "\n",
    "import time\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as s\n",
    "\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
    "from sklearn.metrics import mean_squared_error,mean_absolute_error, roc_auc_score\n",
    "from sklearn.preprocessing import LabelEncoder, OneHotEncoder, MinMaxScaler\n",
    "from sklearn.feature_selection import SelectKBest, chi2\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "\n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "from sklearn import datasets, svm\n",
    "from sklearn.feature_selection import RFE, mutual_info_classif\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.linear_model import LassoCV\n",
    "\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the training and testing data sets\n",
    "file = os.getcwd();\n",
    "\n",
    "trainfile = file + '/UNSW_NB15_training-set.csv' \n",
    "train = pd.read_csv(trainfile)\n",
    "\n",
    "testfile = file + '/UNSW_NB15_testing-set.csv'\n",
    "test = pd.read_csv(testfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine the training and testing data sets\n",
    "total = pd.concat([train, test], axis=0)\n",
    "# Replace the 'Normal' and 'Attack' labels with 0 and 1\n",
    "total['label'] = total['label'].replace([0,1], ['Normal', 'Attack'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attack    164673\n",
      "Normal     93000\n",
      "Name: label, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='label'>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Print the stats for the combined data sets, print a pie chart\n",
    "print(total['label'].value_counts())\n",
    "total['label'].value_counts().plot(kind='pie')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "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>id</th>\n",
       "      <th>dur</th>\n",
       "      <th>spkts</th>\n",
       "      <th>dpkts</th>\n",
       "      <th>sbytes</th>\n",
       "      <th>dbytes</th>\n",
       "      <th>rate</th>\n",
       "      <th>sttl</th>\n",
       "      <th>dttl</th>\n",
       "      <th>sload</th>\n",
       "      <th>...</th>\n",
       "      <th>ct_dst_ltm</th>\n",
       "      <th>ct_src_dport_ltm</th>\n",
       "      <th>ct_dst_sport_ltm</th>\n",
       "      <th>ct_dst_src_ltm</th>\n",
       "      <th>is_ftp_login</th>\n",
       "      <th>ct_ftp_cmd</th>\n",
       "      <th>ct_flw_http_mthd</th>\n",
       "      <th>ct_src_ltm</th>\n",
       "      <th>ct_srv_dst</th>\n",
       "      <th>is_sm_ips_ports</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>2.576730e+05</td>\n",
       "      <td>2.576730e+05</td>\n",
       "      <td>2.576730e+05</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>2.576730e+05</td>\n",
       "      <td>...</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "      <td>257673.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>72811.823858</td>\n",
       "      <td>1.246715</td>\n",
       "      <td>19.777144</td>\n",
       "      <td>18.514703</td>\n",
       "      <td>8.572952e+03</td>\n",
       "      <td>1.438729e+04</td>\n",
       "      <td>9.125391e+04</td>\n",
       "      <td>180.000931</td>\n",
       "      <td>84.754957</td>\n",
       "      <td>7.060869e+07</td>\n",
       "      <td>...</td>\n",
       "      <td>6.050467</td>\n",
       "      <td>5.238271</td>\n",
       "      <td>4.032677</td>\n",
       "      <td>8.322964</td>\n",
       "      <td>0.012819</td>\n",
       "      <td>0.012850</td>\n",
       "      <td>0.132005</td>\n",
       "      <td>6.800045</td>\n",
       "      <td>9.121049</td>\n",
       "      <td>0.014274</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>48929.917641</td>\n",
       "      <td>5.974305</td>\n",
       "      <td>135.947152</td>\n",
       "      <td>111.985965</td>\n",
       "      <td>1.737739e+05</td>\n",
       "      <td>1.461993e+05</td>\n",
       "      <td>1.603446e+05</td>\n",
       "      <td>102.488268</td>\n",
       "      <td>112.762131</td>\n",
       "      <td>1.857313e+08</td>\n",
       "      <td>...</td>\n",
       "      <td>8.173749</td>\n",
       "      <td>8.160822</td>\n",
       "      <td>5.831515</td>\n",
       "      <td>11.120754</td>\n",
       "      <td>0.116091</td>\n",
       "      <td>0.116421</td>\n",
       "      <td>0.681854</td>\n",
       "      <td>8.396266</td>\n",
       "      <td>10.874752</td>\n",
       "      <td>0.118618</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>2.400000e+01</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>32210.000000</td>\n",
       "      <td>0.000008</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.140000e+02</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>3.078928e+01</td>\n",
       "      <td>62.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.231800e+04</td>\n",
       "      <td>...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>64419.000000</td>\n",
       "      <td>0.004285</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>5.280000e+02</td>\n",
       "      <td>1.780000e+02</td>\n",
       "      <td>2.955665e+03</td>\n",
       "      <td>254.000000</td>\n",
       "      <td>29.000000</td>\n",
       "      <td>7.439423e+05</td>\n",
       "      <td>...</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>110923.000000</td>\n",
       "      <td>0.685777</td>\n",
       "      <td>12.000000</td>\n",
       "      <td>10.000000</td>\n",
       "      <td>1.362000e+03</td>\n",
       "      <td>1.064000e+03</td>\n",
       "      <td>1.250000e+05</td>\n",
       "      <td>254.000000</td>\n",
       "      <td>252.000000</td>\n",
       "      <td>8.000000e+07</td>\n",
       "      <td>...</td>\n",
       "      <td>6.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>175341.000000</td>\n",
       "      <td>59.999989</td>\n",
       "      <td>10646.000000</td>\n",
       "      <td>11018.000000</td>\n",
       "      <td>1.435577e+07</td>\n",
       "      <td>1.465753e+07</td>\n",
       "      <td>1.000000e+06</td>\n",
       "      <td>255.000000</td>\n",
       "      <td>254.000000</td>\n",
       "      <td>5.988000e+09</td>\n",
       "      <td>...</td>\n",
       "      <td>59.000000</td>\n",
       "      <td>59.000000</td>\n",
       "      <td>46.000000</td>\n",
       "      <td>65.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>4.000000</td>\n",
       "      <td>30.000000</td>\n",
       "      <td>60.000000</td>\n",
       "      <td>62.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>8 rows × 40 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                  id            dur          spkts          dpkts  \\\n",
       "count  257673.000000  257673.000000  257673.000000  257673.000000   \n",
       "mean    72811.823858       1.246715      19.777144      18.514703   \n",
       "std     48929.917641       5.974305     135.947152     111.985965   \n",
       "min         1.000000       0.000000       1.000000       0.000000   \n",
       "25%     32210.000000       0.000008       2.000000       0.000000   \n",
       "50%     64419.000000       0.004285       4.000000       2.000000   \n",
       "75%    110923.000000       0.685777      12.000000      10.000000   \n",
       "max    175341.000000      59.999989   10646.000000   11018.000000   \n",
       "\n",
       "             sbytes        dbytes          rate           sttl           dttl  \\\n",
       "count  2.576730e+05  2.576730e+05  2.576730e+05  257673.000000  257673.000000   \n",
       "mean   8.572952e+03  1.438729e+04  9.125391e+04     180.000931      84.754957   \n",
       "std    1.737739e+05  1.461993e+05  1.603446e+05     102.488268     112.762131   \n",
       "min    2.400000e+01  0.000000e+00  0.000000e+00       0.000000       0.000000   \n",
       "25%    1.140000e+02  0.000000e+00  3.078928e+01      62.000000       0.000000   \n",
       "50%    5.280000e+02  1.780000e+02  2.955665e+03     254.000000      29.000000   \n",
       "75%    1.362000e+03  1.064000e+03  1.250000e+05     254.000000     252.000000   \n",
       "max    1.435577e+07  1.465753e+07  1.000000e+06     255.000000     254.000000   \n",
       "\n",
       "              sload  ...     ct_dst_ltm  ct_src_dport_ltm  ct_dst_sport_ltm  \\\n",
       "count  2.576730e+05  ...  257673.000000     257673.000000     257673.000000   \n",
       "mean   7.060869e+07  ...       6.050467          5.238271          4.032677   \n",
       "std    1.857313e+08  ...       8.173749          8.160822          5.831515   \n",
       "min    0.000000e+00  ...       1.000000          1.000000          1.000000   \n",
       "25%    1.231800e+04  ...       1.000000          1.000000          1.000000   \n",
       "50%    7.439423e+05  ...       2.000000          1.000000          1.000000   \n",
       "75%    8.000000e+07  ...       6.000000          4.000000          3.000000   \n",
       "max    5.988000e+09  ...      59.000000         59.000000         46.000000   \n",
       "\n",
       "       ct_dst_src_ltm   is_ftp_login     ct_ftp_cmd  ct_flw_http_mthd  \\\n",
       "count   257673.000000  257673.000000  257673.000000     257673.000000   \n",
       "mean         8.322964       0.012819       0.012850          0.132005   \n",
       "std         11.120754       0.116091       0.116421          0.681854   \n",
       "min          1.000000       0.000000       0.000000          0.000000   \n",
       "25%          1.000000       0.000000       0.000000          0.000000   \n",
       "50%          3.000000       0.000000       0.000000          0.000000   \n",
       "75%          8.000000       0.000000       0.000000          0.000000   \n",
       "max         65.000000       4.000000       4.000000         30.000000   \n",
       "\n",
       "          ct_src_ltm     ct_srv_dst  is_sm_ips_ports  \n",
       "count  257673.000000  257673.000000    257673.000000  \n",
       "mean        6.800045       9.121049         0.014274  \n",
       "std         8.396266      10.874752         0.118618  \n",
       "min         1.000000       1.000000         0.000000  \n",
       "25%         2.000000       2.000000         0.000000  \n",
       "50%         3.000000       4.000000         0.000000  \n",
       "75%         8.000000      11.000000         0.000000  \n",
       "max        60.000000      62.000000         1.000000  \n",
       "\n",
       "[8 rows x 40 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get summary stats for the features in the combined data set\n",
    "total.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encoding for non-numerical data\n",
    "service_ = LabelEncoder()\n",
    "proto_ = LabelEncoder()\n",
    "state_ = LabelEncoder()\n",
    "\n",
    "test['service_le'] = service_.fit_transform(test.service)\n",
    "test['proto_le'] = proto_.fit_transform(test.proto)\n",
    "test['state_le'] = state_.fit_transform(test.state)\n",
    "\n",
    "train['service_le'] = service_.fit_transform(train.service)\n",
    "train['proto_le'] = proto_.fit_transform(train.proto)\n",
    "train['state_le'] = state_.fit_transform(train.state)\n",
    "\n",
    "_service = OneHotEncoder()\n",
    "_proto = OneHotEncoder()\n",
    "_state = OneHotEncoder()\n",
    "\n",
    "service = _service.fit_transform(test.service_le.values.reshape(-1,1)).toarray()\n",
    "proto = _proto.fit_transform(test.proto_le.values.reshape(-1,1)).toarray()\n",
    "state = _state.fit_transform(test.state_le.values.reshape(-1,1)).toarray()\n",
    "\n",
    "oh = pd.DataFrame(service, columns = [\"service_\"+str(int(i)) for i in range(service.shape[1])])\n",
    "test = pd.concat([test, oh], axis=1)\n",
    "\n",
    "oh = pd.DataFrame(proto, columns = [\"proto_\"+str(int(i)) for i in range(proto.shape[1])])\n",
    "test = pd.concat([test, oh], axis=1)\n",
    "\n",
    "oh = pd.DataFrame(state, columns = [\"state_\"+str(int(i)) for i in range(state.shape[1])])\n",
    "test = pd.concat([test, oh], axis=1)\n",
    "\n",
    "service = _service.fit_transform(train.service_le.values.reshape(-1,1)).toarray()\n",
    "proto = _proto.fit_transform(train.proto_le.values.reshape(-1,1)).toarray()\n",
    "state = _state.fit_transform(train.state_le.values.reshape(-1,1)).toarray()\n",
    "\n",
    "oh = pd.DataFrame(service, columns = [\"service_\"+str(int(i)) for i in range(service.shape[1])])\n",
    "train = pd.concat([train, oh], axis=1)\n",
    "\n",
    "oh = pd.DataFrame(proto, columns = [\"proto_\"+str(int(i)) for i in range(proto.shape[1])])\n",
    "train = pd.concat([train, oh], axis=1)\n",
    "\n",
    "oh = pd.DataFrame(state, columns = [\"state_\"+str(int(i)) for i in range(state.shape[1])])\n",
    "train = pd.concat([train, oh], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "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>id</th>\n",
       "      <th>dur</th>\n",
       "      <th>proto</th>\n",
       "      <th>service</th>\n",
       "      <th>state</th>\n",
       "      <th>spkts</th>\n",
       "      <th>dpkts</th>\n",
       "      <th>sbytes</th>\n",
       "      <th>dbytes</th>\n",
       "      <th>rate</th>\n",
       "      <th>...</th>\n",
       "      <th>proto_128</th>\n",
       "      <th>proto_129</th>\n",
       "      <th>proto_130</th>\n",
       "      <th>state_0</th>\n",
       "      <th>state_1</th>\n",
       "      <th>state_2</th>\n",
       "      <th>state_3</th>\n",
       "      <th>state_4</th>\n",
       "      <th>state_5</th>\n",
       "      <th>state_6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000011</td>\n",
       "      <td>udp</td>\n",
       "      <td>-</td>\n",
       "      <td>INT</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>496</td>\n",
       "      <td>0</td>\n",
       "      <td>90909.0902</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>0.000008</td>\n",
       "      <td>udp</td>\n",
       "      <td>-</td>\n",
       "      <td>INT</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1762</td>\n",
       "      <td>0</td>\n",
       "      <td>125000.0003</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0.000005</td>\n",
       "      <td>udp</td>\n",
       "      <td>-</td>\n",
       "      <td>INT</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1068</td>\n",
       "      <td>0</td>\n",
       "      <td>200000.0051</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>0.000006</td>\n",
       "      <td>udp</td>\n",
       "      <td>-</td>\n",
       "      <td>INT</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>900</td>\n",
       "      <td>0</td>\n",
       "      <td>166666.6608</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>udp</td>\n",
       "      <td>-</td>\n",
       "      <td>INT</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2126</td>\n",
       "      <td>0</td>\n",
       "      <td>100000.0025</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 199 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   id       dur proto service state  spkts  dpkts  sbytes  dbytes  \\\n",
       "0   1  0.000011   udp       -   INT      2      0     496       0   \n",
       "1   2  0.000008   udp       -   INT      2      0    1762       0   \n",
       "2   3  0.000005   udp       -   INT      2      0    1068       0   \n",
       "3   4  0.000006   udp       -   INT      2      0     900       0   \n",
       "4   5  0.000010   udp       -   INT      2      0    2126       0   \n",
       "\n",
       "          rate  ...  proto_128  proto_129  proto_130  state_0  state_1  \\\n",
       "0   90909.0902  ...        0.0        0.0        0.0      0.0      0.0   \n",
       "1  125000.0003  ...        0.0        0.0        0.0      0.0      0.0   \n",
       "2  200000.0051  ...        0.0        0.0        0.0      0.0      0.0   \n",
       "3  166666.6608  ...        0.0        0.0        0.0      0.0      0.0   \n",
       "4  100000.0025  ...        0.0        0.0        0.0      0.0      0.0   \n",
       "\n",
       "   state_2  state_3  state_4  state_5  state_6  \n",
       "0      0.0      0.0      1.0      0.0      0.0  \n",
       "1      0.0      0.0      1.0      0.0      0.0  \n",
       "2      0.0      0.0      1.0      0.0      0.0  \n",
       "3      0.0      0.0      1.0      0.0      0.0  \n",
       "4      0.0      0.0      1.0      0.0      0.0  \n",
       "\n",
       "[5 rows x 199 columns]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove categorical data\n",
    "\n",
    "test.drop(columns=['proto','service','state'], inplace = True )\n",
    "test.shape\n",
    "\n",
    "train.drop(columns=['proto','service','state'], inplace = True )\n",
    "train.shape\n",
    "\n",
    "train.drop(columns='attack_cat', inplace = True )\n",
    "test.drop(columns='attack_cat', inplace = True )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize data\n",
    "\n",
    "trained = pd.DataFrame(MinMaxScaler().fit_transform(train), columns = list(train.columns))\n",
    "\n",
    "tested = pd.DataFrame(MinMaxScaler().fit_transform(test), columns = list(test.columns))\n",
    "\n",
    "\n",
    "ytest = tested['label']\n",
    "ytrain = trained['label']\n",
    "\n",
    "xtrain = trained\n",
    "xtest = tested\n",
    "\n",
    "xtest.drop(columns='label', inplace = True)\n",
    "xtrain.drop(columns='label', inplace = True)\n",
    "\n",
    "xtrain.drop(columns=['id'], inplace = True)\n",
    "xtest.drop(columns=['id'], inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select features with the best scores using mutual_info_classif \n",
    "best = SelectKBest(score_func = mutual_info_classif, k = 'all')\n",
    "\n",
    "i = tested.iloc[:,0:198]\n",
    "fit = best.fit(xtrain,ytrain)\n",
    "\n",
    "scores = pd.DataFrame(fit.scores_)\n",
    "cols = pd.DataFrame(i.columns)\n",
    "\n",
    "score = pd.concat([cols,scores],axis=1)\n",
    "score.columns = ['feature','score']\n",
    "\n",
    "k = score['feature']\n",
    "\n",
    "t5 = score.nlargest(5,'score')\n",
    "t10 = score.nlargest(10,'score')\n",
    "t20 = score.nlargest(20,'score')\n",
    "t50 = score.nlargest(50,'score')\n",
    "t100 = score.nlargest(100,'score')\n",
    "\n",
    "l5 = list(t5['feature'])\n",
    "l5 = [x for x in l5 if str(x) != 'nan']\n",
    "\n",
    "l10 = list(t10['feature'])\n",
    "l10 = [x for x in l10 if str(x) != 'nan']\n",
    "\n",
    "l20 = list(t20['feature'])\n",
    "l20 = [x for x in l20 if str(x) != 'nan']\n",
    "\n",
    "l50 = list(t50['feature'])\n",
    "l50 = [x for x in l50 if str(x) != 'nan']\n",
    "\n",
    "l100 = list(t100['feature'])\n",
    "l100 = [x for x in l100 if str(x) != 'nan']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select Top features\n",
    "\n",
    "xtest5 = tested[l5]\n",
    "xtrain5 = trained[l5]\n",
    "\n",
    "xtest10 = tested[l10]\n",
    "xtrain10 = trained[l10]\n",
    "\n",
    "xtest20 = tested[l20]\n",
    "xtrain20 = trained[l20]\n",
    "\n",
    "xtest50 = tested[l50]\n",
    "xtrain50 = trained[l50]\n",
    "\n",
    "xtest100 = tested[l100]\n",
    "xtrain100 = trained[l100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9736171232056393\n",
      "Test Accuracy  ::  0.8044259826070058\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.89      0.64      0.75     37000\n",
      "         1.0       0.76      0.93      0.84     45332\n",
      "\n",
      "    accuracy                           0.80     82332\n",
      "   macro avg       0.83      0.79      0.79     82332\n",
      "weighted avg       0.82      0.80      0.80     82332\n",
      "\n",
      "[[23863 13137]\n",
      " [ 2965 42367]]\n",
      "Time ::  0.999380350112915\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 5 estimators/features used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc5_5 = RandomForestClassifier(n_estimators = 5)\n",
    "rfc5_5.fit(xtrain5, ytrain)\n",
    "pred_rfc5_5 = rfc5_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc5_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc5_5))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc5_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc5_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9743756451714088\n",
      "Test Accuracy  ::  0.8189160958072196\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.95      0.63      0.76     37000\n",
      "         1.0       0.76      0.98      0.86     45332\n",
      "\n",
      "    accuracy                           0.82     82332\n",
      "   macro avg       0.86      0.80      0.81     82332\n",
      "weighted avg       0.85      0.82      0.81     82332\n",
      "\n",
      "[[23185 13815]\n",
      " [ 1094 44238]]\n",
      "Time ::  1.2458395957946777\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 5 estimators/features used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc5_10 = RandomForestClassifier(n_estimators = 5)\n",
    "rfc5_10.fit(xtrain10, ytrain)\n",
    "pred_rfc5_10 = rfc5_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc5_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc5_10))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc5_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc5_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9808088239487627\n",
      "Test Accuracy  ::  0.8166448039644366\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.95      0.63      0.75     37000\n",
      "         1.0       0.76      0.97      0.85     45332\n",
      "\n",
      "    accuracy                           0.82     82332\n",
      "   macro avg       0.85      0.80      0.80     82332\n",
      "weighted avg       0.84      0.82      0.81     82332\n",
      "\n",
      "[[23193 13807]\n",
      " [ 1289 44043]]\n",
      "Time ::  1.7518622875213623\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 5 estimators/features used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc5_20 = RandomForestClassifier(n_estimators = 5)\n",
    "rfc5_20.fit(xtrain20, ytrain)\n",
    "pred_rfc5_20 = rfc5_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc5_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc5_20))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc5_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc5_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9923862644789296\n",
      "Test Accuracy  ::  0.8323980955157169\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.65      0.78     37000\n",
      "         1.0       0.77      0.98      0.87     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.87      0.82      0.82     82332\n",
      "weighted avg       0.86      0.83      0.83     82332\n",
      "\n",
      "[[23968 13032]\n",
      " [  767 44565]]\n",
      "Time ::  1.8126075267791748\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 5 estimators/features used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc5_50 = RandomForestClassifier(n_estimators = 5)\n",
    "rfc5_50.fit(xtrain50, ytrain)\n",
    "pred_rfc5_50 = rfc5_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc5_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc5_50))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc5_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc5_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9906182809496923\n",
      "Test Accuracy  ::  0.8428800466404314\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.96      0.68      0.79     37000\n",
      "         1.0       0.79      0.98      0.87     45332\n",
      "\n",
      "    accuracy                           0.84     82332\n",
      "   macro avg       0.88      0.83      0.83     82332\n",
      "weighted avg       0.87      0.84      0.84     82332\n",
      "\n",
      "[[25003 11997]\n",
      " [  939 44393]]\n",
      "Time ::  1.9549529552459717\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 5 estimators/features used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc5_100 = RandomForestClassifier(n_estimators = 5)\n",
    "rfc5_100.fit(xtrain100, ytrain)\n",
    "pred_rfc5_100 = rfc5_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc5_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc5_100))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc5_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc5_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9783336470078304\n",
      "Test Accuracy  ::  0.8073410095710052\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.90      0.64      0.75     37000\n",
      "         1.0       0.76      0.94      0.84     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.83      0.79      0.80     82332\n",
      "weighted avg       0.83      0.81      0.80     82332\n",
      "\n",
      "[[23638 13362]\n",
      " [ 2500 42832]]\n",
      "Time ::  4.135732173919678\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 25 estimators/features used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc25_5 = RandomForestClassifier(n_estimators = 25)\n",
    "rfc25_5.fit(xtrain5, ytrain)\n",
    "pred_rfc25_5 = rfc25_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc25_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc25_5))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc25_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc25_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9791377943549997\n",
      "Test Accuracy  ::  0.8075717825389885\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.58      0.73     37000\n",
      "         1.0       0.74      0.99      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.86      0.79      0.79     82332\n",
      "weighted avg       0.85      0.81      0.80     82332\n",
      "\n",
      "[[21527 15473]\n",
      " [  370 44962]]\n",
      "Time ::  4.887283086776733\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 25 estimators/features used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc25_10 = RandomForestClassifier(n_estimators = 25)\n",
    "rfc25_10.fit(xtrain10, ytrain)\n",
    "pred_rfc25_10 = rfc25_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc25_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc25_10))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc25_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc25_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9862895728893983\n",
      "Test Accuracy  ::  0.8205922363115192\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.61      0.75     37000\n",
      "         1.0       0.76      0.99      0.86     45332\n",
      "\n",
      "    accuracy                           0.82     82332\n",
      "   macro avg       0.87      0.80      0.81     82332\n",
      "weighted avg       0.86      0.82      0.81     82332\n",
      "\n",
      "[[22713 14287]\n",
      " [  484 44848]]\n",
      "Time ::  7.508655786514282\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 25 estimators/features used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc25_20 = RandomForestClassifier(n_estimators = 25)\n",
    "rfc25_20.fit(xtrain20, ytrain)\n",
    "pred_rfc25_20 = rfc25_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc25_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc25_20))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc25_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc25_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9974221659509185\n",
      "Test Accuracy  ::  0.8333697711703834\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.64      0.78     37000\n",
      "         1.0       0.77      0.99      0.87     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.88      0.82      0.82     82332\n",
      "weighted avg       0.87      0.83      0.83     82332\n",
      "\n",
      "[[23713 13287]\n",
      " [  432 44900]]\n",
      "Time ::  8.684804677963257\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 25 estimators/features used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc25_50 = RandomForestClassifier(n_estimators = 25)\n",
    "rfc25_50.fit(xtrain50, ytrain)\n",
    "pred_rfc25_50 = rfc25_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc25_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc25_50))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc25_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc25_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9963100472793015\n",
      "Test Accuracy  ::  0.8274061118398679\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.63      0.77     37000\n",
      "         1.0       0.76      0.99      0.86     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.87      0.81      0.81     82332\n",
      "weighted avg       0.86      0.83      0.82     82332\n",
      "\n",
      "[[23181 13819]\n",
      " [  391 44941]]\n",
      "Time ::  9.109999656677246\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 25 estimators/features used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc25_100 = RandomForestClassifier(n_estimators = 25)\n",
    "rfc25_100.fit(xtrain100, ytrain)\n",
    "pred_rfc25_100 = rfc25_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc25_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc25_100))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc25_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc25_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9791434975276746\n",
      "Test Accuracy  ::  0.8063328960792887\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.90      0.64      0.75     37000\n",
      "         1.0       0.76      0.94      0.84     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.83      0.79      0.80     82332\n",
      "weighted avg       0.82      0.81      0.80     82332\n",
      "\n",
      "[[23717 13283]\n",
      " [ 2662 42670]]\n",
      "Time ::  8.267976999282837\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 50 estimators/features used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc50_5 = RandomForestClassifier(n_estimators = 50)\n",
    "rfc50_5.fit(xtrain5, ytrain)\n",
    "pred_rfc50_5 = rfc50_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc50_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc50_5))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc50_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc50_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.980917184229587\n",
      "Test Accuracy  ::  0.8088835446727882\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.58      0.73     37000\n",
      "         1.0       0.75      0.99      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.86      0.79      0.79     82332\n",
      "weighted avg       0.85      0.81      0.80     82332\n",
      "\n",
      "[[21600 15400]\n",
      " [  335 44997]]\n",
      "Time ::  9.876421928405762\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 50 estimators/features used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc50_10 = RandomForestClassifier(n_estimators = 50)\n",
    "rfc50_10.fit(xtrain10, ytrain)\n",
    "pred_rfc50_10 = rfc50_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc50_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc50_10))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc50_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc50_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9865861378684962\n",
      "Test Accuracy  ::  0.815150852645387\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.60      0.74     37000\n",
      "         1.0       0.75      0.99      0.86     45332\n",
      "\n",
      "    accuracy                           0.82     82332\n",
      "   macro avg       0.87      0.79      0.80     82332\n",
      "weighted avg       0.86      0.82      0.81     82332\n",
      "\n",
      "[[22035 14965]\n",
      " [  254 45078]]\n",
      "Time ::  15.25287938117981\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 50 estimators/features used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc50_20 = RandomForestClassifier(n_estimators = 50)\n",
    "rfc50_20.fit(xtrain20, ytrain)\n",
    "pred_rfc50_20 = rfc50_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc50_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc50_20))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc50_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc50_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9975989643038422\n",
      "Test Accuracy  ::  0.8338920468347666\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.64      0.78     37000\n",
      "         1.0       0.77      0.99      0.87     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.88      0.82      0.82     82332\n",
      "weighted avg       0.87      0.83      0.83     82332\n",
      "\n",
      "[[23659 13341]\n",
      " [  335 44997]]\n",
      "Time ::  17.547386407852173\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 50 estimators/features used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc50_50 = RandomForestClassifier(n_estimators = 50)\n",
    "rfc50_50.fit(xtrain50, ytrain)\n",
    "pred_rfc50_50 = rfc50_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc50_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc50_50))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc50_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc50_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9970001311729715\n",
      "Test Accuracy  ::  0.8297138415197007\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.63      0.77     37000\n",
      "         1.0       0.77      0.99      0.87     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.88      0.81      0.82     82332\n",
      "weighted avg       0.87      0.83      0.82     82332\n",
      "\n",
      "[[23278 13722]\n",
      " [  298 45034]]\n",
      "Time ::  16.060949087142944\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 50 estimators/features used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc50_100 = RandomForestClassifier(n_estimators = 50)\n",
    "rfc50_100.fit(xtrain100, ytrain)\n",
    "pred_rfc50_100 = rfc50_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc50_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc50_100))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc50_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc50_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9793145927079234\n",
      "Test Accuracy  ::  0.8179322742068698\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.92      0.65      0.76     37000\n",
      "         1.0       0.77      0.96      0.85     45332\n",
      "\n",
      "    accuracy                           0.82     82332\n",
      "   macro avg       0.85      0.80      0.81     82332\n",
      "weighted avg       0.84      0.82      0.81     82332\n",
      "\n",
      "[[23958 13042]\n",
      " [ 1948 43384]]\n",
      "Time ::  16.293118000030518\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 100 estimators/features used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc100_5 = RandomForestClassifier(n_estimators = 100)\n",
    "rfc100_5.fit(xtrain5, ytrain)\n",
    "pred_rfc100_5 = rfc100_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc100_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc100_5))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc100_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc100_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.980911481056912\n",
      "Test Accuracy  ::  0.8063693339163387\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.58      0.73     37000\n",
      "         1.0       0.74      0.99      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.79      0.79     82332\n",
      "weighted avg       0.85      0.81      0.79     82332\n",
      "\n",
      "[[21305 15695]\n",
      " [  247 45085]]\n",
      "Time ::  20.550424098968506\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 100 estimators/features used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc100_10 = RandomForestClassifier(n_estimators = 100)\n",
    "rfc100_10.fit(xtrain10, ytrain)\n",
    "pred_rfc100_10 = rfc100_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc100_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc100_10))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc100_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc100_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.987036688509818\n",
      "Test Accuracy  ::  0.8138633824029539\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.59      0.74     37000\n",
      "         1.0       0.75      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.79      0.80     82332\n",
      "weighted avg       0.86      0.81      0.80     82332\n",
      "\n",
      "[[21877 15123]\n",
      " [  202 45130]]\n",
      "Time ::  31.664016008377075\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 100 estimators/features used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc100_20 = RandomForestClassifier(n_estimators = 100)\n",
    "rfc100_20.fit(xtrain20, ytrain)\n",
    "pred_rfc100_20 = rfc100_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc100_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc100_20))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc100_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc100_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9977187309300164\n",
      "Test Accuracy  ::  0.828329203711801\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.62      0.77     37000\n",
      "         1.0       0.76      1.00      0.86     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.88      0.81      0.82     82332\n",
      "weighted avg       0.87      0.83      0.82     82332\n",
      "\n",
      "[[23079 13921]\n",
      " [  213 45119]]\n",
      "Time ::  32.46507716178894\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 100 estimators/features used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc100_50 = RandomForestClassifier(n_estimators = 100)\n",
    "rfc100_50.fit(xtrain50, ytrain)\n",
    "pred_rfc100_50 = rfc100_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc100_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc100_50))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc100_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc100_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9967663010932982\n",
      "Test Accuracy  ::  0.8266652091531846\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.62      0.76     37000\n",
      "         1.0       0.76      1.00      0.86     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.88      0.81      0.81     82332\n",
      "weighted avg       0.86      0.83      0.82     82332\n",
      "\n",
      "[[22950 14050]\n",
      " [  221 45111]]\n",
      "Time ::  15.509146928787231\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier with 100 estimators/features used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "rfc100_100 = RandomForestClassifier(n_estimators = 50)\n",
    "rfc100_100.fit(xtrain100, ytrain)\n",
    "pred_rfc100_100 = rfc100_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, rfc100_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_rfc100_100))\n",
    "\n",
    "print(classification_report(ytest, pred_rfc100_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_rfc100_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9206289458825945\n",
      "Test Accuracy  ::  0.7663241509983967\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      0.48      0.65     37000\n",
      "         1.0       0.70      1.00      0.82     45332\n",
      "\n",
      "    accuracy                           0.77     82332\n",
      "   macro avg       0.85      0.74      0.74     82332\n",
      "weighted avg       0.83      0.77      0.75     82332\n",
      "\n",
      "[[17822 19178]\n",
      " [   61 45271]]\n",
      "Time ::  0.9309992790222168\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 5 estimators used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc5_5 = AdaBoostClassifier(n_estimators = 5)\n",
    "abc5_5.fit(xtrain5, ytrain)\n",
    "pred_abc5_5 = abc5_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc5_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc5_5))\n",
    "\n",
    "print(classification_report(ytest, pred_abc5_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc5_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9130209135341991\n",
      "Test Accuracy  ::  0.7655589564203469\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.96      0.50      0.66     37000\n",
      "         1.0       0.71      0.98      0.82     45332\n",
      "\n",
      "    accuracy                           0.77     82332\n",
      "   macro avg       0.83      0.74      0.74     82332\n",
      "weighted avg       0.82      0.77      0.75     82332\n",
      "\n",
      "[[18393 18607]\n",
      " [  695 44637]]\n",
      "Time ::  1.1785995960235596\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 5 estimators used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc5_10 = AdaBoostClassifier(n_estimators = 5)\n",
    "abc5_10.fit(xtrain10, ytrain)\n",
    "pred_abc5_10 = abc5_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc5_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc5_10))\n",
    "\n",
    "print(classification_report(ytest, pred_abc5_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc5_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9130209135341991\n",
      "Test Accuracy  ::  0.7655589564203469\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.96      0.50      0.66     37000\n",
      "         1.0       0.71      0.98      0.82     45332\n",
      "\n",
      "    accuracy                           0.77     82332\n",
      "   macro avg       0.83      0.74      0.74     82332\n",
      "weighted avg       0.82      0.77      0.75     82332\n",
      "\n",
      "[[18393 18607]\n",
      " [  695 44637]]\n",
      "Time ::  1.8846850395202637\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 5 estimators used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc5_20 = AdaBoostClassifier(n_estimators = 5)\n",
    "abc5_20.fit(xtrain20, ytrain)\n",
    "pred_abc5_20 = abc5_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc5_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc5_20))\n",
    "\n",
    "print(classification_report(ytest, pred_abc5_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc5_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9226022436281304\n",
      "Test Accuracy  ::  0.7682917941990963\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.50      0.66     37000\n",
      "         1.0       0.71      0.99      0.82     45332\n",
      "\n",
      "    accuracy                           0.77     82332\n",
      "   macro avg       0.84      0.74      0.74     82332\n",
      "weighted avg       0.83      0.77      0.75     82332\n",
      "\n",
      "[[18332 18668]\n",
      " [  409 44923]]\n",
      "Time ::  2.6420600414276123\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 5 estimators used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc5_50 = AdaBoostClassifier(n_estimators = 5)\n",
    "abc5_50.fit(xtrain50, ytrain)\n",
    "pred_abc5_50 = abc5_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc5_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc5_50))\n",
    "\n",
    "print(classification_report(ytest, pred_abc5_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc5_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9226022436281304\n",
      "Test Accuracy  ::  0.7682917941990963\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.50      0.66     37000\n",
      "         1.0       0.71      0.99      0.82     45332\n",
      "\n",
      "    accuracy                           0.77     82332\n",
      "   macro avg       0.84      0.74      0.74     82332\n",
      "weighted avg       0.83      0.77      0.75     82332\n",
      "\n",
      "[[18332 18668]\n",
      " [  409 44923]]\n",
      "Time ::  3.332158088684082\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 5 estimators used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc5_100 = AdaBoostClassifier(n_estimators = 5)\n",
    "abc5_100.fit(xtrain100, ytrain)\n",
    "pred_abc5_100 = abc5_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc5_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc5_100))\n",
    "\n",
    "print(classification_report(ytest, pred_abc5_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc5_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9239653018974455\n",
      "Test Accuracy  ::  0.7864621289413594\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.53      0.69     37000\n",
      "         1.0       0.72      1.00      0.84     45332\n",
      "\n",
      "    accuracy                           0.79     82332\n",
      "   macro avg       0.86      0.76      0.76     82332\n",
      "weighted avg       0.84      0.79      0.77     82332\n",
      "\n",
      "[[19599 17401]\n",
      " [  180 45152]]\n",
      "Time ::  3.3430256843566895\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 25 estimators used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc25_5 = AdaBoostClassifier(n_estimators = 25)\n",
    "abc25_5.fit(xtrain5, ytrain)\n",
    "pred_abc25_5 = abc25_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc25_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc25_5))\n",
    "\n",
    "print(classification_report(ytest, pred_abc25_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc25_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.929200814413058\n",
      "Test Accuracy  ::  0.8031020745275227\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.57      0.72     37000\n",
      "         1.0       0.74      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.80     82332\n",
      "   macro avg       0.87      0.78      0.78     82332\n",
      "weighted avg       0.85      0.80      0.79     82332\n",
      "\n",
      "[[20951 16049]\n",
      " [  162 45170]]\n",
      "Time ::  4.756060361862183\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 25 estimators used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc25_10 = AdaBoostClassifier(n_estimators = 25)\n",
    "abc25_10.fit(xtrain10, ytrain)\n",
    "pred_abc25_10 = abc25_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc25_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc25_10))\n",
    "\n",
    "print(classification_report(ytest, pred_abc25_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc25_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9313566136841925\n",
      "Test Accuracy  ::  0.8061871447310888\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.57      0.73     37000\n",
      "         1.0       0.74      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.78      0.79     82332\n",
      "weighted avg       0.85      0.81      0.79     82332\n",
      "\n",
      "[[21183 15817]\n",
      " [  140 45192]]\n",
      "Time ::  7.840121269226074\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 25 estimators used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc25_20 = AdaBoostClassifier(n_estimators = 25)\n",
    "abc25_20.fit(xtrain20, ytrain)\n",
    "pred_abc25_20 = abc25_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc25_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc25_20))\n",
    "\n",
    "print(classification_report(ytest, pred_abc25_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc25_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9362898580480321\n",
      "Test Accuracy  ::  0.811555652723121\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.59      0.74     37000\n",
      "         1.0       0.75      0.99      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.79      0.80     82332\n",
      "weighted avg       0.85      0.81      0.80     82332\n",
      "\n",
      "[[21883 15117]\n",
      " [  398 44934]]\n",
      "Time ::  12.23608922958374\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 25 estimators used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc25_50 = AdaBoostClassifier(n_estimators = 25)\n",
    "abc25_50.fit(xtrain50, ytrain)\n",
    "pred_abc25_50 = abc25_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc25_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc25_50))\n",
    "\n",
    "print(classification_report(ytest, pred_abc25_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc25_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9362898580480321\n",
      "Test Accuracy  ::  0.811555652723121\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.59      0.74     37000\n",
      "         1.0       0.75      0.99      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.79      0.80     82332\n",
      "weighted avg       0.85      0.81      0.80     82332\n",
      "\n",
      "[[21883 15117]\n",
      " [  398 44934]]\n",
      "Time ::  15.51949954032898\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 25 estimators used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc25_100 = AdaBoostClassifier(n_estimators = 25)\n",
    "abc25_100.fit(xtrain100, ytrain)\n",
    "pred_abc25_100 = abc25_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc25_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc25_100))\n",
    "\n",
    "print(classification_report(ytest, pred_abc25_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc25_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9311684089859189\n",
      "Test Accuracy  ::  0.7801462371860273\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.51      0.68     37000\n",
      "         1.0       0.72      1.00      0.83     45332\n",
      "\n",
      "    accuracy                           0.78     82332\n",
      "   macro avg       0.86      0.76      0.76     82332\n",
      "weighted avg       0.84      0.78      0.76     82332\n",
      "\n",
      "[[18996 18004]\n",
      " [   97 45235]]\n",
      "Time ::  6.9728076457977295\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 50 estimators used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc50_5 = AdaBoostClassifier(n_estimators = 50)\n",
    "abc50_5.fit(xtrain5, ytrain)\n",
    "pred_abc50_5 = abc50_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc50_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc50_5))\n",
    "\n",
    "print(classification_report(ytest, pred_abc50_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc50_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9326284211907084\n",
      "Test Accuracy  ::  0.8049968420541224\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      0.57      0.72     37000\n",
      "         1.0       0.74      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.80     82332\n",
      "   macro avg       0.87      0.78      0.79     82332\n",
      "weighted avg       0.85      0.80      0.79     82332\n",
      "\n",
      "[[21049 15951]\n",
      " [  104 45228]]\n",
      "Time ::  9.239381313323975\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 50 estimators used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc50_10 = AdaBoostClassifier(n_estimators = 50)\n",
    "abc50_10.fit(xtrain10, ytrain)\n",
    "pred_abc50_10 = abc50_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc50_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc50_10))\n",
    "\n",
    "print(classification_report(ytest, pred_abc50_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc50_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9349667219874416\n",
      "Test Accuracy  ::  0.8065272312102221\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       1.00      0.57      0.73     37000\n",
      "         1.0       0.74      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.79      0.79     82332\n",
      "weighted avg       0.86      0.81      0.79     82332\n",
      "\n",
      "[[21176 15824]\n",
      " [  105 45227]]\n",
      "Time ::  15.587998390197754\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 50 estimators used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc50_20 = AdaBoostClassifier(n_estimators = 50)\n",
    "abc50_20.fit(xtrain20, ytrain)\n",
    "pred_abc50_20 = abc50_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc50_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc50_20))\n",
    "\n",
    "print(classification_report(ytest, pred_abc50_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc50_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.942449284536988\n",
      "Test Accuracy  ::  0.8275275712967012\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.64      0.77     37000\n",
      "         1.0       0.77      0.98      0.86     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.87      0.81      0.82     82332\n",
      "weighted avg       0.86      0.83      0.82     82332\n",
      "\n",
      "[[23525 13475]\n",
      " [  725 44607]]\n",
      "Time ::  24.37657070159912\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 50 estimators used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc50_50 = AdaBoostClassifier(n_estimators = 50)\n",
    "abc50_50.fit(xtrain50, ytrain)\n",
    "pred_abc50_50 = abc50_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc50_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc50_50))\n",
    "\n",
    "print(classification_report(ytest, pred_abc50_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc50_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.942449284536988\n",
      "Test Accuracy  ::  0.8275275712967012\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.64      0.77     37000\n",
      "         1.0       0.77      0.98      0.86     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.87      0.81      0.82     82332\n",
      "weighted avg       0.86      0.83      0.82     82332\n",
      "\n",
      "[[23525 13475]\n",
      " [  725 44607]]\n",
      "Time ::  30.553897619247437\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 50 estimators used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc50_100 = AdaBoostClassifier(n_estimators = 50)\n",
    "abc50_100.fit(xtrain100, ytrain)\n",
    "pred_abc50_100 = abc50_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc50_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc50_100))\n",
    "\n",
    "print(classification_report(ytest, pred_abc50_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc50_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9311284867771942\n",
      "Test Accuracy  ::  0.803077782636156\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.56      0.72     37000\n",
      "         1.0       0.74      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.80     82332\n",
      "   macro avg       0.87      0.78      0.78     82332\n",
      "weighted avg       0.85      0.80      0.79     82332\n",
      "\n",
      "[[20897 16103]\n",
      " [  110 45222]]\n",
      "Time ::  12.660365343093872\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 100 estimators used in the model, 5 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc100_5 = AdaBoostClassifier(n_estimators = 100)\n",
    "abc100_5.fit(xtrain5, ytrain)\n",
    "pred_abc100_5 = abc100_5.predict(xtest5)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc100_5.predict(xtrain5)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc100_5))\n",
    "\n",
    "print(classification_report(ytest, pred_abc100_5))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc100_5))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9346359379722939\n",
      "Test Accuracy  ::  0.8094422581742214\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.98      0.59      0.73     37000\n",
      "         1.0       0.75      0.99      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.86      0.79      0.79     82332\n",
      "weighted avg       0.85      0.81      0.80     82332\n",
      "\n",
      "[[21753 15247]\n",
      " [  442 44890]]\n",
      "Time ::  17.95105218887329\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 100 estimators used in the model, 10 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc100_10 = AdaBoostClassifier(n_estimators = 100)\n",
    "abc100_10.fit(xtrain10, ytrain)\n",
    "pred_abc100_10 = abc100_10.predict(xtest10)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc100_10.predict(xtrain10)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc100_10))\n",
    "\n",
    "print(classification_report(ytest, pred_abc100_10))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc100_10))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9357195407805362\n",
      "Test Accuracy  ::  0.8078997230724384\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.99      0.58      0.73     37000\n",
      "         1.0       0.74      1.00      0.85     45332\n",
      "\n",
      "    accuracy                           0.81     82332\n",
      "   macro avg       0.87      0.79      0.79     82332\n",
      "weighted avg       0.85      0.81      0.80     82332\n",
      "\n",
      "[[21342 15658]\n",
      " [  158 45174]]\n",
      "Time ::  32.27416181564331\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 100 estimators used in the model, 20 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc100_20 = AdaBoostClassifier(n_estimators = 100)\n",
    "abc100_20.fit(xtrain20, ytrain)\n",
    "pred_abc100_20 = abc100_20.predict(xtest20)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc100_20.predict(xtrain20)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc100_20))\n",
    "\n",
    "print(classification_report(ytest, pred_abc100_20))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc100_20))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9458369691059136\n",
      "Test Accuracy  ::  0.8353617062624495\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.65      0.78     37000\n",
      "         1.0       0.78      0.98      0.87     45332\n",
      "\n",
      "    accuracy                           0.84     82332\n",
      "   macro avg       0.87      0.82      0.82     82332\n",
      "weighted avg       0.86      0.84      0.83     82332\n",
      "\n",
      "[[24230 12770]\n",
      " [  785 44547]]\n",
      "Time ::  52.10533666610718\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 100 estimators used in the model, 50 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc100_50 = AdaBoostClassifier(n_estimators = 100)\n",
    "abc100_50.fit(xtrain50, ytrain)\n",
    "pred_abc100_50 = abc100_50.predict(xtest50)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc100_50.predict(xtrain50)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc100_50))\n",
    "\n",
    "print(classification_report(ytest, pred_abc100_50))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc100_50))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Accuracy ::  0.9454947787454161\n",
      "Test Accuracy  ::  0.8348515765437498\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.97      0.65      0.78     37000\n",
      "         1.0       0.78      0.98      0.87     45332\n",
      "\n",
      "    accuracy                           0.83     82332\n",
      "   macro avg       0.87      0.82      0.82     82332\n",
      "weighted avg       0.86      0.83      0.83     82332\n",
      "\n",
      "[[24090 12910]\n",
      " [  687 44645]]\n",
      "Time ::  61.9043755531311\n"
     ]
    }
   ],
   "source": [
    "# Ada Boost Classifier with 100 estimators used in the model, 100 best features\n",
    "tm = -time.time()\n",
    "\n",
    "abc100_100 = AdaBoostClassifier(n_estimators = 100)\n",
    "abc100_100.fit(xtrain100, ytrain)\n",
    "pred_abc100_100 = abc100_100.predict(xtest100)\n",
    "\n",
    "print (\"Train Accuracy :: \", accuracy_score(ytrain, abc100_100.predict(xtrain100)))\n",
    "print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_abc100_100))\n",
    "\n",
    "print(classification_report(ytest, pred_abc100_100))\n",
    "\n",
    "print(confusion_matrix(ytest, pred_abc100_100))\n",
    "\n",
    "tm += time.time()\n",
    "\n",
    "print (\"Time :: \", tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Support Vector Machine Classifier\n",
    "#tm = -time.time()\n",
    "\n",
    "#sm = svm.SVC(kernel='linear', C=1)\n",
    "#sm.fit(xtrain, ytrain)\n",
    "#pred_sm = sm.predict(xtest)\n",
    "\n",
    "#print (\"Train Accuracy :: \", accuracy_score(ytrain, sm.predict(xtrain)))\n",
    "#print (\"Test Accuracy  :: \", accuracy_score(ytest, pred_sm))\n",
    "\n",
    "#print(classification_report(ytest, pred_sm))\n",
    "\n",
    "#print(confusion_matrix(ytest, pred_sm))\n",
    "\n",
    "#tm += time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.92238285 0.95436111 0.78286601 0.96794349 0.77490589]\n",
      "AdaBoost Classifier: 0.88 accuracy with a standard deviation of 0.08\n",
      "[0.92820413 0.95961968 0.78354516 0.96119067 0.78821749]\n",
      "Random Forest classifier 1: 0.88 accuracy with a standard deviation of 0.08\n",
      "[0.92733094 0.95985253 0.77657902 0.94161136 0.80306206]\n",
      "Random Forest classifier 2: 0.88 accuracy with a standard deviation of 0.08\n"
     ]
    }
   ],
   "source": [
    "#  Cross-validation\n",
    "xtotal50 = pd.concat([xtrain50, xtest50], axis=0)\n",
    "xtotal100 = pd.concat([xtrain100, xtest100], axis=0)\n",
    "ytotal = pd.concat([ytrain, ytest], axis=0)\n",
    "\n",
    "#scores_svm = cross_val_score(sm, xtotal, ytotal, cv=5)\n",
    "scores_abc = cross_val_score(abc100_50, xtotal50, ytotal, cv=5)\n",
    "scores_rfc1 = cross_val_score(rfc5_50, xtotal50, ytotal, cv=5)\n",
    "scores_rfc2 = cross_val_score(rfc5_100, xtotal100, ytotal, cv=5)\n",
    "\n",
    "print(scores_abc)\n",
    "print(\"AdaBoost Classifier: %0.2f accuracy with a standard deviation of %0.2f\" % (scores_abc.mean(), scores_abc.std()))\n",
    "\n",
    "print(scores_rfc1)\n",
    "print(\"Random Forest classifier 1: %0.2f accuracy with a standard deviation of %0.2f\" % (scores_rfc1.mean(), scores_rfc1.std()))\n",
    "\n",
    "print(scores_rfc2)\n",
    "print(\"Random Forest classifier 2: %0.2f accuracy with a standard deviation of %0.2f\" % (scores_rfc2.mean(), scores_rfc2.std()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normal            93000\n",
      "Generic           58871\n",
      "Exploits          44525\n",
      "Fuzzers           24246\n",
      "DoS               16353\n",
      "Reconnaissance    13987\n",
      "Analysis           2677\n",
      "Backdoor           2329\n",
      "Shellcode          1511\n",
      "Worms               174\n",
      "Name: attack_cat, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(total['attack_cat'].value_counts())\n",
    "total['attack_cat'].value_counts().plot(kind='bar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ytest_multi = test['attack_cat']\n",
    "# ytrain_multi = train['attack_cat']\n",
    "\n",
    "ytest_multi = total['attack_cat']\n",
    "ytrain_multi = total['attack_cat']"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}