Model_Experiments_Mount_Sinai_Dataset.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Model Experiments - Mount Sinai Dataset.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOEAZmmaf1l1CM9J9412Cl6",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jfrank94/SParCS/blob/master/Model_Experiments_Mount_Sinai_Dataset.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g2l0aqtrnRu4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive # import drive from google colab\n",
        "\n",
        "ROOT = \"/content/drive\"     # default location for the drive\n",
        "print(ROOT)                 # print content of ROOT (Optional)\n",
        "\n",
        "drive.mount(ROOT)           # we mount the google drive at /content/drive"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ZAQ3WErncii",
        "colab_type": "code",
        "outputId": "368dc15a-c8a2-4c74-ca22-108be690e0df",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "cd /content/drive/My Drive/MyDrive/SParCS Project/"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/drive/My Drive/MyDrive/SParCS Project\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-QvEm7wOnlUT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd \n",
        "import numpy as np \n",
        "from matplotlib import pyplot as plt \n",
        "import seaborn as sns"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2I-Qkqe3nl5N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "path_to_data = 'MSSM_COVID_FINAL/'\n",
        "files = []\n",
        "for file in os.listdir(path_to_data):\n",
        "  if file.endswith('.txt'):\n",
        "    files.append(file)\n",
        "\n",
        "patient_df = pd.read_csv(path_to_data + files[0], sep=\"\\t\", \n",
        "                        error_bad_lines=False, encoding='latin1')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lxoGHN4vwCfd",
        "colab_type": "code",
        "outputId": "b1d61b02-e4cf-4c9d-dfff-ddc584f18050",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "\"There are {} features in the patient dataset.\".format(patient_df.shape[1])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'There are 73 features in the patient dataset.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KrqNpKqrw9Zf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "patient_df = patient_df.fillna(0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xIhthG6A5_7m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "patient_df_modified = patient_df.drop(columns=['ZIPCODE', 'MASKED_MRN', 'MASKED_ENCOUNTER_EPIC_CSN', 'FACILITY', 'ENC_ACUITY',\n",
        "                                               'TOCILIZUMAB', 'DATE_OF_FIRST_TOCILIZUMAB', 'DECEASED_INDICATOR', 'TOCILIZUMAB',\n",
        "                                                'DATE_OF_FIRST_TOCILIZUMAB', 'REMDESIVIR', 'DATE_OF_FIRST_REMDESIVIR',\n",
        "                                               'SARILUMAB', 'DATE_OF_FIRST_SARILUMAB', 'HYDROXYCHLOROQUINE',\n",
        "                                                'DATE_OF_FIRST_HYDROXYCHLOROQUINE', 'ANAKINRA',\n",
        "                                                'DATE_OF_FIRST_ANAKINRA', 'AZITHROMYCIN', 'DATE_OF_FIRST_AZITHROMYCIN', 'ADMITTED', 'ICU'])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PwDN99s2sOSs",
        "colab_type": "code",
        "outputId": "5e8c04e6-03ff-474e-a1e1-770ec95d3ba7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#modifying the object values into categorical data \n",
        "cols_str = []\n",
        "for col in patient_df_modified.columns: \n",
        "  if patient_df_modified[col].dtype == object or patient_df_modified[col].dtype == bool:\n",
        "    cols_str.append(col)\n",
        "  #print(patient_df_modified[col].dtype == bool)\n",
        "\n",
        "for col in cols_str: \n",
        "  patient_df_modified[col] = pd.Categorical(patient_df_modified[col]).codes\n",
        "print(cols_str)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['SEX', 'COVID_POS', 'CANCER_DIAGNOSIS_DESCRIPTION', 'RACE_SIMPLE', 'SMOKING_SIMPLE', 'COPD_ASTHMA']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "23x5lpQx06CC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "target = patient_df_modified['COVID_POS']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1z01OJZLC-GQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install eli5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "520G__Pm_Ryt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.model_selection import RandomizedSearchCV, train_test_split\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix\n",
        "from  sklearn.base import BaseEstimator\n",
        "\n",
        "import eli5\n",
        "from eli5.sklearn import PermutationImportance\n",
        "from IPython.core.display import display, HTML\n",
        "\n",
        "from xgboost import XGBClassifier\n",
        "from scipy import sparse\n",
        "\n",
        "import seaborn as sns\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "class TrainClassifier(BaseEstimator):\n",
        "    \n",
        "    def __init__(self, classifier=XGBClassifier(tree_hist='gpu_hist')):\n",
        "        self.classifier = classifier \n",
        "\n",
        "    \n",
        "    def fit(self, X, y=None, **kwargs): \n",
        "        self.classifier.fit(X, y)\n",
        "        return self \n",
        "\n",
        "    #1st method of feature extraction \n",
        "    def permutationImportances(self, model, dataset, X, y=None, display=False):\n",
        "      model = model.fit(X, y)\n",
        "      perm = PermutationImportance(model, random_state=42).fit(X, y)\n",
        "      perm_df = eli5.format_as_dataframe(eli5.explain_weights(perm, feature_names=X.columns.tolist()))\n",
        "      if display: \n",
        "        display(eli5.show_weights(perm, feature_names=X.columns.tolist(), top=50))\n",
        "      perm_df_filtered = perm_df[perm_df['weight'] >= 0]\n",
        "      dataset_filtered = dataset[list(perm_df_filtered['feature'])]\n",
        "      return dataset_filtered\n",
        "\n",
        "    #2nd method of feature extraction \n",
        "    def bioMarkerFilter(self, dataset):\n",
        "      biomarkers = ['SMOKING_SIMPLE', 'COPD_ASTHMA', 'DIABETES', 'CHRONIC_KIDNEY_DISEASE', 'HIV_FLAG',\n",
        "              'CANCER_FLAG', 'BMI', 'HTN', 'TEMPERATURE', 'HTN', 'HEART_RATE', 'RESPIRATORY_RATE',\n",
        "              'SYSTOLIC_BP', 'DIASTOLIC_BP', 'O2_SAT']\n",
        "      biomarkers = biomarkers + [col for col in dataset.columns if col.endswith('_INITIAL')]\n",
        "      dataset_modified_biomarkers = dataset[biomarkers]\n",
        "      return dataset_modified_biomarkers \n",
        "      \n",
        "    def predict(self, X, y=None):\n",
        "        self.classifier.predict(X)\n",
        "\n",
        "    def score(self, X, y=None):\n",
        "        testing_predictions = self.classifier.predict(X)\n",
        "        predictions = [round(value) for value in testing_predictions]\n",
        "        accuracy = accuracy_score(y_important_test, predictions)\n",
        "        return (\"Accuracy: %.2f%%\" % (accuracy * 100.0))\n",
        "    \n",
        "    def displayPredictionMatrix(self, X_test, y_test):\n",
        "      unique_labels = [0, 1]\n",
        "      testing_predictions = self.classifier.predict(X_test)\n",
        "      seed = np.random.seed(0)\n",
        "      matrix = confusion_matrix(y_test, testing_predictions, labels=unique_labels)\n",
        "      sns.heatmap(matrix, annot=True, xticklabels=unique_labels, yticklabels=unique_labels)\n",
        "      plt.ylabel('Actual/True Label')\n",
        "      plt.xlabel('Predicted Label')\n",
        "      plt.title('Confusion Matrix for Predicted Labeling')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gxUhQj8tC2OQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pickle\n",
        "\n",
        "patient_df_modified_features = patient_df_modified.columns\n",
        "patient_df_modified_features = [feature for feature in patient_df_modified_features if feature != \"COVID_POS\"]\n",
        "target = patient_df_modified['COVID_POS']\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(patient_df_modified[patient_df_modified_features], \n",
        "                                                        target, test_size=0.3, random_state=np.random.seed(0))\n",
        "    \n",
        "pipe = Pipeline([('preprocessing', MinMaxScaler()),  \n",
        "                 ('classifier', RandomForestClassifier())])\n",
        "               \n",
        "params =  {'classifier': [RandomForestClassifier()], \n",
        "         'preprocessing': [MinMaxScaler(feature_range=(0, 1))],\n",
        "         'classifier__max_features': ['auto', 'sqrt'],\n",
        "         'classifier__min_samples_split': [2, 5, 10],\n",
        "         'classifier__min_samples_leaf': [1, 2, 4],\n",
        "         'classifier__n_estimators': [int(x) for x in np.linspace(start=200, stop=300, num=10)], \n",
        "         'classifier__max_depth': [int(x) for x in np.linspace(start=10, stop=50, num=10)],\n",
        "         'classifier__bootstrap': [True, False]}\n",
        "\n",
        "rscv = RandomizedSearchCV(pipe, params, n_iter=100, verbose=2, cv=5, random_state=np.random.seed(0), n_jobs=-1)\n",
        "rscv.fit(X_train, y_train)\n",
        "random_forest_best = rscv.best_params_['classifier']\n",
        "filename = 'random_forest_best.sav'\n",
        "rfcb_saved = pickle.dump(random_forest_best, open(filename, 'wb'))\n",
        "rfcb_loaded = pickle.load(open(filename, 'rb'))\n",
        "rfcb_model = rfcb_loaded.fit(X_train, y_train)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nm83DiuV1Sxk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6be4da9e-1b85-4edf-923b-f37f34ebe6ac"
      },
      "source": [
        "tr = TrainClassifier()\n",
        "permutation_dataset = tr.permutationImportances(rfcb_model, patient_df_modified, X_test, y_test)\n",
        "\n",
        "X_important_train, X_important_test, y_important_train, y_important_test = train_test_split(permutation_dataset, \n",
        "                                                                                            target, test_size=0.3, random_state=42)\n",
        "tr.fit(X_important_train, y_important_train)\n",
        "tr.score(X_important_test)"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Accuracy: 52.78%'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nWnXF_-eIk6-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 893
        },
        "outputId": "6cd0e717-4d53-4be4-b5e5-442c502923ea"
      },
      "source": [
        "plt.figure(figsize=(15, 15))\n",
        "tr.displayPredictionMatrix(X_important_test, y_important_test)"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x1080 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w0FA4e2j2EcU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c0026367-b49a-4524-844f-f879e79cf9ee"
      },
      "source": [
        "biomarker_dataset = tr.bioMarkerFilter(patient_df_modified)\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(patient_df_modified[patient_df_modified_features], \n",
        "                                                        target, test_size=0.3, random_state=np.random.seed(0))\n",
        "\n",
        "tr.fit(X_train, y_train)\n",
        "tr.score(X_test)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Accuracy: 52.70%'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    }
  ]
}