Part 2(b). RandomForest(Classifying Activities).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2b. Random Forest Model on Activities (Include Hyperparameter tuning by RandomSearchCV)\n",
    "GONG ZERUI 04/14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Load libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import pandas as pd\n",
    "from sklearn.ensemble import *\n",
    "from sklearn.tree import *\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.feature_selection import *\n",
    "from sklearn.preprocessing import *\n",
    "from sklearn.model_selection import *\n",
    "from sklearn.linear_model import *\n",
    "from sklearn.naive_bayes import *\n",
    "from sklearn.svm import *\n",
    "from sklearn.neighbors import *\n",
    "from sklearn.tree import *\n",
    "from sklearn.metrics import *\n",
    "import time\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Split train-test datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train :  (7352, 561)\n",
      "y_train :  (7352,)\n",
      "X_test :  (2947, 561)\n",
      "y_test :  (2947,)\n"
     ]
    }
   ],
   "source": [
    "df_train = pd.read_csv(\"source/train.csv\")\n",
    "df_test = pd.read_csv(\"source/test.csv\")\n",
    "df_total = pd.concat([df_train, df_test])\n",
    "\n",
    "\n",
    "y_train = df_train.Activity\n",
    "X_train = df_train.drop(['subject', 'Activity'], axis=1)\n",
    "\n",
    "y_test = df_test.Activity\n",
    "X_test = df_test.drop(['subject', 'Activity'], axis=1)\n",
    "\n",
    "\n",
    "print('X_train : ', X_train.shape)\n",
    "print('y_train : ', y_train.shape)\n",
    "print('X_test : ', X_test.shape)\n",
    "print('y_test : ', y_test.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Build Random Forest Model with Hyperparameter Tuning (RandomizedSearchCV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of trees in random forest\n",
    "n_estimators = [int(x) for x in np.linspace(start=10, stop=200, num=10)]\n",
    "\n",
    "# Maximum number of levels in tree\n",
    "max_depth = [int(x) for x in np.linspace(start=2, stop=50, num=2)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the random grid\n",
    "param = {\n",
    "    \"n_estimators\": n_estimators,\n",
    "    \"max_depth\": max_depth,\n",
    "}\n",
    "\n",
    "rf_Model = RandomForestClassifier()\n",
    "\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "\n",
    "rf_rs = RandomizedSearchCV(\n",
    "    estimator=rf_Model, param_distributions=param, random_state = 42\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomizedSearchCV(estimator=RandomForestClassifier(),\n",
       "                   param_distributions={'max_depth': [2, 50],\n",
       "                                        'n_estimators': [10, 31, 52, 73, 94,\n",
       "                                                         115, 136, 157, 178,\n",
       "                                                         200]},\n",
       "                   random_state=42)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_rs.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Print out best random search parameters\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best estimator :  RandomForestClassifier(max_depth=50, n_estimators=115)\n",
      "Best set of parameters :  {'n_estimators': 115, 'max_depth': 50}\n"
     ]
    }
   ],
   "source": [
    "print(\"Best estimator : \", rf_rs.best_estimator_)\n",
    "print(\"Best set of parameters : \", rf_rs.best_params_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Print out Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy using Random forest with hyperparameter tuning :  0.9334916864608076\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "y_pred = rf_rs.predict(X_test)\n",
    "rf_accuracy = accuracy_score(y_true=y_test, y_pred=y_pred)\n",
    "print(\"Accuracy using Random forest with hyperparameter tuning : \", rf_accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Print out confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "cm = confusion_matrix(y_test.values, y_pred)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12, 8))\n",
    "im = ax.imshow(cm, cmap=plt.cm.Blues)\n",
    "ax.figure.colorbar(im, ax=ax)\n",
    "ax.set(\n",
    "    xticks=np.arange(cm.shape[1]),\n",
    "    yticks=np.arange(cm.shape[0]),\n",
    "    xticklabels=np.unique(y_pred),\n",
    "    yticklabels=np.unique(y_pred),\n",
    "    ylabel=\"True label\",\n",
    "    xlabel=\"Predicted label\",\n",
    ")\n",
    "plt.xticks(rotation = 90)\n",
    "thresh = cm.max() / 2.\n",
    "for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, int(cm[i, j]),ha=\"center\", va=\"center\",color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "fig.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Find sorted feature list based on importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print importance\n",
    "rf_Model = RandomForestClassifier(max_depth=50, n_estimators=157)\n",
    "rf_Model.fit(X_train, y_train)\n",
    "d = {'Parameter':X_train.columns,'FeatureImportance':rf_Model.feature_importances_}\n",
    "df_importance = pd.DataFrame(d)\n",
    "df_importance_sorted = df_importance.sort_values('FeatureImportance', ascending= False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Delete some features and re-test models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a.  Drop features in main feature group one by one "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drop fBodyAcc:\n",
      "Model accuracy score: 0.9226\n",
      "drop fBodyGyro:\n",
      "Model accuracy score: 0.9104\n",
      "drop fBodyAccJerk:\n",
      "Model accuracy score: 0.9321\n",
      "drop tGravityAcc:\n",
      "Model accuracy score: 0.9369\n",
      "drop tBodyAcc:\n",
      "Model accuracy score: 0.9226\n",
      "drop tBodyGyroJerk:\n",
      "Model accuracy score: 0.9233\n",
      "drop tBodyGyro:\n",
      "Model accuracy score: 0.9169\n",
      "drop tBodyAccJerk:\n",
      "Model accuracy score: 0.9274\n",
      "drop tBodyAccMag:\n",
      "Model accuracy score: 0.9243\n",
      "drop tGravityAccMag:\n",
      "Model accuracy score: 0.9270\n",
      "drop tBodyAccJerkMag:\n",
      "Model accuracy score: 0.9237\n",
      "drop tBodyGyroMag:\n",
      "Model accuracy score: 0.9257\n",
      "drop tBodyGyroJerkMag:\n",
      "Model accuracy score: 0.9240\n",
      "drop fBodyAccMag:\n",
      "Model accuracy score: 0.9213\n",
      "drop fBodyBodyAccJerkMag:\n",
      "Model accuracy score: 0.9267\n",
      "drop fBodyBodyGyroMag:\n",
      "Model accuracy score: 0.9284\n",
      "drop fBodyBodyGyroJerkMag:\n",
      "Model accuracy score: 0.9284\n",
      "drop angle:\n",
      "Model accuracy score: 0.9365\n"
     ]
    }
   ],
   "source": [
    "main_feature_list = ['fBodyAcc','fBodyGyro','fBodyAccJerk','tGravityAcc','tBodyAcc','tBodyGyroJerk','tBodyGyro','tBodyAccJerk',\n",
    "                     'tBodyAccMag','tGravityAccMag','tBodyAccJerkMag','tBodyGyroMag','tBodyGyroJerkMag','fBodyAccMag',\n",
    "                     'fBodyBodyAccJerkMag','fBodyBodyGyroMag','fBodyBodyGyroJerkMag','angle']\n",
    "for feature in main_feature_list:\n",
    "    X_train_drop_main_feature = X_train.drop(list(X_train.filter(regex = feature)),axis=1)\n",
    "    X_test_drop_main_feature = X_test.drop(list(X_test.filter(regex = feature)),axis=1)\n",
    "    rf_Model_main = RandomForestClassifier(max_depth=50, n_estimators=157)\n",
    "    rf_Model_main.fit(X_train_drop_main_feature, y_train)\n",
    "    y_pred_drop_main =rf_Model_main.predict(X_test_drop_main_feature)\n",
    "    print(\"drop \" + feature + \":\")\n",
    "    print('Model accuracy score: {0:0.4f}'. format(accuracy_score(y_test, y_pred_drop_main)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b. Drop top 10% of important features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drop top 10%, model accuracy score: 0.9080\n"
     ]
    }
   ],
   "source": [
    "top10p_features = df_importance_sorted.head(56).Parameter\n",
    "X_train_afterDrop10p = X_train.drop(top10p_features,axis=1)\n",
    "X_test_afterDrop10p = X_test.drop(top10p_features,axis=1)\n",
    "rf_Model_drop10p = RandomForestClassifier(max_depth=50, n_estimators=157)\n",
    "rf_Model_drop10p.fit(X_train_afterDrop10p, y_train)\n",
    "y_pred_10p = rf_Model_drop10p.predict(X_test_afterDrop10p)\n",
    "print('Drop top 10%, model accuracy score: {0:0.4f}'. format(accuracy_score(y_test, y_pred_10p)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c. Drop top 30% of important features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drop top 30%, model accuracy score: 0.8751\n"
     ]
    }
   ],
   "source": [
    "top30p_features = df_importance_sorted.head(170).Parameter\n",
    "X_train_afterDrop30p = X_train.drop(top30p_features,axis=1)\n",
    "X_test_afterDrop30p = X_test.drop(top30p_features,axis=1)\n",
    "rf_Model_drop30p = RandomForestClassifier(max_depth=50, n_estimators=157)\n",
    "rf_Model_drop30p.fit(X_train_afterDrop30p, y_train)\n",
    "y_pred_30p = rf_Model_drop30p.predict(X_test_afterDrop30p)\n",
    "print('Drop top 30%, model accuracy score: {0:0.4f}'. format(accuracy_score(y_test, y_pred_30p)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d. Drop top 50% of important features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drop top 50%, model accuracy score: 0.7900\n"
     ]
    }
   ],
   "source": [
    "top50p_features = df_importance_sorted.head(280).Parameter\n",
    "X_train_afterDrop50p = X_train.drop(top50p_features,axis=1)\n",
    "X_test_afterDrop50p = X_test.drop(top50p_features,axis=1)\n",
    "rf_Model_drop50p = RandomForestClassifier(max_depth=50, n_estimators=157)\n",
    "rf_Model_drop50p.fit(X_train_afterDrop50p, y_train)\n",
    "y_pred_50p = rf_Model_drop50p.predict(X_test_afterDrop50p)\n",
    "print('Drop top 50%, model accuracy score: {0:0.4f}'. format(accuracy_score(y_test, y_pred_50p)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### e. Hide one sensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drop Acc:\n",
      "Model accuracy score: 0.9074\n",
      "drop Gyro:\n",
      "Model accuracy score: 0.8853\n"
     ]
    }
   ],
   "source": [
    "main_feature_list = ['Acc','Gyro']\n",
    "for feature in main_feature_list:\n",
    "    X_train_drop_main_feature = X_train.drop(list(X_train.filter(regex = feature)),axis=1)\n",
    "    X_test_drop_main_feature = X_test.drop(list(X_test.filter(regex = feature)),axis=1)\n",
    "    rf_Model_main = RandomForestClassifier(max_depth=50, n_estimators=157)\n",
    "    rf_Model_main.fit(X_train_drop_main_feature, y_train)\n",
    "    y_pred_drop_main =rf_Model_main.predict(X_test_drop_main_feature)\n",
    "    print(\"drop \" + feature + \":\")\n",
    "    print('Model accuracy score: {0:0.4f}'. format(accuracy_score(y_test, y_pred_drop_main)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "fbc8aa4214fedb48b0b7e9159cb57cac96f213c2036602ef91c90215122c989b"
  },
  "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
}