hackerearth-defcon.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/kaggle/input/hackerearth-defcon/train.csv\n",
      "/kaggle/input/hackerearth-defcon/test.csv\n",
      "/kaggle/input/hackerearth-defcon/sample_submission.csv\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load in \n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
    "\n",
    "import os\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "    for filename in filenames:\n",
    "        print(os.path.join(dirname, filename))\n",
    "\n",
    "# Any results you write to the current directory are saved as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import mean_absolute_error,confusion_matrix,accuracy_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "",
    "_uuid": ""
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "sample_submission = pd.read_csv(\"../input/hackerearth-defcon/sample_submission.csv\")\n",
    "X_test = pd.read_csv(\"../input/hackerearth-defcon/test.csv\")\n",
    "train = pd.read_csv(\"../input/hackerearth-defcon/train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    4270\n",
       "3    3910\n",
       "4    1212\n",
       "1     498\n",
       "5     110\n",
       "Name: DEFCON_Level, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train['DEFCON_Level'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### seprating features and target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameter_train = X_test.columns\n",
    "X = train[parameter_train]\n",
    "Y = train['DEFCON_Level']\n",
    "Y_test = sample_submission.DEFCON_Level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### splitting trian and test data using trian test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#splitting into train and test set \n",
    "train_X,val_x,train_Y,val_y = train_test_split(X,Y,random_state =1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random forest classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4108\n",
      "[[ 15  13   2   1   0]\n",
      " [ 75 771 287  22   1]\n",
      " [ 25 248 637 161   7]\n",
      " [  2  16  74 132  10]\n",
      " [  0   1   0   0   0]]\n"
     ]
    }
   ],
   "source": [
    "rfc_model = RandomForestClassifier(n_estimators = 500,random_state = 0)\n",
    "rfc_model.fit(train_X,train_Y)\n",
    "print(mean_absolute_error(rfc_model.predict(val_x),val_y))\n",
    "print(confusion_matrix(rfc_model.predict(val_x),val_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest model accuracy(in %): 62.2\n"
     ]
    }
   ],
   "source": [
    "print(\"Random Forest model accuracy(in %):\", metrics.accuracy_score(val_y,rfc_model.predict(val_x))*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### KNN classifier model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "                     metric_params=None, n_jobs=None, n_neighbors=30, p=2,\n",
       "                     weights='uniform')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "KNN = KNeighborsClassifier(n_neighbors = 30)\n",
    "KNN.fit(train_X,train_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5192\n",
      "[[  0   0   0   0   0]\n",
      " [ 68 737 408  35   5]\n",
      " [ 46 299 543 238  11]\n",
      " [  3  13  49  43   2]\n",
      " [  0   0   0   0   0]]\n",
      "\n",
      " KNN model accuracy(in %): 52.92\n"
     ]
    }
   ],
   "source": [
    "print(mean_absolute_error(KNN.predict(val_x),val_y))\n",
    "print(confusion_matrix(KNN.predict(val_x),val_y))\n",
    "print(\"\\n KNN model accuracy(in %):\", metrics.accuracy_score(val_y,KNN.predict(val_x))*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decission tree classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(ccp_alpha=0.0, class_weight=None, criterion='gini',\n",
       "                       max_depth=None, max_features=None, max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=100,\n",
       "                       min_weight_fraction_leaf=0.0, presort='deprecated',\n",
       "                       random_state=0, splitter='best')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DTC = DecisionTreeClassifier(min_samples_split=100,random_state = 0)\n",
    "DTC.fit(train_X,train_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.406\n",
      "[[ 11  11   1   0   0]\n",
      " [ 70 744 244  28   2]\n",
      " [ 33 274 678 140   4]\n",
      " [  3  20  77 148  12]\n",
      " [  0   0   0   0   0]]\n",
      "\n",
      " Decision Tree model accuracy(in %): 63.239999999999995\n"
     ]
    }
   ],
   "source": [
    "print(mean_absolute_error(DTC.predict(val_x),val_y))\n",
    "print(confusion_matrix(DTC.predict(val_x),val_y))\n",
    "print(\"\\n Decision Tree model accuracy(in %):\", metrics.accuracy_score(val_y,DTC.predict(val_x))*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Predicting with the best model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = np.round(DTC.predict(X_test))\n",
    "output = pd.DataFrame({\"ID\": X_test.ID,\"DEFCON_Level\": preds })\n",
    "output.to_csv(\"hackerearth-defcon.csv\",index = False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}