SIT719_Prac05_Task02_HD_task_sample _done.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SECTION 1: DECLARE THE MODULES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from collections import defaultdict\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SECTION 2: Data import and preprocess\n",
    "#Run this but dont worry if it does not make any sense Jump to SECTION 3 that is related to your HD task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: wget in c:\\anaconda3\\lib\\site-packages (3.2)\n",
      "\r",
      "  0% [                                                                                  ]   0 / 500\r",
      "100% [..................................................................................] 500 / 500"
     ]
    }
   ],
   "source": [
    "!pip install wget\n",
    "import wget\n",
    "    \n",
    "link_to_data = 'https://raw.githubusercontent.com/SIT719/2020-S2/master/data/Week_5_NSL-KDD-Dataset/training_attack_types.txt?raw=true'\n",
    "DataSet = wget.download(link_to_data) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'training_attack_types (4).txt'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DataSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "header_names = ['duration', 'protocol_type', 'service', 'flag', 'src_bytes', 'dst_bytes', 'land', 'wrong_fragment', 'urgent', 'hot', 'num_failed_logins', 'logged_in', 'num_compromised', 'root_shell', 'su_attempted', 'num_root', 'num_file_creations', 'num_shells', 'num_access_files', 'num_outbound_cmds', 'is_host_login', 'is_guest_login', 'count', 'srv_count', 'serror_rate', 'srv_serror_rate', 'rerror_rate', 'srv_rerror_rate', 'same_srv_rate', 'diff_srv_rate', 'srv_diff_host_rate', 'dst_host_count', 'dst_host_srv_count', 'dst_host_same_srv_rate', 'dst_host_diff_srv_rate', 'dst_host_same_src_port_rate', 'dst_host_srv_diff_host_rate', 'dst_host_serror_rate', 'dst_host_srv_serror_rate', 'dst_host_rerror_rate', 'dst_host_srv_rerror_rate', 'attack_type', 'success_pred']\n",
    "\n",
    "\n",
    "# Differentiating between nominal, binary, and numeric features\n",
    "\n",
    "# root_shell is marked as a continuous feature in the kddcup.names \n",
    "# file, but it is supposed to be a binary feature according to the \n",
    "# dataset documentation\n",
    "\n",
    "# training_attack_types.txt maps each of the 22 different attacks to 1 of 4 categories\n",
    "# file obtained from http://kdd.ics.uci.edu/databases/kddcup99/training_attack_types\n",
    "\n",
    "col_names = np.array(header_names)\n",
    "\n",
    "nominal_idx = [1, 2, 3]\n",
    "binary_idx = [6, 11, 13, 14, 20, 21]\n",
    "numeric_idx = list(set(range(41)).difference(nominal_idx).difference(binary_idx))\n",
    "\n",
    "nominal_cols = col_names[nominal_idx].tolist()\n",
    "binary_cols = col_names[binary_idx].tolist()\n",
    "numeric_cols = col_names[numeric_idx].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training_attack_types.txt maps each of the 22 different attacks to 1 of 4 categories\n",
    "# file obtained from http://kdd.ics.uci.edu/databases/kddcup99/training_attack_types\n",
    "\n",
    "category = defaultdict(list)\n",
    "category['benign'].append('normal')\n",
    "\n",
    "with open(DataSet, 'r') as f:\n",
    "    for line in f.readlines():\n",
    "        attack, cat = line.strip().split(' ')\n",
    "        category[cat].append(attack)\n",
    "\n",
    "attack_mapping = dict((v,k) for k in category for v in category[k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'normal': 'benign',\n",
       " 'apache2': 'dos',\n",
       " 'back': 'dos',\n",
       " 'mailbomb': 'dos',\n",
       " 'processtable': 'dos',\n",
       " 'snmpgetattack': 'dos',\n",
       " 'teardrop': 'dos',\n",
       " 'smurf': 'dos',\n",
       " 'land': 'dos',\n",
       " 'neptune': 'dos',\n",
       " 'pod': 'dos',\n",
       " 'udpstorm': 'dos',\n",
       " 'ps': 'u2r',\n",
       " 'buffer_overflow': 'u2r',\n",
       " 'perl': 'u2r',\n",
       " 'rootkit': 'u2r',\n",
       " 'loadmodule': 'u2r',\n",
       " 'xterm': 'u2r',\n",
       " 'sqlattack': 'u2r',\n",
       " 'httptunnel': 'u2r',\n",
       " 'ftp_write': 'r2l',\n",
       " 'guess_passwd': 'r2l',\n",
       " 'snmpguess': 'r2l',\n",
       " 'imap': 'r2l',\n",
       " 'spy': 'r2l',\n",
       " 'warezclient': 'r2l',\n",
       " 'warezmaster': 'r2l',\n",
       " 'multihop': 'r2l',\n",
       " 'phf': 'r2l',\n",
       " 'named': 'r2l',\n",
       " 'sendmail': 'r2l',\n",
       " 'xlock': 'r2l',\n",
       " 'xsnoop': 'r2l',\n",
       " 'worm': 'probe',\n",
       " 'nmap': 'probe',\n",
       " 'ipsweep': 'probe',\n",
       " 'portsweep': 'probe',\n",
       " 'satan': 'probe',\n",
       " 'mscan': 'probe',\n",
       " 'saint': 'probe'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attack_mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Processing Training Data\n",
    "\n",
    "train_file='https://raw.githubusercontent.com/SIT719/2020-S2/master/data/Week_5_NSL-KDD-Dataset/KDDTrain%2B.txt'\n",
    "\n",
    "\n",
    "\n",
    "train_df = pd.read_csv(train_file, names=header_names)\n",
    "\n",
    "train_df['attack_category'] = train_df['attack_type'] \\\n",
    "                                .map(lambda x: attack_mapping[x])\n",
    "\n",
    "train_df.drop(['success_pred'], axis=1, inplace=True)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Processing test Data\n",
    "test_file='https://raw.githubusercontent.com/SIT719/2020-S2/master/data/Week_5_NSL-KDD-Dataset/KDDTest%2B.txt'\n",
    "\n",
    "test_df = pd.read_csv(test_file, names=header_names)\n",
    "test_df['attack_category'] = test_df['attack_type'] \\\n",
    "                                .map(lambda x: attack_mapping[x])\n",
    "test_df.drop(['success_pred'], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_attack_types = train_df['attack_type'].value_counts()\n",
    "train_attack_cats = train_df['attack_category'].value_counts()\n",
    "\n",
    "test_attack_types = test_df['attack_type'].value_counts()\n",
    "test_attack_cats = test_df['attack_category'].value_counts()\n",
    "\n",
    "train_attack_types.plot(kind='barh', figsize=(20,10), fontsize=20)\n",
    "\n",
    "train_attack_cats.plot(kind='barh', figsize=(20,10), fontsize=30)\n",
    "\n",
    "train_df[binary_cols].describe().transpose()\n",
    "train_df.groupby(['su_attempted']).size()\n",
    "train_df['su_attempted'].replace(2, 0, inplace=True)\n",
    "test_df['su_attempted'].replace(2, 0, inplace=True)\n",
    "train_df.groupby(['su_attempted']).size()\n",
    "train_df.groupby(['num_outbound_cmds']).size()\n",
    "\n",
    "#Now, that's not a very useful feature - let's drop it from the dataset\n",
    "\n",
    "train_df.drop('num_outbound_cmds', axis = 1, inplace=True)\n",
    "test_df.drop('num_outbound_cmds', axis = 1, inplace=True)\n",
    "numeric_cols.remove('num_outbound_cmds')\n",
    "\n",
    "\n",
    "\n",
    "#Data Preparation\n",
    "\n",
    "train_Y = train_df['attack_category']\n",
    "train_x_raw = train_df.drop(['attack_category','attack_type'], axis=1)\n",
    "test_Y = test_df['attack_category']\n",
    "test_x_raw = test_df.drop(['attack_category','attack_type'], axis=1)\n",
    "\n",
    "\n",
    "combined_df_raw = pd.concat([train_x_raw, test_x_raw])\n",
    "combined_df = pd.get_dummies(combined_df_raw, columns=nominal_cols, drop_first=True)\n",
    "\n",
    "train_x = combined_df[:len(train_x_raw)]\n",
    "test_x = combined_df[len(train_x_raw):]\n",
    "\n",
    "# Store dummy variable feature names\n",
    "dummy_variables = list(set(train_x)-set(combined_df_raw))\n",
    "\n",
    "#execute the commands in console\n",
    "train_x.describe()\n",
    "train_x['duration'].describe()\n",
    "# Experimenting with StandardScaler on the single 'duration' feature\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "durations = train_x['duration'].values.reshape(-1, 1)\n",
    "standard_scaler = StandardScaler().fit(durations)\n",
    "scaled_durations = standard_scaler.transform(durations)\n",
    "pd.Series(scaled_durations.flatten()).describe()\n",
    "\n",
    "# Experimenting with MinMaxScaler on the single 'duration' feature\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "min_max_scaler = MinMaxScaler().fit(durations)\n",
    "min_max_scaled_durations = min_max_scaler.transform(durations)\n",
    "pd.Series(min_max_scaled_durations.flatten()).describe()\n",
    "\n",
    "# Experimenting with RobustScaler on the single 'duration' feature\n",
    "from sklearn.preprocessing import RobustScaler\n",
    "\n",
    "min_max_scaler = RobustScaler().fit(durations)\n",
    "robust_scaled_durations = min_max_scaler.transform(durations)\n",
    "pd.Series(robust_scaled_durations.flatten()).describe()\n",
    "\n",
    "# Experimenting with MaxAbsScaler on the single 'duration' feature\n",
    "from sklearn.preprocessing import MaxAbsScaler\n",
    "\n",
    "max_Abs_scaler = MaxAbsScaler().fit(durations)\n",
    "robust_scaled_durations = max_Abs_scaler.transform(durations)\n",
    "pd.Series(robust_scaled_durations.flatten()).describe()\n",
    "\n",
    "# Let's proceed with StandardScaler- Apply to all the numeric columns\n",
    "\n",
    "standard_scaler = StandardScaler().fit(train_x[numeric_cols])\n",
    "\n",
    "train_x[numeric_cols] = \\\n",
    "    standard_scaler.transform(train_x[numeric_cols])\n",
    "\n",
    "test_x[numeric_cols] = \\\n",
    "    standard_scaler.transform(test_x[numeric_cols])\n",
    "    \n",
    "train_x.describe()\n",
    "\n",
    "\n",
    "\n",
    "train_Y_bin = train_Y.apply(lambda x: 0 if x is 'benign' else 1)\n",
    "test_Y_bin = test_Y.apply(lambda x: 0 if x is 'benign' else 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SECTION 3: Multi class classification\n",
    "#This is the section where you have to add other algorithms, tune algorithms and visualize to compare and analyze algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9365   56  289    1    0]\n",
      " [1541 5998   97    0    0]\n",
      " [ 677  220 1526    0    0]\n",
      " [2278    1   14  277    4]\n",
      " [ 175    0    5    5   15]]\n",
      "0.2378903477643719\n"
     ]
    }
   ],
   "source": [
    "# 5-class classification version\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import confusion_matrix, zero_one_loss\n",
    "\n",
    "classifier = DecisionTreeClassifier(random_state=17)\n",
    "classifier.fit(train_x, train_Y)\n",
    "\n",
    "pred_y = classifier.predict(test_x)\n",
    "\n",
    "results = confusion_matrix(test_Y, pred_y)\n",
    "error = zero_one_loss(test_Y, pred_y)\n",
    "\n",
    "print(results)\n",
    "print(error)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}