RandomForest_casestudy_covid19_vms.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EvpyI0E7SpNT"
   },
   "source": [
    "## Random Forest\n",
    "\n",
    "Random Forest is an ensemble of Decision Trees. With a few exceptions, a `RandomForestClassifier` has all the hyperparameters of a `DecisionTreeClassifier` (to control how trees are grown), plus all the hyperparameters of a `BaggingClassifier` to control the ensemble itself.\n",
    "\n",
    "The Random Forest algorithm introduces extra randomness when growing trees; instead of searching for the very best feature when splitting a node, it searches for the best feature among a random subset of features. This results in a greater tree diversity, which (once again) trades a higher bias for a lower variance, generally yielding an overall better model. The following `BaggingClassifier` is roughly equivalent to the previous `RandomForestClassifier`. Run the cell below to visualize a single estimator from a random forest model, using the Iris dataset to classify the data into the appropriate species."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "output_embedded_package_id": "1NIbktS4yyfVlE2Y4bXMargRbQgbdWTFh"
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 7579,
     "status": "ok",
     "timestamp": 1592213046926,
     "user": {
      "displayName": "Andrew Maguire",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GjaIpd1sqQPWOc9NJXtyl5fYSonikxEZgshlvloAYk=s64",
      "userId": "13447906511017779027"
     },
     "user_tz": -60
    },
    "id": "z_-6xEUFSpNU",
    "outputId": "75184be3-e99c-4c44-a638-824a9ba0b1e9"
   },
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[WinError 2] The system cannot find the file specified",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-121-53b30f6d91ce>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mpydot\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0msubprocess\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mcall\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 24\u001b[1;33m \u001b[0mcall\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'dot'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'-Tpng'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'tree.dot'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'-o'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'tree.png'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'-Gdpi=600'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     25\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     26\u001b[0m \u001b[1;31m# Display in jupyter notebook\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\subprocess.py\u001b[0m in \u001b[0;36mcall\u001b[1;34m(timeout, *popenargs, **kwargs)\u001b[0m\n\u001b[0;32m    338\u001b[0m     \u001b[0mretcode\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcall\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"ls\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"-l\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    339\u001b[0m     \"\"\"\n\u001b[1;32m--> 340\u001b[1;33m     \u001b[1;32mwith\u001b[0m \u001b[0mPopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mpopenargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mp\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    341\u001b[0m         \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    342\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0mp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\subprocess.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags, restore_signals, start_new_session, pass_fds, encoding, errors, text)\u001b[0m\n\u001b[0;32m    852\u001b[0m                             encoding=encoding, errors=errors)\n\u001b[0;32m    853\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 854\u001b[1;33m             self._execute_child(args, executable, preexec_fn, close_fds,\n\u001b[0m\u001b[0;32m    855\u001b[0m                                 \u001b[0mpass_fds\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcwd\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0menv\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    856\u001b[0m                                 \u001b[0mstartupinfo\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreationflags\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mshell\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\subprocess.py\u001b[0m in \u001b[0;36m_execute_child\u001b[1;34m(self, args, executable, preexec_fn, close_fds, pass_fds, cwd, env, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, unused_restore_signals, unused_start_new_session)\u001b[0m\n\u001b[0;32m   1305\u001b[0m             \u001b[1;31m# Start the process\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1306\u001b[0m             \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1307\u001b[1;33m                 hp, ht, pid, tid = _winapi.CreateProcess(executable, args,\n\u001b[0m\u001b[0;32m   1308\u001b[0m                                          \u001b[1;31m# no special security\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1309\u001b[0m                                          \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 2] The system cannot find the file specified"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "\n",
    "# Model (can also use single decision tree)\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "model = RandomForestClassifier(n_estimators=10)\n",
    "\n",
    "# Train\n",
    "model.fit(iris.data, iris.target)\n",
    "# Extract single tree\n",
    "estimator = model.estimators_[5]\n",
    "\n",
    "from sklearn.tree import export_graphviz\n",
    "# Export as dot file\n",
    "export_graphviz(estimator, out_file='tree.dot', \n",
    "                feature_names = iris.feature_names,\n",
    "                class_names = iris.target_names,\n",
    "                rounded = True, proportion = False, \n",
    "                precision = 2, filled = True)\n",
    "\n",
    "# Convert to png using system command (requires Graphviz)\n",
    "import pydot\n",
    "from subprocess import call\n",
    "call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])\n",
    "\n",
    "# Display in jupyter notebook\n",
    "from IPython.display import Image\n",
    "Image(filename = 'tree.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VSnWoCRUSpNY"
   },
   "source": [
    "Notice how each split seperates the data into buckets of similar observations. This is a single tree and a relatively simple classification dataset, but the same method is used in a more complex dataset with greater depth to the trees."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tJ2aGPMZB5X8"
   },
   "source": [
    "## Coronavirus\n",
    "Coronavirus disease (COVID-19) is an infectious disease caused by a new virus.\n",
    "The disease causes respiratory illness (like the flu) with symptoms such as a cough, fever, and in more severe cases, difficulty breathing. You can protect yourself by washing your hands frequently, avoiding touching your face, and avoiding close contact (1 meter or 3 feet) with people who are unwell. An outbreak of COVID-19 started in December 2019 and at the time of the creation of this project was continuing to spread throughout the world. Many governments recommended only essential outings to public places and closed most business that do not serve food or sell essential items. An excellent [spatial dashboard](https://www.arcgis.com/apps/opsdashboard/index.html#/bda7594740fd40299423467b48e9ecf6) built by Johns Hopkins shows the daily confirmed cases by country. \n",
    "\n",
    "This case study was designed to drive home the important role that data science plays in real-world situations like this pandemic. This case study uses the Random Forest Classifier and a dataset from the South Korean cases of COVID-19 provided on [Kaggle](https://www.kaggle.com/kimjihoo/coronavirusdataset) to encourage research on this important topic. The goal of the case study is to build a Random Forest Classifier to predict the 'state' of the patient."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7PrMkSjBQEMZ"
   },
   "source": [
    "First, please load the needed packages and modules into Python. Next, load the data into a pandas dataframe for ease of use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X3EhD-LSB5YI"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from datetime import datetime,timedelta\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "import plotly.graph_objects as go\n",
    "from sklearn.experimental import enable_iterative_imputer\n",
    "from sklearn.impute import IterativeImputer\n",
    "from sklearn.ensemble import ExtraTreesRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CiJQlTK1SpNd"
   },
   "outputs": [],
   "source": [
    "url ='SouthKoreacoronavirusdataset/PatientInfo.csv'\n",
    "df = pd.read_csv('SouthKoreacoronavirusdataset-20200630T044816Z-001/SouthKoreacoronavirusdataset/PatientInfo.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GUY5Cp2cSpNg"
   },
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oxKUKR_pSpNi"
   },
   "outputs": [],
   "source": [
    "#Counts of null values \n",
    "na_df=pd.DataFrame(df.isnull().sum().sort_values(ascending=False)).reset_index()\n",
    "na_df.columns = ['VarName', 'NullCount']\n",
    "na_df[(na_df['NullCount']>0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NhPtmRWdSpNl"
   },
   "outputs": [],
   "source": [
    "#counts of response variable values\n",
    "df.state.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "06e0gqMzSpNp"
   },
   "source": [
    " **<font color='teal'> Create a new column named 'n_age' which is the calculated age based on the birth year column.</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DVCW7LBRSpNp"
   },
   "outputs": [],
   "source": [
    "current_yr = 2021\n",
    "df['n_age'] = current_yr - df['birth_year']\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "w9t91IzDSpNr"
   },
   "source": [
    "### Handle Missing Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Fm1TjGDhSpNs"
   },
   "source": [
    " **<font color='teal'> Print the number of missing values by column.</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PAtr2t3rSpNs"
   },
   "outputs": [],
   "source": [
    "print(\" \\nCount total NaN at each column in a DataFrame : \\n\\n\",\n",
    "      df.isnull().sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "I8B5cY19SpNu"
   },
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zjLpYG_ASpNw"
   },
   "source": [
    " **<font color='teal'> Fill the 'disease' missing values with 0 and remap the True values to 1.</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NHBtVW1ESpNx"
   },
   "outputs": [],
   "source": [
    "df['disease'].fillna(0, inplace = True)\n",
    "di = {'True':1}\n",
    "df.replace({'disease': di})\n",
    "df.head()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fZArBBUhSpNz"
   },
   "source": [
    " **<font color='teal'> Fill null values in the following columns with their mean: 'global_number','birth_year','infection_order','infected_by'and 'contact_number'</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zQdarDx_SpNz"
   },
   "outputs": [],
   "source": [
    "df[['global_num','birth_year','infection_order','infected_by','contact_number']].fillna(df.mean(), inplace=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Coy_jYEbSpN2"
   },
   "source": [
    " **<font color='teal'> Fill the rest of the missing values with any method.</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ATJ84cdDSpN2"
   },
   "outputs": [],
   "source": [
    "df = df.fillna(df.median())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kGi4NkcbSpN4"
   },
   "source": [
    " **<font color='teal'> Check for any remaining null values.</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "82lVA3vUSpN5"
   },
   "outputs": [],
   "source": [
    "print(\" \\nCount total NaN at each column in a DataFrame : \\n\\n\",\n",
    "      df.isnull().sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "55CJRFKtSpN7"
   },
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PK9Jk8KgSpN9"
   },
   "source": [
    "Remove date columns from the data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xIbYDncMSpN9"
   },
   "outputs": [],
   "source": [
    "df = df.drop(['symptom_onset_date','confirmed_date','released_date','deceased_date'],axis =1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RDBxf5ZDB5ZZ"
   },
   "source": [
    "Review the count of unique values by column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PIdCkZ4AB5Zf"
   },
   "outputs": [],
   "source": [
    "print(df.nunique())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9oENi5DRB5Zq"
   },
   "source": [
    "Review the percent of unique values by column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_IcO33VsB5Zt"
   },
   "outputs": [],
   "source": [
    "print(df.nunique()/df.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rCZHVugqB5Z4"
   },
   "source": [
    "Review the range of values per column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Y3zLsGxMB5Z5"
   },
   "outputs": [],
   "source": [
    "df.describe().T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AEBFq3hmB5aN"
   },
   "source": [
    "### Check for duplicated rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s9KGFCpkB5aP"
   },
   "outputs": [],
   "source": [
    "duplicateRowsDF = df[df.duplicated()]\n",
    "duplicateRowsDF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8WOrbEk1SpOH"
   },
   "source": [
    "Print the categorical columns and their associated levels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8QTm6RuRSpOH"
   },
   "outputs": [],
   "source": [
    "dfo = df.select_dtypes(include=['object'], exclude=['datetime'])\n",
    "dfo.shape\n",
    "#get levels for all variables\n",
    "vn = pd.DataFrame(dfo.nunique()).reset_index()\n",
    "vn.columns = ['VarName', 'LevelsCount']\n",
    "vn.sort_values(by='LevelsCount', ascending =False)\n",
    "vn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "a43l6w_uSpOJ"
   },
   "source": [
    "**<font color='teal'> Plot the correlation heat map for the features.</font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZRJlPqV5B5e5",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sns.heatmap(df.corr())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2KtABW0USpOK"
   },
   "source": [
    "**<font color='teal'> Plot the boxplots to check for outliers. </font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uYMmU_szB5fZ"
   },
   "outputs": [],
   "source": [
    "bcolumns = ['patient_id', 'global_num', 'birth_year', 'infection_order', 'infected_by', 'contact_number', 'n_age']\n",
    "plt.figure(figsize=(10,10))\n",
    "plt_num = 1\n",
    "for col in bcolumns:\n",
    "    ax = plt.subplot(3, 3, plt_num)\n",
    "    sns.boxplot(data=df[col])\n",
    "    ax.set_title(col)\n",
    "    plt_num +=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2Z_NuqkNSpOM"
   },
   "source": [
    "**<font color='teal'> Create dummy features for object type features. </font>**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.get_dummies(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0uTSQY_liDHj"
   },
   "source": [
    "### Split the data into test and train subsamples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BSkPut0gguds"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "# dont forget to define your X and y\n",
    "y = df['disease']\n",
    "y = y.astype(int)\n",
    "X = pd.get_dummies(df.drop(['disease'], axis = 1))\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       0\n",
       "1       0\n",
       "2       0\n",
       "3       0\n",
       "4       0\n",
       "       ..\n",
       "2213    0\n",
       "2214    0\n",
       "2215    0\n",
       "2216    0\n",
       "2217    0\n",
       "Name: disease, Length: 2218, dtype: int32"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TcrOg3y7gRtG"
   },
   "source": [
    "### Scale data to prep for model creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IZL-q-KtAYI6"
   },
   "outputs": [],
   "source": [
    "#scale data\n",
    "from sklearn import preprocessing\n",
    "import numpy as np\n",
    "# build scaler based on training data and apply it to test data to then also scale the test data\n",
    "scaler = preprocessing.StandardScaler().fit(X_train)\n",
    "X_train_scaled=scaler.transform(X_train)\n",
    "X_test_scaled=scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZSOICugNSpOR"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import auc\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from matplotlib import pyplot\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import auc\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report,confusion_matrix,roc_curve,roc_auc_score\n",
    "from sklearn.metrics import accuracy_score,log_loss\n",
    "from matplotlib import pyplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vzrLoM58SpOT"
   },
   "source": [
    "### Fit Random Forest Classifier\n",
    "The fit model shows an overall accuracy of 80% which is great and indicates our model was effectively able to identify the status of a patients in the South Korea dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "b9jQyje3SpOU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest: Accuracy=0.989\n",
      "Random Forest: f1-score=0.988\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "clf = RandomForestClassifier(n_estimators=300, random_state = 1,n_jobs=-1)\n",
    "model_res = clf.fit(X_train_scaled, y_train)\n",
    "y_pred = model_res.predict(X_test_scaled)\n",
    "y_pred_prob = model_res.predict_proba(X_test_scaled)\n",
    "lr_probs = y_pred_prob[:,1]\n",
    "ac = accuracy_score(y_test, y_pred)\n",
    "\n",
    "f1 = f1_score(y_test, y_pred, average='weighted')\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "print('Random Forest: Accuracy=%.3f' % (ac))\n",
    "\n",
    "print('Random Forest: f1-score=%.3f' % (f1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QYdW02QQSpOW"
   },
   "source": [
    "### Create Confusion Matrix Plots\n",
    "Confusion matrices are great ways to review your model performance for a multi-class classification problem. Being able to identify which class the misclassified observations end up in is a great way to determine if you need to build additional features to improve your overall model. In the example below we plot a regular counts confusion matrix as well as a weighted percent confusion matrix. The percent confusion matrix is particulary helpful when you have unbalanced class sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wSWGVZU6SpOW"
   },
   "outputs": [],
   "source": [
    "class_names=['isolated','released','missing','deceased'] # name  of classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GjnV5ugJSpOb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[438   2]\n",
      " [  3   1]]\n",
      "Normalized confusion matrix\n",
      "[[1.   0.  ]\n",
      " [0.75 0.25]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import itertools\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn import svm, datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.tight_layout()\n",
    "\n",
    "\n",
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, y_pred)\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=class_names,\n",
    "                      title='Confusion matrix, without normalization')\n",
    "#plt.savefig('figures/RF_cm_multi_class.png')\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=True,\n",
    "                      title='Normalized confusion matrix')\n",
    "#plt.savefig('figures/RF_cm_proportion_multi_class.png', bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z7PtbV4LSpOc"
   },
   "source": [
    "### Plot feature importances\n",
    "The random forest algorithm can be used as a regression or classification model. In either case it tends to be a bit of a black box, where understanding what's happening under the hood can be difficult. Plotting the feature importances is one way that you can gain a perspective on which features are driving the model predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "T1xpGOCVSpOc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "feature_importance = clf.feature_importances_\n",
    "# make importances relative to max importance\n",
    "feature_importance = 100.0 * (feature_importance / feature_importance.max())[:30]\n",
    "sorted_idx = np.argsort(feature_importance)[:30]\n",
    "\n",
    "pos = np.arange(sorted_idx.shape[0]) + .5\n",
    "print(pos.size)\n",
    "sorted_idx.size\n",
    "plt.figure(figsize=(10,10))\n",
    "plt.barh(pos, feature_importance[sorted_idx], align='center')\n",
    "plt.yticks(pos, X.columns[sorted_idx])\n",
    "plt.xlabel('Relative Importance')\n",
    "plt.title('Variable Importance')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ys_mI5GsSpOe"
   },
   "source": [
    "The popularity of random forest is primarily due to how well it performs in a multitude of data situations. It tends to handle highly correlated features well, where as a linear regression model would not. In this case study we demonstrate the performance ability even with only a few features and almost all of them being highly correlated with each other.\n",
    "Random Forest is also used as an efficient way to investigate the importance of a set of features with a large data set. Consider random forest to be one of your first choices when building a decision tree, especially for multiclass classifications."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "FXGd_NbdB5kn"
   ],
   "name": "RandomForest_casestudy_covid19.ipynb",
   "provenance": []
  },
  "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": 4
}