mlp_v2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Heart failure prediction based on the MIMIC-III dataset\n",
        "This notebook provides a basic code to preprocess the MIMIC-III dataset and two multi-layer perceptron (MLP) models for heart failure (HF) prediction.\n",
        "In this version, only the DIAGNOSIS table was used, to avoid sparsity. The goal of the model is to predict the incidence of HF in the next visit, given the observed ICD-9 codes for a certain patient."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Jo221tlG8d5",
        "outputId": "bbf74371-0b54-40bb-e5a4-e6c5895476f0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "\" # if using google drive, mounting drive for mimic-iii access\\nfrom google.colab import drive\\ndrive.mount('/content/drive') \""
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" # if using google drive, mounting drive for mimic-iii access\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive') \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zqPZ608UHuQt",
        "outputId": "643ea1b8-8351-49c0-fe62-4f1095b5150e"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "\n",
        "# add the path to the files\n",
        "# if they are in your google drive, it will look something like this:\n",
        "# /content/drive/MyDrive/Colab Notebooks/mimic-iii-demo/ADMISSIONS.csv\n",
        "\n",
        "diagnoses_path = \"data\\mimic-iii\\DIAGNOSES_ICD.csv\"\n",
        "\n",
        "# loading data\n",
        "diagnoses = pd.read_csv(diagnoses_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "id": "QJujKXGbMs3C",
        "outputId": "01bbeeec-29fa-4bc7-d0dc-cdd488759db3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Diagnoses table, containing data about patients' diagnoses based on ICD codes:\n"
          ]
        }
      ],
      "source": [
        "print(\"\\nDiagnoses table, containing data about patients' diagnoses based on ICD codes:\")\n",
        "# diagnoses.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KXM8CEOqFsoR",
        "outputId": "0c8955e4-f0c6-4f72-f5f0-c3672502f73d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Total number of patients: 46520\n"
          ]
        }
      ],
      "source": [
        "unique_subject_ids_count = diagnoses['SUBJECT_ID'].nunique()\n",
        "print(f\"Total number of patients: {unique_subject_ids_count}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Total number of unique ICD-9 codes: 6984\n"
          ]
        }
      ],
      "source": [
        "unique_icd9_count = diagnoses['ICD9_CODE'].nunique()\n",
        "print(f\"Total number of unique ICD-9 codes: {unique_icd9_count}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "\" import matplotlib.pyplot as plt\\nimport seaborn as sns\\n\\nicd9_counts = diagnoses['ICD9_CODE'].value_counts()\\ntop_icd9_counts = icd9_counts.head(10)\\n\\nplt.figure(figsize=(10, 6))\\nax = sns.barplot(x=top_icd9_counts.index, y=top_icd9_counts.values)\\nplt.ylabel('Count')\\nplt.xlabel('ICD-9 codes')\\nplt.title('10 Most Frequent ICD-9 Codes in the MIMIC-III dataset')\\n\\n# adding code counts\\nfor p in ax.patches:\\n    ax.annotate(f'{int(p.get_height())}', (p.get_x() + p.get_width() / 2., p.get_height()), \\n                ha='center', va='center', fontsize=10, color='black', xytext=(0, 5), \\n                textcoords='offset points')\\n\\nplt.tight_layout()\\nplt.show() \""
            ]
          },
          "execution_count": 77,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "icd9_counts = diagnoses['ICD9_CODE'].value_counts()\n",
        "top_icd9_counts = icd9_counts.head(10)\n",
        "\n",
        "plt.figure(figsize=(10, 6))\n",
        "ax = sns.barplot(x=top_icd9_counts.index, y=top_icd9_counts.values)\n",
        "plt.ylabel('Count')\n",
        "plt.xlabel('ICD-9 codes')\n",
        "plt.title('10 Most Frequent ICD-9 Codes in the MIMIC-III dataset')\n",
        "\n",
        "# adding code counts\n",
        "for p in ax.patches:\n",
        "    ax.annotate(f'{int(p.get_height())}', (p.get_x() + p.get_width() / 2., p.get_height()), \n",
        "                ha='center', va='center', fontsize=10, color='black', xytext=(0, 5), \n",
        "                textcoords='offset points')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show() \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Average number of ICD codes per subject: 12.615477214101462\n",
            "Average number of visits per patient: 1.267755803955288\n",
            "Number of patients with less than 2 visits: 38983\n",
            "Number of patients with more than 2 visits: 7537\n"
          ]
        }
      ],
      "source": [
        "# avg no. of icd-9 codes assigned to a subject\n",
        "avg_icd_per_subject = diagnoses.groupby('SUBJECT_ID')['ICD9_CODE'].nunique().mean()\n",
        "\n",
        "# avg visits per subject\n",
        "avg_visits_per_subject = diagnoses.groupby('SUBJECT_ID')['HADM_ID'].nunique().mean()\n",
        "\n",
        "# subjects with less than 2 visits\n",
        "subjects_less_than_2_visits = (diagnoses.groupby('SUBJECT_ID')['HADM_ID'].nunique() < 2).sum()\n",
        "\n",
        "# subjects with more than 2 visits\n",
        "subjects_more_than_2_visits = (diagnoses.groupby('SUBJECT_ID')['HADM_ID'].nunique() >= 2).sum()\n",
        "\n",
        "print(f\"Average number of ICD codes per subject: {avg_icd_per_subject}\")\n",
        "print(f\"Average number of visits per patient: {avg_visits_per_subject}\")\n",
        "print(f\"Number of patients with less than 2 visits: {subjects_less_than_2_visits}\")\n",
        "print(f\"Number of patients with more than 2 visits: {subjects_more_than_2_visits}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(651047, 5)"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "diagnoses.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "id": "S4cuGBqEQJTX"
      },
      "outputs": [],
      "source": [
        "# first, remove patients with less than 2 visits\n",
        "diagnoses = diagnoses.groupby('SUBJECT_ID').filter(lambda x: x['HADM_ID'].nunique() >= 2)\n",
        "# diagnoses.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "lySkAOtNQs79"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(260326, 5)"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# each row indicates an icd code entry given a patient's visit\n",
        "diagnoses.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dJAKXGQfEpBt",
        "outputId": "49927115-d8f2-4e52-f0cc-60f492553e43"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Number of unique patients with 2+ visits: 7537\n",
            "Total number of unique patients: 7537\n"
          ]
        }
      ],
      "source": [
        "filtered_diagnoses = diagnoses.groupby('SUBJECT_ID').filter(lambda x: len(x['HADM_ID']) >= 2)\n",
        "unique_patients_with_multiple_visits = filtered_diagnoses['SUBJECT_ID'].nunique()\n",
        "\n",
        "unique_patients = diagnoses['SUBJECT_ID'].nunique()\n",
        "\n",
        "print(f\"Number of unique patients with 2+ visits: {unique_patients_with_multiple_visits}\")\n",
        "print(f\"Total number of unique patients: {unique_patients}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KMzrsrfhUD5N",
        "outputId": "3f1dcaa6-4ca9-46ab-c43f-cc74780cf2c5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Missing values in selected Diagnoses:\n",
            "SUBJECT_ID     0\n",
            "HADM_ID        0\n",
            "SEQ_NUM       44\n",
            "ICD9_CODE     44\n",
            "dtype: int64\n"
          ]
        }
      ],
      "source": [
        "# for diagnosis, hospital admission id, and icd-9 codes\n",
        "# goal: diagnose HF at a patient level\n",
        "diags = diagnoses[['SUBJECT_ID', 'HADM_ID', 'SEQ_NUM', 'ICD9_CODE']]\n",
        "# print(diags.head())\n",
        "print(\"\\nMissing values in selected Diagnoses:\")\n",
        "print(diags.isnull().sum())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Missing values in cleaned Diagnoses:\n",
            "SUBJECT_ID    0\n",
            "HADM_ID       0\n",
            "SEQ_NUM       0\n",
            "ICD9_CODE     0\n",
            "dtype: int64\n"
          ]
        }
      ],
      "source": [
        "# dropping rows (patients) with missing values\n",
        "diags = diags.dropna(subset=['SEQ_NUM', 'ICD9_CODE'])\n",
        "# print(diags.head())\n",
        "print(\"\\nMissing values in cleaned Diagnoses:\")\n",
        "print(diags.isnull().sum())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(260326, 5)"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "diagnoses.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "xXqpRGr4VNCp",
        "outputId": "ae6d2131-68d7-41e5-9f33-fe5a373b39e7"
      },
      "outputs": [],
      "source": [
        "# heart failure diagnosis for binary label\n",
        "hf_icd9_codes = ['4250', '4251', '4252', '4253', '4254', '4255', '4257', '4258', '4259', '42983',\n",
        "                 '42830', '42832', '42840', '42842',\n",
        "                 '39891', '4280', '4281', '42820', '42822', '4289',\n",
        "                 '40211', '40291',\n",
        "                 '40411', '40491',\n",
        "                 '4168', '4169'\n",
        "                 ]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l5tiuH5EWTm1",
        "outputId": "1f23db62-e4b0-4e37-937c-4dd3e92f1cfc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Frequencies of heart failure (1 = prevalence in an encounter; 0 = non-prevalence):\n",
            "heart_failure\n",
            "0    248961\n",
            "1     11365\n",
            "Name: count, dtype: int64)\n"
          ]
        }
      ],
      "source": [
        "# counting heart failure cases\n",
        "diags = diagnoses[['ICD9_CODE', 'SUBJECT_ID', 'SEQ_NUM']].copy()\n",
        "diags['heart_failure'] = diags['ICD9_CODE'].isin(hf_icd9_codes).astype(int)\n",
        "diags.head()\n",
        "\n",
        "heart_failure_frequencies = diags['heart_failure'].value_counts()\n",
        "print(f\"\\nFrequencies of heart failure (1 = prevalence in an encounter; 0 = non-prevalence):\\n{heart_failure_frequencies})\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "uVpmdCzJOOG7",
        "outputId": "6a73a281-1dae-4706-a37f-60ea7491f41c"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# visualizing the classes\n",
        "\n",
        "# hf percentages in dataset\n",
        "total = sum(heart_failure_frequencies)\n",
        "percentages = (heart_failure_frequencies / total) * 100\n",
        "\n",
        "# hf value counts\n",
        "ax = heart_failure_frequencies.plot(kind='bar')\n",
        "plt.title('Heart failure frequencies')\n",
        "plt.xlabel('Heart failure ocurrence')\n",
        "plt.ylabel('Count')\n",
        "plt.xticks(rotation=0)\n",
        "\n",
        "# annotating bars\n",
        "for idx, rect in enumerate(ax.patches):\n",
        "    height = rect.get_height()\n",
        "    ax.text(rect.get_x() + rect.get_width()/2., height + 5,\n",
        "            '{:.1f}%'.format(percentages[idx]),\n",
        "            ha='center', va='bottom', color='black')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The goal now is to create sequence of visits for each patient.\n",
        "Given the patient trajectory, if a certain visit has a heart failure (HF) code:  \n",
        "\n",
        "    - Remove that specific visit and the subsequent ones;\n",
        "    - Label the patient as HF = 1;\n",
        "    - Else, label the patient as HF = 0."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {},
      "outputs": [],
      "source": [
        "# diagnoses.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(260326, 5)"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "diagnoses.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {},
      "outputs": [],
      "source": [
        "# sort diagnoses by SUBJECT_ID and SEQ_NUM (patients visits in chronological order)\n",
        "sorted_df = diagnoses.copy().sort_values(by=['SUBJECT_ID', 'HADM_ID'])\n",
        "# sorted_df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The data type of the 'ICD9_CODE' column is: <class 'str'>\n"
          ]
        }
      ],
      "source": [
        "icd9_code_type = type(sorted_df['ICD9_CODE'].iloc[0])\n",
        "print(f\"The data type of the 'ICD9_CODE' column is: {icd9_code_type}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [],
      "source": [
        "# create sequences of visits for each patient\n",
        "patient_sequences = {}\n",
        "\n",
        "for _, row in sorted_df.iterrows():\n",
        "    patient_id = row['SUBJECT_ID']\n",
        "    visit_id = row['HADM_ID']\n",
        "    \n",
        "    if patient_id not in patient_sequences:\n",
        "        patient_sequences[patient_id] = {}\n",
        "    if visit_id not in patient_sequences[patient_id]:\n",
        "        patient_sequences[patient_id][visit_id] = []\n",
        "    \n",
        "    patient_sequences[patient_id][visit_id].append(row.to_dict())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' first_2_sequences = dict(list(patient_sequences.items())[:2])\\n\\n# visualizing the first 2 patient sequences\\nfor patient_id, visits in list(patient_sequences.items())[:5]:\\n    print(f\"Patient ID: {patient_id}\")\\n    for visit_id, codes in visits.items():\\n        print(f\"Visit ID: {visit_id}\")\\n        for code in codes:\\n            print(code)\\n        print(\"\\n\")\\n    print(\"-\"*50 + \"\\n\") '"
            ]
          },
          "execution_count": 79,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" first_2_sequences = dict(list(patient_sequences.items())[:2])\n",
        "\n",
        "# visualizing the first 2 patient sequences\n",
        "for patient_id, visits in list(patient_sequences.items())[:5]:\n",
        "    print(f\"Patient ID: {patient_id}\")\n",
        "    for visit_id, codes in visits.items():\n",
        "        print(f\"Visit ID: {visit_id}\")\n",
        "        for code in codes:\n",
        "            print(code)\n",
        "        print(\"\\n\")\n",
        "    print(\"-\"*50 + \"\\n\") \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {},
      "outputs": [],
      "source": [
        "hf_labels = {}\n",
        "\n",
        "# iterating over each patient's sequence of visits\n",
        "for patient_id, visits in list(patient_sequences.items()): \n",
        "    hf_detected = False\n",
        "    visits_to_remove = []\n",
        "    first_visit_id = min(visits.keys())\n",
        "\n",
        "    # checking if HF code exists in the first visit\n",
        "    for code in visits[first_visit_id]:\n",
        "        if code['ICD9_CODE'] in hf_icd9_codes:\n",
        "            hf_detected = True\n",
        "            del patient_sequences[patient_id]  # remove the patient entirely from the sequences\n",
        "            break\n",
        "\n",
        "    # if HF code is found in the first visit, skip the remaining checks for this patient and do not assign a label\n",
        "    if hf_detected:\n",
        "        continue\n",
        "\n",
        "    # checking the other visits for the HF codes\n",
        "    for visit_id, codes in visits.items():\n",
        "        if hf_detected:  # if HF was detected in a previous visit, mark all subsequent visits for removal\n",
        "            visits_to_remove.append(visit_id)\n",
        "            continue  # skip the current visit\n",
        "\n",
        "        for code in codes:\n",
        "            if code['ICD9_CODE'] in hf_icd9_codes:\n",
        "                hf_detected = True\n",
        "                visits_to_remove.append(visit_id)\n",
        "                break  # once HF code is detected, stop checking other codes in the current visit\n",
        "\n",
        "    # remove visits marked for deletion\n",
        "    for vid in visits_to_remove:\n",
        "        del visits[vid]\n",
        "\n",
        "    # assign HF label to a patient based on detection\n",
        "    hf_labels[patient_id] = 1 if hf_detected else 0\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' # visualizing the updated patient sequences and HF labels for the first 2 patients\\nfor patient_id, visits in list(patient_sequences.items())[:2]:\\n    print(f\"Patient ID: {patient_id}, HF Label: {hf_labels[patient_id]}\")\\n    for visit_id, codes in visits.items():\\n        print(f\"Visit ID: {visit_id}\")\\n        for code in codes:\\n            print(code)\\n        print(\"\\n\")\\n    print(\"-\"*50 + \"\\n\") '"
            ]
          },
          "execution_count": 71,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" # visualizing the updated patient sequences and HF labels for the first 2 patients\n",
        "for patient_id, visits in list(patient_sequences.items())[:2]:\n",
        "    print(f\"Patient ID: {patient_id}, HF Label: {hf_labels[patient_id]}\")\n",
        "    for visit_id, codes in visits.items():\n",
        "        print(f\"Visit ID: {visit_id}\")\n",
        "        for code in codes:\n",
        "            print(code)\n",
        "        print(\"\\n\")\n",
        "    print(\"-\"*50 + \"\\n\") \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' # get patient IDs with HF label = 1\\npatients_with_hf = [patient_id for patient_id, label in hf_labels.items() if label == 1]\\n\\n# visualizing the sequences for the first 2 patients with HF label = 1\\nfor patient_id in patients_with_hf[:2]:\\n    visits = patient_sequences[patient_id]\\n    print(f\"Patient ID: {patient_id}, HF Label: {hf_labels[patient_id]}\")\\n    for visit_id, codes in visits.items():\\n        print(f\"Visit ID: {visit_id}\")\\n        for code in codes:\\n            print(code)\\n        print(\"\\n\")\\n    print(\"-\"*50 + \"\\n\")\\n '"
            ]
          },
          "execution_count": 72,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" # get patient IDs with HF label = 1\n",
        "patients_with_hf = [patient_id for patient_id, label in hf_labels.items() if label == 1]\n",
        "\n",
        "# visualizing the sequences for the first 2 patients with HF label = 1\n",
        "for patient_id in patients_with_hf[:2]:\n",
        "    visits = patient_sequences[patient_id]\n",
        "    print(f\"Patient ID: {patient_id}, HF Label: {hf_labels[patient_id]}\")\n",
        "    for visit_id, codes in visits.items():\n",
        "        print(f\"Visit ID: {visit_id}\")\n",
        "        for code in codes:\n",
        "            print(code)\n",
        "        print(\"\\n\")\n",
        "    print(\"-\"*50 + \"\\n\")\n",
        " \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Number of patients with label 1 (HF): 980\n",
            "Number of patients with label 0 (No HF): 3896\n"
          ]
        }
      ],
      "source": [
        "from collections import Counter\n",
        "\n",
        "# count the labels\n",
        "label_counts = Counter(hf_labels.values())\n",
        "count_label_1 = label_counts[1]\n",
        "count_label_0 = label_counts[0]\n",
        "\n",
        "print(f\"Number of patients with label 1 (HF): {count_label_1}\")\n",
        "print(f\"Number of patients with label 0 (No HF): {count_label_0}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# plotting the hf frequencies\n",
        "labels = ['HF (1)', 'No HF (0)']\n",
        "counts = [count_label_1, count_label_0]\n",
        "\n",
        "plt.figure(figsize=(8,6))\n",
        "bars = plt.bar(labels, counts)\n",
        "\n",
        "for bar in bars:\n",
        "    height = bar.get_height()\n",
        "    plt.text(bar.get_x() + bar.get_width()/2, height + 50, str(height), ha='center', va='bottom')\n",
        "\n",
        "plt.xlabel('Labels')\n",
        "plt.ylabel('Number of patients')\n",
        "plt.title('Distribution of patients based on heart failure Label')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {},
      "outputs": [],
      "source": [
        "# flatten the patient_sequences\n",
        "flattened_data = []\n",
        "\n",
        "for patient_id, visits in patient_sequences.items():\n",
        "    for visit_id, codes in visits.items():\n",
        "        # extracting icd codes for the visit\n",
        "        icd9_codes_for_visit = [code['ICD9_CODE'] for code in codes]\n",
        "        \n",
        "        flattened_data.append({\n",
        "            'patient_id': patient_id,\n",
        "            'visit_id': visit_id,\n",
        "            'icd9_codes': icd9_codes_for_visit,\n",
        "            'label': hf_labels[patient_id]\n",
        "        })\n",
        "\n",
        "# convert the list of dictionaries into a df\n",
        "flattened_df = pd.DataFrame(flattened_data)\n",
        "# flattened_df.head()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {},
      "outputs": [],
      "source": [
        "# expanding df\n",
        "expanded_df = flattened_df.explode('icd9_codes').reset_index(drop=True)\n",
        "\n",
        "# truncating ICD9 codes to first 4 characters\n",
        "expanded_df['icd9_codes'] = expanded_df['icd9_codes'].str[:4]\n",
        "# expanded_df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {},
      "outputs": [],
      "source": [
        "# one-hot encoding the truncated icd codes\n",
        "encoded_icd9 = pd.get_dummies(expanded_df['icd9_codes'])\n",
        "\n",
        "# joining the encoded icd dataframe with the expanded dataframe\n",
        "final_df = expanded_df.join(encoded_icd9)\n",
        "\n",
        "# drop the icd9_codes column\n",
        "final_df = final_df.drop(['icd9_codes'], axis=1)\n",
        "final_df = final_df * 1\n",
        "\n",
        "# final_df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "pos_weight: 6.818854808807373\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "\n",
        "# pos_weight for optional use in loss\n",
        "hf_label_counts = final_df['label'].value_counts()\n",
        "non_hf_frequency = hf_label_counts[0]\n",
        "hf_frequency = hf_label_counts[1]\n",
        "\n",
        "pos_weight = torch.tensor([non_hf_frequency / hf_frequency], dtype=torch.float32)\n",
        "print(\"pos_weight:\", pos_weight.item())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "D4id3QnYoEz_"
      },
      "outputs": [],
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "X = final_df.drop(columns=['label'])\n",
        "y = final_df['label']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3BmK5-0LoR38",
        "outputId": "ae925bf9-97ce-4220-ace8-4173c6cc6457"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(120426, 120426)"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(X), len(y) # no. samples"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RXEO-gLjoTlq",
        "outputId": "f5f28bff-459c-4011-bc03-e2c3d9762f47"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' print(f\"First 5 samples of X: {X[:5]}\")\\nprint(f\"First 5 samples of Y: {y[:5]}\") '"
            ]
          },
          "execution_count": 76,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" print(f\"First 5 samples of X: {X[:5]}\")\n",
        "print(f\"First 5 samples of Y: {y[:5]}\") \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T-pKuAH3oUw7",
        "outputId": "d5e7b5f2-7f83-4fe0-bb32-aaa3c7d9c325"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Number of features in X: 2773\n"
          ]
        }
      ],
      "source": [
        "num_features = X.shape[1]\n",
        "print(f\"Number of features in X: {num_features}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2REbkQOTo70W",
        "outputId": "e690273b-a856-4c7a-ece4-0208f559b09a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "((120426, 2773), (120426,))"
            ]
          },
          "execution_count": 38,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X.shape, y.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fwebR-DlpC6X",
        "outputId": "237b5df8-6e11-4c1c-ab04-cc262ba16be4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'2.0.1+cpu'"
            ]
          },
          "execution_count": 39,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "torch.__version__"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EiRarydypFFB",
        "outputId": "b6081c7e-e524-4c76-950a-eadb17485a73"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' print(type(X), X.dtype)\\nprint(type(y), X.dtype)\\n '"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" print(type(X), X.dtype)\n",
        "print(type(y), X.dtype)\n",
        " \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {},
      "outputs": [],
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=22)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LNFb8Qsrq57W",
        "outputId": "76d3e3e2-cd18-40d3-cdd4-9382fa8d26b9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(96340, 24086, 96340, 24086)"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(X_train), len(X_test), len(y_train), len(y_test)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c0s3D-19pG62",
        "outputId": "3128922d-45bf-4308-9187-c9378adbe04a"
      },
      "outputs": [],
      "source": [
        "# convert data to tensors\n",
        "X_train_tensor = torch.tensor(X_train.values, dtype=torch.float32)\n",
        "y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32).unsqueeze(1)  # extra dim for the label\n",
        "\n",
        "X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)\n",
        "y_test_tensor = torch.tensor(y_test.values, dtype=torch.float32).unsqueeze(1)  # extra dim for the label\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {},
      "outputs": [],
      "source": [
        "# creating custom dataset\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "\n",
        "class MIMICDataset(Dataset):\n",
        "    def __init__(self, X, y):\n",
        "        self.X = X\n",
        "        self.y = y\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.X)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        return self.X[idx], self.y[idx]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {},
      "outputs": [],
      "source": [
        "# creating data loaders\n",
        "BATCH_SIZE = 32  \n",
        "\n",
        "train_dataset = MIMICDataset(X_train_tensor, y_train_tensor)\n",
        "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
        "\n",
        "test_dataset = MIMICDataset(X_test_tensor, y_test_tensor)\n",
        "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(torch.Size([32, 2773]), torch.Size([32, 1]))"
            ]
          },
          "execution_count": 46,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "train_features_batch, train_labels_batch = next(iter(train_loader))\n",
        "train_features_batch.shape, train_labels_batch.shape # 32 batches with 2773 features; 32 batches with 1 feature (label)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Taj73zACq-7N",
        "outputId": "15d90071-8e5b-4e81-ce31-055abf7e4c26"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'cpu'"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "1j7QcXLCrSWi"
      },
      "outputs": [],
      "source": [
        "class MLP_MIMIC_V0(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    self.layer_stack = nn.Sequential(\n",
        "    nn.Linear(in_features=2773, out_features=246),\n",
        "    nn.ReLU(),\n",
        "    nn.Linear(in_features=246, out_features=246),\n",
        "    nn.ReLU(),\n",
        "    nn.Linear(in_features=246, out_features=1))\n",
        "\n",
        "  def forward(self, x):\n",
        "    return self.layer_stack(x)\n",
        "\n",
        "model_0 = MLP_MIMIC_V0().to(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aqfYmXz_sA3Q",
        "outputId": "93ed4ac3-39e3-4124-90b5-b7da5b050d2b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' model_0.state_dict()\\n '"
            ]
          },
          "execution_count": 49,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" model_0.state_dict()\n",
        " \"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "id": "TKtYQfkhsMMc"
      },
      "outputs": [],
      "source": [
        "loss_fn = nn.BCEWithLogitsLoss() # binary cross entropy loss with built in sigmoid; pos_weight=pos_weight use is optional\n",
        "\n",
        "optimizer = torch.optim.Adam(params=model_0.parameters(), lr=0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "id": "aktFvR4EsOw9"
      },
      "outputs": [],
      "source": [
        "def accuracy_fn(y_true, y_pred):\n",
        "  correct = torch.eq(y_true, y_pred).sum().item()\n",
        "  acc = (correct/len(y_pred)) * 100\n",
        "  return acc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pHxk8361sQEy",
        "outputId": "9e488515-f769-4c1d-8974-54198d021c0f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "MLP_MIMIC_V0(\n",
              "  (layer_stack): Sequential(\n",
              "    (0): Linear(in_features=2773, out_features=246, bias=True)\n",
              "    (1): ReLU()\n",
              "    (2): Linear(in_features=246, out_features=246, bias=True)\n",
              "    (3): ReLU()\n",
              "    (4): Linear(in_features=246, out_features=1, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MN7Gc8azsZgi",
        "outputId": "3f94c03f-6a86-4e36-8547-d4ce2f8f3765"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 1 | Train loss: 3.842 | Train acc: 87.037 | Test loss: 0.382 | Test acc: 87.322\n",
            "Epoch: 2 | Train loss: 0.384 | Train acc: 87.181 | Test loss: 0.381 | Test acc: 87.322\n",
            "Epoch: 3 | Train loss: 0.384 | Train acc: 87.182 | Test loss: 0.380 | Test acc: 87.322\n",
            "Epoch: 4 | Train loss: 0.384 | Train acc: 87.182 | Test loss: 0.380 | Test acc: 87.322\n",
            "Epoch: 5 | Train loss: 0.384 | Train acc: 87.180 | Test loss: 0.381 | Test acc: 87.322\n",
            "Epoch: 6 | Train loss: 0.383 | Train acc: 87.182 | Test loss: 0.380 | Test acc: 87.322\n",
            "Epoch: 7 | Train loss: 0.383 | Train acc: 87.182 | Test loss: 0.380 | Test acc: 87.322\n",
            "Epoch: 8 | Train loss: 0.383 | Train acc: 87.180 | Test loss: 0.380 | Test acc: 87.322\n",
            "Epoch: 9 | Train loss: 0.383 | Train acc: 87.183 | Test loss: 0.380 | Test acc: 87.322\n",
            "Epoch: 10 | Train loss: 0.383 | Train acc: 87.182 | Test loss: 0.380 | Test acc: 87.322\n"
          ]
        }
      ],
      "source": [
        "# training loop for model_0\n",
        "torch.manual_seed(22)\n",
        "torch.cuda.manual_seed(22)\n",
        "model_0.to(device)\n",
        "\n",
        "# for tracking model progress\n",
        "epoch_count_0 = []\n",
        "train_loss_values_0 = []\n",
        "train_acc_values_0 = []\n",
        "test_loss_values_0 = []\n",
        "test_acc_values_0 = []\n",
        "\n",
        "# epochs\n",
        "epochs = 10\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    model_0.train()\n",
        "    running_train_loss = 0.0\n",
        "    running_train_acc = 0.0\n",
        "    \n",
        "    # train loop w dataloaders\n",
        "    for batch_X, batch_y in train_loader:\n",
        "        batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
        "        \n",
        "        y_logits = model_0(batch_X).squeeze(1)\n",
        "        batch_y = batch_y.squeeze(1)\n",
        "        y_pred = torch.round(torch.sigmoid(y_logits))\n",
        "        \n",
        "        train_loss = loss_fn(y_logits, batch_y)\n",
        "        train_acc = accuracy_fn(y_true=batch_y, y_pred=y_pred)\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        train_loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        running_train_loss += train_loss\n",
        "        running_train_acc += train_acc\n",
        "    \n",
        "    # avg out the loss and accuracy over the entire dataset\n",
        "    average_train_loss = running_train_loss / len(train_loader)\n",
        "    average_train_acc = running_train_acc / len(train_loader)\n",
        "\n",
        "    # test loop w dataloaders\n",
        "    model_0.eval()\n",
        "    running_test_loss = 0.0\n",
        "    running_test_acc = 0.0\n",
        "    \n",
        "    with torch.inference_mode():\n",
        "        for batch_X, batch_y in test_loader:\n",
        "            batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
        "            \n",
        "            test_logits = model_0(batch_X).squeeze(1)\n",
        "            batch_y = batch_y.squeeze(1)\n",
        "            test_pred = torch.round(torch.sigmoid(test_logits))\n",
        "            \n",
        "            test_loss = loss_fn(test_logits, batch_y)\n",
        "            test_acc = accuracy_fn(y_true=batch_y, y_pred=test_pred)\n",
        "            \n",
        "            running_test_loss += test_loss\n",
        "            running_test_acc += test_acc\n",
        "    \n",
        "    average_test_loss = running_test_loss / len(test_loader)\n",
        "    average_test_acc = running_test_acc / len(test_loader)\n",
        "\n",
        "    epoch_count_0.append(epoch)\n",
        "    train_loss_values_0.append(average_train_loss)\n",
        "    train_acc_values_0.append(average_train_acc)\n",
        "    test_loss_values_0.append(average_test_loss)\n",
        "    test_acc_values_0.append(average_test_acc)\n",
        "\n",
        "    print(f\"Epoch: {epoch + 1} | Train loss: {average_train_loss:.3f} | Train acc: {average_train_acc:.3f} | Test loss: {average_test_loss:.3f} | Test acc: {average_test_acc:.3f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {},
      "outputs": [],
      "source": [
        "class MLP_MIMIC_V1(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "        self.layer_stack = nn.Sequential(\n",
        "            nn.Linear(in_features=2773, out_features=512),\n",
        "            nn.BatchNorm1d(512),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(0.5),\n",
        "\n",
        "            nn.Linear(in_features=512, out_features=256),\n",
        "            nn.BatchNorm1d(256),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(0.5),\n",
        "\n",
        "            nn.Linear(in_features=256, out_features=128),\n",
        "            nn.BatchNorm1d(128),\n",
        "            nn.ReLU(),\n",
        "            nn.Dropout(0.5),\n",
        "\n",
        "            nn.Linear(in_features=128, out_features=1)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.layer_stack(x)\n",
        "\n",
        "model_1 = MLP_MIMIC_V1().to(device)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "MLP_MIMIC_V1(\n",
              "  (layer_stack): Sequential(\n",
              "    (0): Linear(in_features=2773, out_features=512, bias=True)\n",
              "    (1): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (2): ReLU()\n",
              "    (3): Dropout(p=0.5, inplace=False)\n",
              "    (4): Linear(in_features=512, out_features=256, bias=True)\n",
              "    (5): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (6): ReLU()\n",
              "    (7): Dropout(p=0.5, inplace=False)\n",
              "    (8): Linear(in_features=256, out_features=128, bias=True)\n",
              "    (9): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    (10): ReLU()\n",
              "    (11): Dropout(p=0.5, inplace=False)\n",
              "    (12): Linear(in_features=128, out_features=1, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "execution_count": 64,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 1 | Train loss: 0.365 | Train acc: 87.148 | Test loss: 0.353 | Test acc: 87.322\n",
            "Epoch: 2 | Train loss: 0.361 | Train acc: 87.166 | Test loss: 0.354 | Test acc: 87.322\n",
            "Epoch: 3 | Train loss: 0.360 | Train acc: 87.180 | Test loss: 0.352 | Test acc: 87.322\n",
            "Epoch: 4 | Train loss: 0.360 | Train acc: 87.180 | Test loss: 0.351 | Test acc: 87.322\n",
            "Epoch: 5 | Train loss: 0.360 | Train acc: 87.181 | Test loss: 0.352 | Test acc: 87.322\n",
            "Epoch: 6 | Train loss: 0.360 | Train acc: 87.177 | Test loss: 0.352 | Test acc: 87.322\n",
            "Epoch: 7 | Train loss: 0.360 | Train acc: 87.177 | Test loss: 0.351 | Test acc: 87.322\n",
            "Epoch: 8 | Train loss: 0.360 | Train acc: 87.172 | Test loss: 0.351 | Test acc: 87.322\n",
            "Epoch: 9 | Train loss: 0.360 | Train acc: 87.174 | Test loss: 0.352 | Test acc: 87.322\n",
            "Epoch: 10 | Train loss: 0.360 | Train acc: 87.180 | Test loss: 0.350 | Test acc: 87.322\n"
          ]
        }
      ],
      "source": [
        "loss_fn = nn.BCEWithLogitsLoss() # binary cross entropy loss with built in sigmoid\n",
        "optimizer = torch.optim.Adam(params=model_1.parameters(), lr=0.01)\n",
        "\n",
        "# training loop for model_1\n",
        "torch.manual_seed(22)\n",
        "torch.cuda.manual_seed(22)\n",
        "model_1.to(device)\n",
        "\n",
        "# for tracking model progress\n",
        "epoch_count_1 = []\n",
        "train_loss_values_1 = []\n",
        "train_acc_values_1 = []\n",
        "test_loss_values_1 = []\n",
        "test_acc_values_1 = []\n",
        "\n",
        "# epochs\n",
        "epochs = 10\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    model_1.train()\n",
        "    running_train_loss = 0.0\n",
        "    running_train_acc = 0.0\n",
        "    \n",
        "    # train loop w dataloaders\n",
        "    for batch_X, batch_y in train_loader:\n",
        "        batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
        "        \n",
        "        y_logits = model_1(batch_X).squeeze(1)\n",
        "        batch_y = batch_y.squeeze(1)\n",
        "        y_pred = torch.round(torch.sigmoid(y_logits))\n",
        "        \n",
        "        train_loss = loss_fn(y_logits, batch_y)\n",
        "        train_acc = accuracy_fn(y_true=batch_y, y_pred=y_pred)\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        train_loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        running_train_loss += train_loss\n",
        "        running_train_acc += train_acc\n",
        "    \n",
        "    # avg out the loss and accuracy over the entire dataset\n",
        "    average_train_loss = running_train_loss / len(train_loader)\n",
        "    average_train_acc = running_train_acc / len(train_loader)\n",
        "\n",
        "    # test loop w dataloaders\n",
        "    model_1.eval()\n",
        "    running_test_loss = 0.0\n",
        "    running_test_acc = 0.0\n",
        "    \n",
        "    with torch.inference_mode():\n",
        "        for batch_X, batch_y in test_loader:\n",
        "            batch_X, batch_y = batch_X.to(device), batch_y.to(device)\n",
        "            \n",
        "            test_logits = model_1(batch_X).squeeze(1)\n",
        "            batch_y = batch_y.squeeze(1)\n",
        "            test_pred = torch.round(torch.sigmoid(test_logits))\n",
        "            \n",
        "            test_loss = loss_fn(test_logits, batch_y)\n",
        "            test_acc = accuracy_fn(y_true=batch_y, y_pred=test_pred)\n",
        "            \n",
        "            running_test_loss += test_loss\n",
        "            running_test_acc += test_acc\n",
        "    \n",
        "    average_test_loss = running_test_loss / len(test_loader)\n",
        "    average_test_acc = running_test_acc / len(test_loader)\n",
        "\n",
        "    epoch_count_1.append(epoch)\n",
        "    train_loss_values_1.append(average_train_loss)\n",
        "    train_acc_values_1.append(average_train_acc)\n",
        "    test_loss_values_1.append(average_test_loss)\n",
        "    test_acc_values_1.append(average_test_acc)\n",
        "\n",
        "    print(f\"Epoch: {epoch + 1} | Train loss: {average_train_loss:.3f} | Train acc: {average_train_acc:.3f} | Test loss: {average_test_loss:.3f} | Test acc: {average_test_acc:.3f}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model evaluations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Model 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "0hh-WkWTuGrF",
        "outputId": "d5d6d0ef-44f5-4d67-f3a3-5b1896f0e221"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "plt.plot(epoch_count_0, np.array(torch.tensor(train_loss_values_0).numpy()), label=\"Train loss\")\n",
        "plt.plot(epoch_count_0, np.array(torch.tensor(test_loss_values_0).numpy()), label=\"Test loss\")\n",
        "plt.title(\"Train and test loss - Model 0\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.legend();"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 329
        },
        "id": "FC8Ai8ZjPFmA",
        "outputId": "762056b0-dcf7-402f-89f3-508ff7adf5fa"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(12, 6))\n",
        "\n",
        "plt.plot(epoch_count_0, train_acc_values_0, '-o', label='Train Accuracy', color='blue')\n",
        "plt.plot(epoch_count_0, test_acc_values_0, '-o', label='Test Accuracy', color='red')\n",
        "\n",
        "plt.title('Train and test accuracy - Model 0')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.tight_layout()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "8N3vPCXJMxfs",
        "outputId": "7456a30f-f32e-4acf-9f31-9a32e67e019e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "AUC for MLP Model 0: 0.5000\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import roc_curve, auc\n",
        "\n",
        "all_test_probabilities = []\n",
        "all_true_labels = []\n",
        "\n",
        "# iterating w test loader\n",
        "with torch.inference_mode():\n",
        "    for batch_X, batch_y in test_loader:\n",
        "        # device agnostic \n",
        "        batch_X = batch_X.cuda() if next(model_0.parameters()).is_cuda else batch_X\n",
        "        batch_y = batch_y.cuda() if next(model_0.parameters()).is_cuda else batch_y\n",
        "        \n",
        "        test_logits = model_0(batch_X).squeeze()\n",
        "        test_probabilities = torch.sigmoid(test_logits).cpu().numpy()\n",
        "        \n",
        "        all_test_probabilities.extend(test_probabilities)\n",
        "        all_true_labels.extend(batch_y.cpu().numpy())\n",
        "\n",
        "# false positive and true positive rates and thresholds\n",
        "fpr, tpr, thresholds = roc_curve(all_true_labels, all_test_probabilities)\n",
        "\n",
        "# calculate auc\n",
        "roc_auc = auc(fpr, tpr)\n",
        "\n",
        "# print auc\n",
        "print(f\"AUC for MLP Model 0: {roc_auc:.4f}\")\n",
        "\n",
        "# plot roc and auc\n",
        "plt.figure()\n",
        "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n",
        "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')  # random classifier diagonal\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.ylim([0.0, 1.05])\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('ROC Curve - MLP Model 0')\n",
        "plt.legend(loc=\"lower right\")\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Model 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "rkTgfoBsIPr0",
        "outputId": "57817e9e-57b8-4623-c4b3-8599e49f3dbf"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(epoch_count_1, np.array(torch.tensor(train_loss_values_1).numpy()), label=\"Train loss\")\n",
        "plt.plot(epoch_count_1, np.array(torch.tensor(test_loss_values_1).numpy()), label=\"Test loss\")\n",
        "plt.title(\"Train and test loss - Model 1\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.legend();"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 329
        },
        "id": "S57VEQEFPQMZ",
        "outputId": "26312cf5-a60b-4142-cfb2-1269aca090a8"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(12, 6))\n",
        "\n",
        "plt.plot(epoch_count_1, train_acc_values_1, '-o', label='Train Accuracy', color='blue')\n",
        "plt.plot(epoch_count_1, test_acc_values_1, '-o', label='Test Accuracy', color='red')\n",
        "\n",
        "plt.title('Train and test accuracy - Model 1')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.tight_layout()\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwxhg6X2JShN",
        "outputId": "dff6faa6-8a32-4d19-f318-8d77e341d7b4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "AUC for MLP Model 1: 0.7070\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "all_test_probabilities = []\n",
        "all_true_labels = []\n",
        "\n",
        "# iterating w test loader\n",
        "with torch.inference_mode():\n",
        "    for batch_X, batch_y in test_loader:\n",
        "        # device agnostic \n",
        "        batch_X = batch_X.cuda() if next(model_1.parameters()).is_cuda else batch_X\n",
        "        batch_y = batch_y.cuda() if next(model_1.parameters()).is_cuda else batch_y\n",
        "        \n",
        "        test_logits = model_1(batch_X).squeeze()\n",
        "        test_probabilities = torch.sigmoid(test_logits).cpu().numpy()\n",
        "        \n",
        "        all_test_probabilities.extend(test_probabilities)\n",
        "        all_true_labels.extend(batch_y.cpu().numpy())\n",
        "\n",
        "# false positive and true positive rates and thresholds\n",
        "fpr, tpr, thresholds = roc_curve(all_true_labels, all_test_probabilities)\n",
        "\n",
        "# calculate auc\n",
        "roc_auc = auc(fpr, tpr)\n",
        "\n",
        "# print auc\n",
        "print(f\"AUC for MLP Model 1: {roc_auc:.4f}\")\n",
        "\n",
        "# plot roc and auc\n",
        "plt.figure()\n",
        "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n",
        "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')  # random classifier diagonal\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.ylim([0.0, 1.05])\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('ROC Curve - MLP Model 1')\n",
        "plt.legend(loc=\"lower right\")\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "SUuJhO-8Uuoz",
        "outputId": "86dd459f-9e74-426e-f3f5-ca1e342f2314"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Accuracy: 0.87\n",
            "AUC: 0.70\n"
          ]
        }
      ],
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.metrics import accuracy_score, roc_auc_score, roc_curve\n",
        "\n",
        "# run logistic regression model\n",
        "logreg = LogisticRegression(max_iter=1000)\n",
        "logreg.fit(X_train, y_train.ravel())\n",
        "\n",
        "# predict probs\n",
        "y_pred_prob = logreg.predict_proba(X_test)[:,1]\n",
        "\n",
        "# compute accuracy\n",
        "y_pred = logreg.predict(X_test)\n",
        "accuracy = accuracy_score(y_test.ravel(), y_pred)\n",
        "\n",
        "# compute auc\n",
        "auc = roc_auc_score(y_test.ravel(), y_pred_prob)\n",
        "\n",
        "# compute and plot roc curve\n",
        "fpr, tpr, thresholds = roc_curve(y_test.ravel(), y_pred_prob)\n",
        "plt.figure(figsize=(10, 7))\n",
        "plt.plot(fpr, tpr, label=f'AUC: {auc:.2f}')\n",
        "plt.plot([0, 1], [0, 1], linestyle='--', color='red')\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('ROC Curve - Logistic Regression')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "print(f\"Accuracy: {accuracy:.2f}\")\n",
        "print(f\"AUC: {auc:.2f}\") \n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.9.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}