rf_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.metrics import accuracy_score, roc_auc_score\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_state = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('dataset_diabetes/diabetic_data_train.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['encounter_id', 'patient_nbr', 'race', 'gender', 'age', 'weight',\n",
       "       'admission_type_id', 'discharge_disposition_id', 'admission_source_id',\n",
       "       'time_in_hospital', 'payer_code', 'medical_specialty',\n",
       "       'num_lab_procedures', 'num_procedures', 'num_medications',\n",
       "       'number_outpatient', 'number_emergency', 'number_inpatient', 'diag_1',\n",
       "       'diag_2', 'diag_3', 'number_diagnoses', 'max_glu_serum', 'A1Cresult',\n",
       "       'metformin', 'repaglinide', 'nateglinide', 'chlorpropamide',\n",
       "       'glimepiride', 'acetohexamide', 'glipizide', 'glyburide', 'tolbutamide',\n",
       "       'pioglitazone', 'rosiglitazone', 'acarbose', 'miglitol', 'troglitazone',\n",
       "       'tolazamide', 'examide', 'citoglipton', 'insulin',\n",
       "       'glyburide-metformin', 'glipizide-metformin',\n",
       "       'glimepiride-pioglitazone', 'metformin-rosiglitazone',\n",
       "       'metformin-pioglitazone', 'change', 'diabetesMed', 'readmitted'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove 'encounter_id', 'patient_nbr', 'weight',  'payer_code', 'medical_specialty' columns\n",
    "df = df[[col for col in df.columns if col not in ['encounter_id', 'patient_nbr', 'weight', 'payer_code', 'medical_specialty']]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['race', 'gender', 'age', 'admission_type_id',\n",
       "       'discharge_disposition_id', 'admission_source_id', 'time_in_hospital',\n",
       "       'num_lab_procedures', 'num_procedures', 'num_medications',\n",
       "       'number_outpatient', 'number_emergency', 'number_inpatient', 'diag_1',\n",
       "       'diag_2', 'diag_3', 'number_diagnoses', 'max_glu_serum', 'A1Cresult',\n",
       "       'metformin', 'repaglinide', 'nateglinide', 'chlorpropamide',\n",
       "       'glimepiride', 'acetohexamide', 'glipizide', 'glyburide', 'tolbutamide',\n",
       "       'pioglitazone', 'rosiglitazone', 'acarbose', 'miglitol', 'troglitazone',\n",
       "       'tolazamide', 'examide', 'citoglipton', 'insulin',\n",
       "       'glyburide-metformin', 'glipizide-metformin',\n",
       "       'glimepiride-pioglitazone', 'metformin-rosiglitazone',\n",
       "       'metformin-pioglitazone', 'change', 'diabetesMed', 'readmitted'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating data label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to handle features\n",
    "\n",
    "OHE = One hot encoding\n",
    "\n",
    "+ PREPROCESSING+OHE: 'admission_type_id', 'admission_source_id', 'diag_1', 'diag_2', 'diag_3'\n",
    "\n",
    "\n",
    "+ PREPROCESSING+NUMERICAL: 'age', 'discharge_disposition_id', 'change', 'diabetesMed'\n",
    "\n",
    "\n",
    "+ OHE (using categorical features as is): 'race', 'gender', 'max_glu_serum', 'A1Cresult', 'metformin', 'repaglinide', 'nateglinide', 'chlorpropamide', 'glimepiride', 'acetohexamide', 'glipizide', 'glyburide', 'tolbutamide', 'pioglitazone', 'rosiglitazone', 'acarbose', 'miglitol', 'troglitazone', 'tolazamide', 'examide', 'citoglipton', 'insulin', 'glyburide-metformin', 'glipizide-metformin', 'glimepiride-pioglitazone', 'metformin-rosiglitazone','metformin-pioglitazone'\n",
    "\n",
    "\n",
    "+ NO PREPROCESSING NEEDED (numerical): 'time_in_hospital', 'num_lab_procedures', 'num_procedures', 'num_medications', 'number_outpatient', 'number_emergency', 'number_inpatient', 'number_diagnoses'\n",
    "\n",
    "       \n",
    "+ NOT USING (at all, due to not being helpful or missing data): 'encounter_id', 'patient_nbr', 'weight',  'payer_code', 'medical_specialty'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('NO', 0.5393799439886012),\n",
       " ('>30', 0.3491868520611212),\n",
       " ('<30', 0.1114332039502776)]"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(key, val/len(df.readmitted)) for (key, val) in Counter(df.readmitted).most_common()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binarize_readmitted(x):\n",
    "    if x in ['>30', '<30']: # readmitted in less than 30 days is positive class\n",
    "        return 1 \n",
    "    else:\n",
    "        return 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df.apply(lambda x: binarize_readmitted(x['readmitted']), axis=1).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0.5393799439886012), (1, 0.4606200560113988)]"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(key, val/len(df.readmitted)) for (key, val) in Counter(y).most_common()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing Features\n",
    "\n",
    "Mapping age groups to single numerical value (age in the middle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "def map_age(x):\n",
    "    if x == '[0-10)':\n",
    "        return 5\n",
    "    elif x == '[10-20)':\n",
    "        return 15\n",
    "    elif x == '[20-30)':\n",
    "        return 25\n",
    "    elif x == '[30-40)':\n",
    "        return 35\n",
    "    elif x == '[40-50)':\n",
    "        return 45\n",
    "    elif x == '[50-60)':\n",
    "        return 55\n",
    "    elif x == '[60-70)':\n",
    "        return 65\n",
    "    elif x == '[70-80)':\n",
    "        return 75\n",
    "    elif x == '[80-90)':\n",
    "        return 85\n",
    "    else:\n",
    "        return 95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['age_processed'] = df.apply(lambda x: map_age(x['age']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Admission Type\n",
    "\n",
    "Combine Not Available vs. NULL vs. Not Mapped into one and leave the remaining as is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "admission_dict = {1: 'Emergency', 2: 'Urgent', 3: 'Elective', 4: 'Newborn', 7: 'Trauma Center'}\n",
    "def map_admission(x):\n",
    "    if x in [5,6,8]:\n",
    "        return 'Not Available'\n",
    "    else:\n",
    "        return admission_dict[x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['admission_type_processed'] = df.apply(lambda x: map_admission(x['admission_type_id']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Discharge \n",
    "\n",
    "Only use discharge home, since it is the dominant value. Discharge to home is coded as 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discharged_home(x):\n",
    "    if x == 1:\n",
    "        return 1 # Discharged home\n",
    "    else:\n",
    "        return 0 # Other "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['discharged_processed'] = df.apply(lambda x: discharged_home(x['discharge_disposition_id']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Source\n",
    "Only using emergency room, referral (physician, clinical, or HMO), or other (everything else)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "def map_source(x):\n",
    "    if x in [1,2,3]:\n",
    "        return 'Referral' \n",
    "    elif x == 7:\n",
    "        return 'Emergency Room'\n",
    "    else:\n",
    "        return 'Other'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['source_processed'] = df.apply(lambda x: map_source(x['admission_source_id']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diag1, Diag2, Diag3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "def map_diag(x):\n",
    "    if x[0].isdigit() == False:\n",
    "        return 'other'\n",
    "    \n",
    "    float_x = float(x)\n",
    "    if (float_x >= 390 and float_x <= 459) or float_x == 785: # 390–459, 785\n",
    "        return 'circulatory'\n",
    "    elif (float_x >= 460 and float_x <= 519) or float_x == 786: # 460–519, 786\n",
    "        return 'respiratory'\n",
    "    elif (float_x >= 520 and float_x <= 579) or float_x == 787: # 520–579, 787\n",
    "        return 'digestive'\n",
    "    elif float_x >= 250 and float_x < 251: # 250.xx\n",
    "        return 'diabetes'\n",
    "    elif float_x >= 800 and float_x <= 999: # 800–999\n",
    "        return 'injury'\n",
    "    elif float_x >= 710 and float_x <= 739: # 710–739\n",
    "        return 'musculoskeletal'\n",
    "    elif (float_x >= 580 and float_x <= 629) or float_x == 788: # 580–629, 788\n",
    "        return 'genitourinary'\n",
    "    elif float_x >= 140 and float_x <= 239: # 140–239\n",
    "        return 'neoplasms'\n",
    "    else:\n",
    "        return 'other'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['diag1_processed'] = df.apply(lambda x: map_diag(x['diag_1']), axis=1)\n",
    "df['diag2_processed'] = df.apply(lambda x: map_diag(x['diag_2']), axis=1)\n",
    "df['diag3_processed'] = df.apply(lambda x: map_diag(x['diag_3']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change\n",
    "Making change in prescribed diabetic medication binary (0 or 1) instead of 'Ch'/'No'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binarize_yn(x):\n",
    "    if x in ['Yes', 'Ch']: \n",
    "        return 1 \n",
    "    else:\n",
    "        return 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['change_processed'] = df.apply(lambda x: binarize_yn(x['change']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### diabetesMed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['diabetesMed_processed'] = df.apply(lambda x: binarize_yn(x['diabetesMed']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# One hot Encoding Features\n",
    "\n",
    "Resources on one hot encoding:\n",
    "- https://kiwidamien.github.io/are-you-getting-burned-by-one-hot-encoding.html\n",
    "- https://stackoverflow.com/questions/44601533/how-to-use-onehotencoder-for-multiple-columns-and-automatically-drop-first-dummy/44601764"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "ohe = OneHotEncoder(categories='auto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_sub = df[['admission_type_processed', 'source_processed',\n",
    "            'diag1_processed', 'diag2_processed', 'diag3_processed', 'race', 'gender', \n",
    "            'max_glu_serum', 'A1Cresult', 'metformin', 'repaglinide', 'nateglinide', \n",
    "            'chlorpropamide', 'glimepiride', 'acetohexamide', 'glipizide', 'glyburide', \n",
    "            'tolbutamide', 'pioglitazone', 'rosiglitazone', 'acarbose', 'miglitol', 'troglitazone', \n",
    "            'tolazamide', 'examide', 'citoglipton', 'insulin', 'glyburide-metformin', 'glipizide-metformin', \n",
    "            'glimepiride-pioglitazone', 'metformin-rosiglitazone','metformin-pioglitazone']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_arr = ohe.fit_transform(df_sub).toarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_labels_ = ohe.categories_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_labels = []\n",
    "for col, values in zip(df_sub.columns, feature_labels_):\n",
    "    for val in values:\n",
    "        feature_labels.append(col+'_'+val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_ohe = pd.DataFrame(feature_arr, columns = feature_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(81412, 124)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_ohe.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_num = df[['age_processed', 'discharged_processed', 'change_processed', 'diabetesMed_processed', 'time_in_hospital', 'num_lab_procedures', 'num_procedures', 'num_medications', 'number_outpatient', 'number_emergency', 'number_inpatient', 'number_diagnoses']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(81412, 12)"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_num.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.concat([df_ohe, df_num], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(81412, 136) (81412,)\n"
     ]
    }
   ],
   "source": [
    "print(X.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [],
   "source": [
    "skf = StratifiedKFold(n_splits=5, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy_training = []\n",
    "accuracy_cv = []\n",
    "auroc_training = []\n",
    "auroc_cv = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/sklearn/ensemble/forest.py:246: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
      "/usr/local/lib/python3.7/site-packages/sklearn/ensemble/forest.py:246: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
      "/usr/local/lib/python3.7/site-packages/sklearn/ensemble/forest.py:246: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
      "/usr/local/lib/python3.7/site-packages/sklearn/ensemble/forest.py:246: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
      "/usr/local/lib/python3.7/site-packages/sklearn/ensemble/forest.py:246: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "for train_index, test_index in skf.split(X, y):\n",
    "    X_train, X_test = X.loc[train_index], X.loc[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "    clf = RandomForestClassifier(max_depth=10, random_state=0)\n",
    "    clf.fit(X_train, y_train)\n",
    "    y_pred_train = clf.predict(X_train)\n",
    "    y_pred_cv = clf.predict(X_test)\n",
    "    accuracy_training.append(accuracy_score(y_train, y_pred_train))\n",
    "    auroc_training.append(roc_auc_score(y_train, y_pred_train))\n",
    "    accuracy_cv.append(accuracy_score(y_test, y_pred_cv))\n",
    "    auroc_cv.append(roc_auc_score(y_test, y_pred_cv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8507713841683817 0.002520721146944525\n",
      "0.610806733164251 0.0036864898230898504\n"
     ]
    }
   ],
   "source": [
    "print(np.average(accuracy_training), np.std(accuracy_training))\n",
    "print(np.average(accuracy_cv), np.std(accuracy_cv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8454788260730892 0.0027661090505620655\n",
      "0.6026641556631278 0.0037792351273024955\n"
     ]
    }
   ],
   "source": [
    "print(np.average(auroc_training), np.std(auroc_training))\n",
    "print(np.average(auroc_cv), np.std(auroc_cv))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes: \n",
    "\n",
    "+ Both train and cross val performance is very low for max depth between 5-10 -> which indicates underfitting to the data/high bias in the model. Increasing max_depth increases training performance dramatically but does not impact cross val performance significantly. \n",
    "+ Tried only using the numerical features and get roughly the same performance. \n",
    "+ How to deal with dropping first column/redundancy in one hot encoding?\n",
    "+ Tree based models are fine without rescaling (which is good because I did not rescale) but are not the best with sparse data -> are results different for other models?"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}