utf-8''C1M1_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chest X-Ray Medical Diagnosis with Deep Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FZYK-0rin5x7"
   },
   "source": [
    "<img src=\"xray-header-image.png\" style=\"padding-top: 50px;width: 87%;left: 0px;margin-left: 0px;margin-right: 0px;\">\n",
    "\n",
    "__Welcome to the first assignment of course 1!__ \n",
    "\n",
    "In this assignment! You will explore medical image diagnosis by building a state-of-the-art chest X-ray classifier using Keras. \n",
    "\n",
    "The assignment will walk through some of the steps of building and evaluating this deep learning classifier model. In particular, you will:\n",
    "- Pre-process and prepare a real-world X-ray dataset\n",
    "- Use transfer learning to retrain a DenseNet model for X-ray image classification\n",
    "- Learn a technique to handle class imbalance\n",
    "- Measure diagnostic performance by computing the AUC (Area Under the Curve) for the ROC (Receiver Operating Characteristic) curve\n",
    "- Visualize model activity using GradCAMs\n",
    "\n",
    "In completing this assignment you will learn about the following topics: \n",
    "\n",
    "- Data preparation\n",
    "  - Visualizing data\n",
    "  - Preventing data leakage\n",
    "- Model Development\n",
    "  - Addressing class imbalance\n",
    "  - Leveraging pre-trained models using transfer learning\n",
    "- Evaluation\n",
    "  - AUC and ROC curves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outline\n",
    "Use these links to jump to specific sections of this assignment!\n",
    "\n",
    "- [1. Import Packages and Function](#1)\n",
    "- [2. Load the Datasets](#2)\n",
    "    - [2.1 Preventing Data Leakage](#2-1)\n",
    "        - [Exercise 1 - Checking Data Leakage](#Ex-1)\n",
    "    - [2.2 Preparing Images](#2-2)\n",
    "- [3. Model Development](#3)\n",
    "    - [3.1 Addressing Class Imbalance](#3-1)\n",
    "        - [Exercise 2 - Computing Class Frequencies](#Ex-2)\n",
    "        - [Exercise 3 - Weighted Loss](#Ex-3)\n",
    "    - [3.3 DenseNet121](#3-3)\n",
    "- [4. Training [optional]](#4)\n",
    "    - [4.1 Training on the Larger Dataset](#4-1)\n",
    "- [5. Prediction and Evaluation](#5)\n",
    "    - [5.1 ROC Curve and AUROC](#5-1)\n",
    "    - [5.2 Visualizing Learning with GradCAM](#5-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XI8PBrk_2Z4V"
   },
   "source": [
    "<a name='1'></a>\n",
    "## 1. Import Packages and Functions¶\n",
    "\n",
    "We'll make use of the following packages:\n",
    "- `numpy` and `pandas` is what we'll use to manipulate our data\n",
    "- `matplotlib.pyplot` and `seaborn` will be used to produce plots for visualization\n",
    "- `util` will provide the locally defined utility functions that have been provided for this assignment\n",
    "\n",
    "We will also use several modules from the `keras` framework for building deep learning models.\n",
    "\n",
    "Run the next cell to import all the necessary packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Je3yV0Wnn5x8",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.applications.densenet import DenseNet121\n",
    "from keras.layers import Dense, GlobalAveragePooling2D\n",
    "from keras.models import Model\n",
    "from keras import backend as K\n",
    "\n",
    "from keras.models import load_model\n",
    "\n",
    "import util"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6PMDCWQRn5yA"
   },
   "source": [
    "<a name='2'></a>\n",
    "## 2 Load the Datasets\n",
    "\n",
    "For this assignment, we will be using the [ChestX-ray8 dataset](https://arxiv.org/abs/1705.02315) which contains 108,948 frontal-view X-ray images of 32,717 unique patients. \n",
    "- Each image in the data set contains multiple text-mined labels identifying 14 different pathological conditions. \n",
    "- These in turn can be used by physicians to diagnose 8 different diseases. \n",
    "- We will use this data to develop a single model that will provide binary classification predictions for each of the 14 labeled pathologies. \n",
    "- In other words it will predict 'positive' or 'negative' for each of the pathologies.\n",
    " \n",
    "You can download the entire dataset for free [here](https://nihcc.app.box.com/v/ChestXray-NIHCC). \n",
    "- We have provided a ~1000 image subset of the images for you.\n",
    "- These can be accessed in the folder path stored in the `IMAGE_DIR` variable.\n",
    "\n",
    "The dataset includes a CSV file that provides the labels for each X-ray. \n",
    "\n",
    "To make your job a bit easier, we have processed the labels for our small sample and generated three new files to get you started. These three files are:\n",
    "\n",
    "1. `nih/train-small.csv`: 875 images from our dataset to be used for training.\n",
    "1. `nih/valid-small.csv`: 109 images from our dataset to be used for validation.\n",
    "1. `nih/test.csv`: 420 images from our dataset to be used for testing. \n",
    "\n",
    "This dataset has been annotated by consensus among four different radiologists for 5 of our 14 pathologies:\n",
    "- `Consolidation`\n",
    "- `Edema`\n",
    "- `Effusion`\n",
    "- `Cardiomegaly`\n",
    "- `Atelectasis`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sidebar on meaning of 'class'\n",
    "It is worth noting that the word **'class'** is used in multiple ways is these discussions. \n",
    "- We sometimes refer to each of the 14 pathological conditions that are labeled in our dataset as a class. \n",
    "- But for each of those pathologies we are attempting to predict whether a certain condition is present (i.e. positive result) or absent (i.e. negative result). \n",
    "    - These two possible labels of 'positive' or 'negative' (or the numerical equivalent of 1 or 0) are also typically referred to as classes. \n",
    "- Moreover, we also use the term in reference to software code 'classes' such as `ImageDataGenerator`.\n",
    "\n",
    "As long as you are aware of all this though, it should not cause you any confusion as the term 'class' is usually clear from the context in which it is used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read in the data\n",
    "Let's open these files using the [pandas](https://pandas.pydata.org/) library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 224
    },
    "colab_type": "code",
    "id": "5JRSHB7i0t_6",
    "outputId": "69830050-af47-4ebc-946d-d411d0cbdf5b"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Image</th>\n",
       "      <th>Atelectasis</th>\n",
       "      <th>Cardiomegaly</th>\n",
       "      <th>Consolidation</th>\n",
       "      <th>Edema</th>\n",
       "      <th>Effusion</th>\n",
       "      <th>Emphysema</th>\n",
       "      <th>Fibrosis</th>\n",
       "      <th>Hernia</th>\n",
       "      <th>Infiltration</th>\n",
       "      <th>Mass</th>\n",
       "      <th>Nodule</th>\n",
       "      <th>PatientId</th>\n",
       "      <th>Pleural_Thickening</th>\n",
       "      <th>Pneumonia</th>\n",
       "      <th>Pneumothorax</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>00008270_015.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>8270</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>00029855_001.png</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>29855</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>00001297_000.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1297</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>00012359_002.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>12359</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>00017951_001.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>17951</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              Image  Atelectasis  Cardiomegaly  Consolidation  Edema  \\\n",
       "0  00008270_015.png            0             0              0      0   \n",
       "1  00029855_001.png            1             0              0      0   \n",
       "2  00001297_000.png            0             0              0      0   \n",
       "3  00012359_002.png            0             0              0      0   \n",
       "4  00017951_001.png            0             0              0      0   \n",
       "\n",
       "   Effusion  Emphysema  Fibrosis  Hernia  Infiltration  Mass  Nodule  \\\n",
       "0         0          0         0       0             0     0       0   \n",
       "1         1          0         0       0             1     0       0   \n",
       "2         0          0         0       0             0     0       0   \n",
       "3         0          0         0       0             0     0       0   \n",
       "4         0          0         0       0             1     0       0   \n",
       "\n",
       "   PatientId  Pleural_Thickening  Pneumonia  Pneumothorax  \n",
       "0       8270                   0          0             0  \n",
       "1      29855                   0          0             0  \n",
       "2       1297                   1          0             0  \n",
       "3      12359                   0          0             0  \n",
       "4      17951                   0          0             0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df = pd.read_csv(\"nih/train-small.csv\")\n",
    "valid_df = pd.read_csv(\"nih/valid-small.csv\")\n",
    "\n",
    "test_df = pd.read_csv(\"nih/test.csv\")\n",
    "\n",
    "train_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mrDoMlsun5yE"
   },
   "outputs": [],
   "source": [
    "labels = ['Cardiomegaly', \n",
    "          'Emphysema', \n",
    "          'Effusion', \n",
    "          'Hernia', \n",
    "          'Infiltration', \n",
    "          'Mass', \n",
    "          'Nodule', \n",
    "          'Atelectasis',\n",
    "          'Pneumothorax',\n",
    "          'Pleural_Thickening', \n",
    "          'Pneumonia', \n",
    "          'Fibrosis', \n",
    "          'Edema', \n",
    "          'Consolidation']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iKwFwpHLn5yG"
   },
   "source": [
    "<a name='2-1'></a>\n",
    "### 2.1 Preventing Data Leakage\n",
    "It is worth noting that our dataset contains multiple images for each patient. This could be the case, for example, when a patient has taken multiple X-ray images at different times during their hospital visits. In our data splitting, we have ensured that the split is done on the patient level so that there is no data \"leakage\" between the train, validation, and test datasets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Ex-1'></a>\n",
    "### Exercise 1 - Checking Data Leakage\n",
    "In the cell below, write a function to check whether there is leakage between two datasets. We'll use this to make sure there are no patients in the test set that are also present in either the train or validation sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>    \n",
    "<summary>\n",
    "    <font size=\"3\" color=\"darkgreen\"><b>Hints</b></font>\n",
    "</summary>\n",
    "<p>\n",
    "<ul>\n",
    "    <li> Make use of python's set.intersection() function. </li>\n",
    "    <li> In order to match the automatic grader's expectations, please start the line of code with <code>df1_patients_unique...[continue your code here]</code> </li>\n",
    "\n",
    "</ul>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jz6dwTSrUcKc"
   },
   "outputs": [],
   "source": [
    "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "def check_for_leakage(df1, df2, patient_col):\n",
    "    \"\"\"\n",
    "    Return True if there any patients are in both df1 and df2.\n",
    "\n",
    "    Args:\n",
    "        df1 (dataframe): dataframe describing first dataset\n",
    "        df2 (dataframe): dataframe describing second dataset\n",
    "        patient_col (str): string name of column with patient IDs\n",
    "    \n",
    "    Returns:\n",
    "        leakage (bool): True if there is leakage, otherwise False\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
    "    \n",
    "    df1_patients_unique = set(df1[patient_col].unique())\n",
    "    df2_patients_unique = set(df2[patient_col].unique())\n",
    "    \n",
    "    patients_in_both_groups = df1_patients_unique.intersection(df2_patients_unique)\n",
    "\n",
    "    # leakage contains true if there is patient overlap, otherwise false.\n",
    "    leakage = len(patients_in_both_groups) # boolean (true if there is at least 1 patient in both groups)\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return leakage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 544
    },
    "colab_type": "code",
    "id": "Rh2p1krrV1g5",
    "outputId": "9ee44d93-8ef1-4c98-f9fa-65b309b9b889"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test case 1\n",
      "df1\n",
      "   patient_id\n",
      "0           0\n",
      "1           1\n",
      "2           2\n",
      "df2\n",
      "   patient_id\n",
      "0           2\n",
      "1           3\n",
      "2           4\n",
      "leakage output: 1\n",
      "-------------------------------------\n",
      "test case 2\n",
      "df1:\n",
      "   patient_id\n",
      "0           0\n",
      "1           1\n",
      "2           2\n",
      "df2:\n",
      "   patient_id\n",
      "0           3\n",
      "1           4\n",
      "2           5\n",
      "leakage output: 0\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "print(\"test case 1\")\n",
    "df1 = pd.DataFrame({'patient_id': [0, 1, 2]})\n",
    "df2 = pd.DataFrame({'patient_id': [2, 3, 4]})\n",
    "print(\"df1\")\n",
    "print(df1)\n",
    "print(\"df2\")\n",
    "print(df2)\n",
    "print(f\"leakage output: {check_for_leakage(df1, df2, 'patient_id')}\")\n",
    "print(\"-------------------------------------\")\n",
    "print(\"test case 2\")\n",
    "df1 = pd.DataFrame({'patient_id': [0, 1, 2]})\n",
    "df2 = pd.DataFrame({'patient_id': [3, 4, 5]})\n",
    "print(\"df1:\")\n",
    "print(df1)\n",
    "print(\"df2:\")\n",
    "print(df2)\n",
    "\n",
    "print(f\"leakage output: {check_for_leakage(df1, df2, 'patient_id')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected output\n",
    "\n",
    "```Python\n",
    "test case 1\n",
    "df1\n",
    "   patient_id\n",
    "0           0\n",
    "1           1\n",
    "2           2\n",
    "df2\n",
    "   patient_id\n",
    "0           2\n",
    "1           3\n",
    "2           4\n",
    "leakage output: True\n",
    "-------------------------------------\n",
    "test case 2\n",
    "df1:\n",
    "   patient_id\n",
    "0           0\n",
    "1           1\n",
    "2           2\n",
    "df2:\n",
    "   patient_id\n",
    "0           3\n",
    "1           4\n",
    "2           5\n",
    "leakage output: False\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FCWkiLudW_Il"
   },
   "source": [
    "Run the next cell to check if there are patients in both train and test or in both valid and test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "AMF3Wd3yW-RS",
    "outputId": "e417c9ea-c06b-49a7-af35-d802bc1725eb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "leakage between train and test: 0\n",
      "leakage between valid and test: 0\n"
     ]
    }
   ],
   "source": [
    "print(\"leakage between train and test: {}\".format(check_for_leakage(train_df, test_df, 'PatientId')))\n",
    "print(\"leakage between valid and test: {}\".format(check_for_leakage(valid_df, test_df, 'PatientId')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zRUvYHpYXhlQ"
   },
   "source": [
    "If we get `False` for both, then we're ready to start preparing the datasets for training. Remember to always check for data leakage!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JBWZ5l4ln5yH"
   },
   "source": [
    "<a name='2-2'></a>\n",
    "### 2.2 Preparing Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SPjuZHPpn5yH"
   },
   "source": [
    "With our dataset splits ready, we can now proceed with setting up our model to consume them. \n",
    "- For this we will use the off-the-shelf [ImageDataGenerator](https://keras.io/preprocessing/image/) class from the Keras framework, which allows us to build a \"generator\" for images specified in a dataframe. \n",
    "- This class also provides support for basic data augmentation such as random horizontal flipping of images.\n",
    "- We also use the generator to transform the values in each batch so that their mean is $0$ and their standard deviation is 1. \n",
    "    - This will facilitate model training by standardizing the input distribution. \n",
    "- The generator also converts our single channel X-ray images (gray-scale) to a three-channel format by repeating the values in the image across all channels.\n",
    "    - We will want this because the pre-trained model that we'll use requires three-channel inputs.\n",
    "\n",
    "Since it is mainly a matter of reading and understanding Keras documentation, we have implemented the generator for you. There are a few things to note: \n",
    "1. We normalize the mean and standard deviation of the data\n",
    "3. We shuffle the input after each epoch.\n",
    "4. We set the image size to be 320px by 320px"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nAgVGOAju8pX"
   },
   "outputs": [],
   "source": [
    "def get_train_generator(df, image_dir, x_col, y_cols, shuffle=True, batch_size=8, seed=1, target_w = 320, target_h = 320):\n",
    "    \"\"\"\n",
    "    Return generator for training set, normalizing using batch\n",
    "    statistics.\n",
    "\n",
    "    Args:\n",
    "      train_df (dataframe): dataframe specifying training data.\n",
    "      image_dir (str): directory where image files are held.\n",
    "      x_col (str): name of column in df that holds filenames.\n",
    "      y_cols (list): list of strings that hold y labels for images.\n",
    "      sample_size (int): size of sample to use for normalization statistics.\n",
    "      batch_size (int): images per batch to be fed into model during training.\n",
    "      seed (int): random seed.\n",
    "      target_w (int): final width of input images.\n",
    "      target_h (int): final height of input images.\n",
    "    \n",
    "    Returns:\n",
    "        train_generator (DataFrameIterator): iterator over training set\n",
    "    \"\"\"        \n",
    "    print(\"getting train generator...\") \n",
    "    # normalize images\n",
    "    image_generator = ImageDataGenerator(\n",
    "        samplewise_center=True,\n",
    "        samplewise_std_normalization= True)\n",
    "    \n",
    "    # flow from directory with specified batch size\n",
    "    # and target image size\n",
    "    generator = image_generator.flow_from_dataframe(\n",
    "            dataframe=df,\n",
    "            directory=image_dir,\n",
    "            x_col=x_col,\n",
    "            y_col=y_cols,\n",
    "            class_mode=\"raw\",\n",
    "            batch_size=batch_size,\n",
    "            shuffle=shuffle,\n",
    "            seed=seed,\n",
    "            target_size=(target_w,target_h))\n",
    "    \n",
    "    return generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vpRXR-3_u7cl"
   },
   "source": [
    "#### Build a separate generator for valid and test sets\n",
    "\n",
    "Now we need to build a new generator for validation and testing data. \n",
    "\n",
    "**Why can't we use the same generator as for the training data?**\n",
    "\n",
    "Look back at the generator we wrote for the training data. \n",
    "- It normalizes each image **per batch**, meaning that it uses batch statistics. \n",
    "- We should not do this with the test and validation data, since in a real life scenario we don't process incoming images a batch at a time (we process one image at a time). \n",
    "- Knowing the average per batch of test data would effectively give our model an advantage.  \n",
    "    - The model should not have any information about the test data.\n",
    "\n",
    "What we need to do is normalize incoming test data using the statistics **computed from the training set**. \n",
    "* We implement this in the function below. \n",
    "* There is one technical note. Ideally, we would want to compute our sample mean and standard deviation using the entire training set. \n",
    "* However, since this is extremely large, that would be very time consuming. \n",
    "* In the interest of time, we'll take a random sample of the dataset and calcualte the sample mean and sample standard deviation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UtWEAfAnrhMq"
   },
   "outputs": [],
   "source": [
    "def get_test_and_valid_generator(valid_df, test_df, train_df, image_dir, x_col, y_cols, sample_size=100, batch_size=8, seed=1, target_w = 320, target_h = 320):\n",
    "    \"\"\"\n",
    "    Return generator for validation set and test test set using \n",
    "    normalization statistics from training set.\n",
    "\n",
    "    Args:\n",
    "      valid_df (dataframe): dataframe specifying validation data.\n",
    "      test_df (dataframe): dataframe specifying test data.\n",
    "      train_df (dataframe): dataframe specifying training data.\n",
    "      image_dir (str): directory where image files are held.\n",
    "      x_col (str): name of column in df that holds filenames.\n",
    "      y_cols (list): list of strings that hold y labels for images.\n",
    "      sample_size (int): size of sample to use for normalization statistics.\n",
    "      batch_size (int): images per batch to be fed into model during training.\n",
    "      seed (int): random seed.\n",
    "      target_w (int): final width of input images.\n",
    "      target_h (int): final height of input images.\n",
    "    \n",
    "    Returns:\n",
    "        test_generator (DataFrameIterator) and valid_generator: iterators over test set and validation set respectively\n",
    "    \"\"\"\n",
    "    print(\"getting train and valid generators...\")\n",
    "    # get generator to sample dataset\n",
    "    raw_train_generator = ImageDataGenerator().flow_from_dataframe(\n",
    "        dataframe=train_df, \n",
    "        directory=IMAGE_DIR, \n",
    "        x_col=\"Image\", \n",
    "        y_col=labels, \n",
    "        class_mode=\"raw\", \n",
    "        batch_size=sample_size, \n",
    "        shuffle=True, \n",
    "        target_size=(target_w, target_h))\n",
    "    \n",
    "    # get data sample\n",
    "    batch = raw_train_generator.next()\n",
    "    data_sample = batch[0]\n",
    "\n",
    "    # use sample to fit mean and std for test set generator\n",
    "    image_generator = ImageDataGenerator(\n",
    "        featurewise_center=True,\n",
    "        featurewise_std_normalization= True)\n",
    "    \n",
    "    # fit generator to sample from training data\n",
    "    image_generator.fit(data_sample)\n",
    "\n",
    "    # get test generator\n",
    "    valid_generator = image_generator.flow_from_dataframe(\n",
    "            dataframe=valid_df,\n",
    "            directory=image_dir,\n",
    "            x_col=x_col,\n",
    "            y_col=y_cols,\n",
    "            class_mode=\"raw\",\n",
    "            batch_size=batch_size,\n",
    "            shuffle=False,\n",
    "            seed=seed,\n",
    "            target_size=(target_w,target_h))\n",
    "\n",
    "    test_generator = image_generator.flow_from_dataframe(\n",
    "            dataframe=test_df,\n",
    "            directory=image_dir,\n",
    "            x_col=x_col,\n",
    "            y_col=y_cols,\n",
    "            class_mode=\"raw\",\n",
    "            batch_size=batch_size,\n",
    "            shuffle=False,\n",
    "            seed=seed,\n",
    "            target_size=(target_w,target_h))\n",
    "    return valid_generator, test_generator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ga4RZN5On5yL"
   },
   "source": [
    "With our generator function ready, let's make one generator for our training data and one each of our test and  validation datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "id": "rNE3HWRbn5yL",
    "outputId": "4c6b1c25-a33d-42e0-f442-40971ca52a3f",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting train generator...\n",
      "Found 1000 validated image filenames.\n",
      "getting train and valid generators...\n",
      "Found 1000 validated image filenames.\n",
      "Found 200 validated image filenames.\n",
      "Found 420 validated image filenames.\n"
     ]
    }
   ],
   "source": [
    "IMAGE_DIR = \"nih/images-small/\"\n",
    "train_generator = get_train_generator(train_df, IMAGE_DIR, \"Image\", labels)\n",
    "valid_generator, test_generator= get_test_and_valid_generator(valid_df, test_df, train_df, IMAGE_DIR, \"Image\", labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pYtXacDgn5yN"
   },
   "source": [
    "Let's peek into what the generator gives our model during training and validation. We can do this by calling the `__get_item__(index)` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 303
    },
    "colab_type": "code",
    "id": "Jh77vpN-n5yO",
    "outputId": "c4e68e79-e8f2-4bb9-8909-072c9dd2f805"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x, y = train_generator.__getitem__(0)\n",
    "plt.imshow(x[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9WBMpRxcDMgp"
   },
   "source": [
    "<a name='3'></a>\n",
    "## 3 Model Development\n",
    "\n",
    "Now we'll move on to model training and development. We have a few practical challenges to deal with before actually training a neural network, though. The first is class imbalance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qHBSgvxfn5yR"
   },
   "source": [
    "<a name='3-1'></a>\n",
    "### 3.1 Addressing Class Imbalance\n",
    "One of the challenges with working with medical diagnostic datasets is the large class imbalance present in such datasets. Let's plot the frequency of each of the labels in our dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 365
    },
    "colab_type": "code",
    "id": "-OvyPe5en5yR",
    "outputId": "077747ad-7ab8-463d-8335-6b243cb29e63"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xticks(rotation=90)\n",
    "plt.bar(x=labels, height=np.mean(train_generator.labels, axis=0))\n",
    "plt.title(\"Frequency of Each Class\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see from this plot that the prevalance of positive cases varies significantly across the different pathologies. (These trends mirror the ones in the full dataset as well.) \n",
    "* The `Hernia` pathology has the greatest imbalance with the proportion of positive training cases being about 0.2%. \n",
    "* But even the `Infiltration` pathology, which has the least amount of imbalance, has only 17.5% of the training cases labelled positive.\n",
    "\n",
    "Ideally, we would train our model using an evenly balanced dataset so that the positive and negative training cases would contribute equally to the loss. \n",
    "\n",
    "If we use a normal cross-entropy loss function with a highly unbalanced dataset, as we are seeing here, then the algorithm will be incentivized to prioritize the majority class (i.e negative in our case), since it contributes more to the loss. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3nHRd9p9n5yU"
   },
   "source": [
    "#### Impact of class imbalance on loss function\n",
    "\n",
    "Let's take a closer look at this. Assume we would have used a normal cross-entropy loss for each pathology. We recall that the cross-entropy loss contribution from the $i^{th}$ training data case is:\n",
    "\n",
    "$$\\mathcal{L}_{cross-entropy}(x_i) = -(y_i \\log(f(x_i)) + (1-y_i) \\log(1-f(x_i))),$$\n",
    "\n",
    "where $x_i$ and $y_i$ are the input features and the label, and $f(x_i)$ is the output of the model, i.e. the probability that it is positive. \n",
    "\n",
    "Note that for any training case, either $y_i=0$ or else $(1-y_i)=0$, so only one of these terms contributes to the loss (the other term is multiplied by zero, and becomes zero). \n",
    "\n",
    "We can rewrite the overall average cross-entropy loss over the entire training set $\\mathcal{D}$ of size $N$ as follows: \n",
    "\n",
    "$$\\mathcal{L}_{cross-entropy}(\\mathcal{D}) = - \\frac{1}{N}\\big( \\sum_{\\text{positive examples}} \\log (f(x_i)) + \\sum_{\\text{negative examples}} \\log(1-f(x_i)) \\big).$$\n",
    "\n",
    "Using this formulation, we can see that if there is a large imbalance with very few positive training cases, for example, then the loss will be dominated by the negative class. Summing the contribution over all the training cases for each class (i.e. pathological condition), we see that the contribution of each class (i.e. positive or negative) is: \n",
    "\n",
    "$$freq_{p} = \\frac{\\text{number of positive examples}}{N} $$\n",
    "\n",
    "$$\\text{and}$$\n",
    "\n",
    "$$freq_{n} = \\frac{\\text{number of negative examples}}{N}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Ex-2'></a>\n",
    "### Exercise 2 - Computing Class Frequencies\n",
    "Complete the function below to calculate these frequences for each label in our dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>    \n",
    "<summary>\n",
    "    <font size=\"3\" color=\"darkgreen\"><b>Hints</b></font>\n",
    "</summary>\n",
    "<p>\n",
    "<ul>\n",
    "    <li> Use numpy.sum(a, axis=), and choose the axis (0 or 1) </li>\n",
    "</ul>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TpDGeY2cChYD"
   },
   "outputs": [],
   "source": [
    "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "def compute_class_freqs(labels):\n",
    "    \"\"\"\n",
    "    Compute positive and negative frequences for each class.\n",
    "\n",
    "    Args:\n",
    "        labels (np.array): matrix of labels, size (num_examples, num_classes)\n",
    "    Returns:\n",
    "        positive_frequencies (np.array): array of positive frequences for each\n",
    "                                         class, size (num_classes)\n",
    "        negative_frequencies (np.array): array of negative frequences for each\n",
    "                                         class, size (num_classes)\n",
    "    \"\"\"\n",
    "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
    "    \n",
    "    # total number of patients (rows)\n",
    "    N = len(labels)\n",
    "    \n",
    "    positive_frequencies = np.sum(np.array(labels) > 0, axis=0) / N\n",
    "    negative_frequencies = np.sum(np.array(labels) == 0, axis=0) / N\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "    return positive_frequencies, negative_frequencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 153
    },
    "colab_type": "code",
    "id": "BqidQvCaD_xi",
    "outputId": "56a5905a-e61b-47a8-f444-aa89d7481c44"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "labels:\n",
      "[[1 0 0]\n",
      " [0 1 1]\n",
      " [1 0 1]\n",
      " [1 1 1]\n",
      " [1 0 1]]\n",
      "pos freqs: [0.8 0.4 0.8]\n",
      "neg freqs: [0.2 0.6 0.2]\n"
     ]
    }
   ],
   "source": [
    "# Test\n",
    "labels_matrix = np.array(\n",
    "    [[1, 0, 0],\n",
    "     [0, 1, 1],\n",
    "     [1, 0, 1],\n",
    "     [1, 1, 1],\n",
    "     [1, 0, 1]]\n",
    ")\n",
    "print(\"labels:\")\n",
    "print(labels_matrix)\n",
    "\n",
    "test_pos_freqs, test_neg_freqs = compute_class_freqs(labels_matrix)\n",
    "\n",
    "print(f\"pos freqs: {test_pos_freqs}\")\n",
    "\n",
    "print(f\"neg freqs: {test_neg_freqs}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Expected output\n",
    "\n",
    "```Python\n",
    "labels:\n",
    "[[1 0 0]\n",
    " [0 1 1]\n",
    " [1 0 1]\n",
    " [1 1 1]\n",
    " [1 0 1]]\n",
    "pos freqs: [0.8 0.4 0.8]\n",
    "neg freqs: [0.2 0.6 0.2]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Iye-sQoOFG37"
   },
   "source": [
    "Now we'll compute frequencies for our training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LoxM5jQ0E30D"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.02 , 0.013, 0.128, 0.002, 0.175, 0.045, 0.054, 0.106, 0.038,\n",
       "       0.021, 0.01 , 0.014, 0.016, 0.033])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freq_pos, freq_neg = compute_class_freqs(train_generator.labels)\n",
    "freq_pos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gsJIDPTZn5yW"
   },
   "source": [
    "Let's visualize these two contribution ratios next to each other for each of the pathologies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 1, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_generator.labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.02  0.013 0.128 0.002 0.175 0.045 0.054 0.106 0.038 0.021 0.01  0.014\n",
      " 0.016 0.033]\n",
      "['Cardiomegaly', 'Emphysema', 'Effusion', 'Hernia', 'Infiltration', 'Mass', 'Nodule', 'Atelectasis', 'Pneumothorax', 'Pleural_Thickening', 'Pneumonia', 'Fibrosis', 'Edema', 'Consolidation']\n"
     ]
    }
   ],
   "source": [
    "freq_pos, freq_neg = compute_class_freqs(train_generator.labels)\n",
    "print(freq_pos)\n",
    "print(labels)\n",
    "data = pd.DataFrame({\"Class\": labels, \"Label\": \"Positive\", \"Value\": freq_pos})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 363
    },
    "colab_type": "code",
    "id": "IqnNCu4In5yW",
    "outputId": "245f1a6b-b292-4c6d-a583-c6924bc61f31",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.DataFrame({\"Class\": labels, \"Label\": \"Positive\", \"Value\": freq_pos})\n",
    "data = data.append([{\"Class\": labels[l], \"Label\": \"Negative\", \"Value\": v} for l,v in enumerate(freq_neg)], ignore_index=True)\n",
    "plt.xticks(rotation=90)\n",
    "f = sns.barplot(x=\"Class\", y=\"Value\", hue=\"Label\" ,data=data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2uvttCM8n5yY"
   },
   "source": [
    "As we see in the above plot, the contributions of positive cases is significantly lower than that of the negative ones. However, we want the contributions to be equal. One way of doing this is by multiplying each example from each class by a class-specific weight factor, $w_{pos}$ and $w_{neg}$, so that the overall contribution of each class is the same. \n",
    "\n",
    "To have this, we want \n",
    "\n",
    "$$w_{pos} \\times freq_{p} = w_{neg} \\times freq_{n},$$\n",
    "\n",
    "which we can do simply by taking \n",
    "\n",
    "$$w_{pos} = freq_{neg}$$\n",
    "$$w_{neg} = freq_{pos}$$\n",
    "\n",
    "This way, we will be balancing the contribution of positive and negative labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zs3_Rgwwn5yZ"
   },
   "outputs": [],
   "source": [
    "pos_weights = freq_neg\n",
    "neg_weights = freq_pos\n",
    "pos_contribution = freq_pos * pos_weights \n",
    "neg_contribution = freq_neg * neg_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ygNZmdyun5ya"
   },
   "source": [
    "Let's verify this by graphing the two contributions next to each other again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 380
    },
    "colab_type": "code",
    "id": "LPfSFrxjn5yb",
    "outputId": "a4b6354f-ab39-4623-d44b-90cfd9b28506",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.DataFrame({\"Class\": labels, \"Label\": \"Positive\", \"Value\": pos_contribution})\n",
    "data = data.append([{\"Class\": labels[l], \"Label\": \"Negative\", \"Value\": v} \n",
    "                        for l,v in enumerate(neg_contribution)], ignore_index=True)\n",
    "plt.xticks(rotation=90)\n",
    "sns.barplot(x=\"Class\", y=\"Value\", hue=\"Label\" ,data=data);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "u9xgoEkpn5yc"
   },
   "source": [
    "As the above figure shows, by applying these weightings the positive and negative labels within each class would have the same aggregate contribution to the loss function. Now let's implement such a loss function. \n",
    "\n",
    "After computing the weights, our final weighted loss for each training case will be \n",
    "\n",
    "$$\\mathcal{L}_{cross-entropy}^{w}(x) = - (w_{p} y \\log(f(x)) + w_{n}(1-y) \\log( 1 - f(x) ) ).$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Ex-3'></a>\n",
    "### Exercise 3 - Weighted Loss\n",
    "Fill out the `weighted_loss` function below to return a loss function that calculates the weighted loss for each batch. Recall that for the multi-class loss, we add up the average loss for each individual class. Note that we also want to add a small value, $\\epsilon$, to the predicted values before taking their logs. This is simply to avoid a numerical error that would otherwise occur if the predicted value happens to be zero.\n",
    "\n",
    "##### Note\n",
    "Please use Keras functions to calculate the mean and the log.\n",
    "\n",
    "- [Keras.mean](https://www.tensorflow.org/api_docs/python/tf/keras/backend/mean)\n",
    "- [Keras.log](https://www.tensorflow.org/api_docs/python/tf/keras/backend/log)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pPIBVAasn5yd"
   },
   "outputs": [],
   "source": [
    "# UNQ_C3 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "def get_weighted_loss(pos_weights, neg_weights, epsilon=1e-7):\n",
    "    \"\"\"\n",
    "    Return weighted loss function given negative weights and positive weights.\n",
    "\n",
    "    Args:\n",
    "      pos_weights (np.array): array of positive weights for each class, size (num_classes)\n",
    "      neg_weights (np.array): array of negative weights for each class, size (num_classes)\n",
    "    \n",
    "    Returns:\n",
    "      weighted_loss (function): weighted loss function\n",
    "    \"\"\"\n",
    "    def weighted_loss(y_true, y_pred):\n",
    "        \"\"\"\n",
    "        Return weighted loss value. \n",
    "\n",
    "        Args:\n",
    "            y_true (Tensor): Tensor of true labels, size is (num_examples, num_classes)\n",
    "            y_pred (Tensor): Tensor of predicted labels, size is (num_examples, num_classes)\n",
    "        Returns:\n",
    "            loss (Tensor): overall scalar loss summed across all classes\n",
    "        \"\"\"\n",
    "        # initialize loss to zero\n",
    "        loss = 0.0\n",
    "        \n",
    "        ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
    "        y_pred /= K.sum(y_pred, axis=-1, keepdims=True)\n",
    "        # clip to prevent NaN's and Inf's\n",
    "        #y_pred = K.clip(y_pred, epsilon, 1 - epsilon())\n",
    "        # calc\n",
    "        loss = y_true * K.log(y_pred) * pos_weights\n",
    "        loss = -K.sum(loss, -1)\n",
    "        for i in range(len(pos_weights)):\n",
    "            # for each class, add average weighted loss for that class \n",
    "            loss += K.mean(pos_weights[i] * K.log(y_true[i])) #complete this line\n",
    "            loss +=i\n",
    "        return loss\n",
    "    \n",
    "        ### END CODE HERE ###\n",
    "    return weighted_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's test our function with some simple cases. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 595
    },
    "colab_type": "code",
    "id": "CFjYda3Wulbm",
    "outputId": "87128f53-7a99-40e2-d09a-6539215879d0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test example:\n",
      "\n",
      "y_true:\n",
      "\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 0.]\n",
      " [0. 1. 0.]\n",
      " [1. 0. 1.]]\n",
      "\n",
      "w_p:\n",
      "\n",
      "[0.25 0.25 0.5 ]\n",
      "\n",
      "w_n:\n",
      "\n",
      "[0.75 0.75 0.5 ]\n",
      "\n",
      "y_pred_1:\n",
      "\n",
      "[[0.7 0.7 0.7]\n",
      " [0.7 0.7 0.7]\n",
      " [0.7 0.7 0.7]\n",
      " [0.7 0.7 0.7]]\n",
      "\n",
      "y_pred_2:\n",
      "\n",
      "[[0.3 0.3 0.3]\n",
      " [0.3 0.3 0.3]\n",
      " [0.3 0.3 0.3]\n",
      " [0.3 0.3 0.3]]\n",
      "\n",
      "If we weighted them correctly, we expect the two losses to be the same.\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported format string passed to numpy.ndarray.__format__",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-52-a9b4d55efaac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     34\u001b[0m     \u001b[0mL1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mL\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred_1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m     \u001b[0mL2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mL\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred_2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 36\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"\\nL(y_pred_1)= {L1:.4f}, L(y_pred_2)= {L2:.4f}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     37\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Difference is L1 - L2 = {L1 - L2:.4f}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported format string passed to numpy.ndarray.__format__"
     ]
    }
   ],
   "source": [
    "# Test\n",
    "sess = K.get_session()\n",
    "with sess.as_default() as sess:\n",
    "    print(\"Test example:\\n\")\n",
    "    y_true = K.constant(np.array(\n",
    "        [[1, 1, 1],\n",
    "         [1, 1, 0],\n",
    "         [0, 1, 0],\n",
    "         [1, 0, 1]]\n",
    "    ))\n",
    "    print(\"y_true:\\n\")\n",
    "    print(y_true.eval())\n",
    "\n",
    "    w_p = np.array([0.25, 0.25, 0.5])\n",
    "    w_n = np.array([0.75, 0.75, 0.5])\n",
    "    print(\"\\nw_p:\\n\")\n",
    "    print(w_p)\n",
    "\n",
    "    print(\"\\nw_n:\\n\")\n",
    "    print(w_n)\n",
    "\n",
    "    y_pred_1 = K.constant(0.7*np.ones(y_true.shape))\n",
    "    print(\"\\ny_pred_1:\\n\")\n",
    "    print(y_pred_1.eval())\n",
    "\n",
    "    y_pred_2 = K.constant(0.3*np.ones(y_true.shape))\n",
    "    print(\"\\ny_pred_2:\\n\")\n",
    "    print(y_pred_2.eval())\n",
    "\n",
    "    # test with a large epsilon in order to catch errors\n",
    "    L = get_weighted_loss(w_p, w_n, epsilon=1)\n",
    "\n",
    "    print(\"\\nIf we weighted them correctly, we expect the two losses to be the same.\")\n",
    "    L1 = L(y_true, y_pred_1).eval()\n",
    "    L2 = L(y_true, y_pred_2).eval()\n",
    "    print(f\"\\nL(y_pred_1)= {L1:.4f}, L(y_pred_2)= {L2:.4f}\")\n",
    "    print(f\"Difference is L1 - L2 = {L1 - L2:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Additional check\n",
    "If you implemented the function correctly, then if the epsilon for the `get_weighted_loss` is set to `1`, the weighted losses will be as follows:\n",
    "```Python\n",
    "L(y_pred_1)= -0.4956, L(y_pred_2)= -0.4956\n",
    "```\n",
    "If you are missing something in your implementation, you will see a different set of losses for L1 and L2 (even though L1 and L2 will be the same)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yDZQMmlgn5yh"
   },
   "source": [
    "<a name='3-3'></a>\n",
    "### 3.3 DenseNet121\n",
    "\n",
    "Next, we will use a pre-trained [DenseNet121](https://www.kaggle.com/pytorch/densenet121) model which we can load directly from Keras and then add two layers on top of it:\n",
    "1. A `GlobalAveragePooling2D` layer to get the average of the last convolution layers from DenseNet121.\n",
    "2. A `Dense` layer with `sigmoid` activation to get the prediction logits for each of our classes.\n",
    "\n",
    "We can set our custom loss function for the model by specifying the `loss` parameter in the `compile()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 71
    },
    "colab_type": "code",
    "id": "gZlxoCTgn5yi",
    "outputId": "7e12120b-8aab-403c-b5ca-2ff77ef978b1",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# create the base pre-trained model\n",
    "base_model = DenseNet121(weights='./nih/densenet.hdf5', include_top=False)\n",
    "\n",
    "x = base_model.output\n",
    "\n",
    "# add a global spatial average pooling layer\n",
    "x = GlobalAveragePooling2D()(x)\n",
    "\n",
    "# and a logistic layer\n",
    "predictions = Dense(len(labels), activation=\"sigmoid\")(x)\n",
    "\n",
    "model = Model(inputs=base_model.input, outputs=predictions)\n",
    "model.compile(optimizer='adam', loss=get_weighted_loss(pos_weights, neg_weights))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BcwhQdOAn5ym"
   },
   "source": [
    "<a name='4'></a>\n",
    "## 4 Training [optional]\n",
    "\n",
    "With our model ready for training, we will use the `model.fit()` function in Keras to train our model. \n",
    "- We are training on a small subset of the dataset (~1%).  \n",
    "- So what we care about at this point is to make sure that the loss on the training set is decreasing.\n",
    "\n",
    "Since training can take a considerable time, for pedagogical purposes we have chosen not to train the model here but rather to load a set of pre-trained weights in the next section. However, you can use the code shown below to practice training the model locally on your machine or in Colab.\n",
    "\n",
    "**NOTE:** Do not run the code below on the Coursera platform as it will exceed the platform's memory limitations.\n",
    "\n",
    "Python Code for training the model:\n",
    "\n",
    "```python\n",
    "history = model.fit_generator(train_generator, \n",
    "                              validation_data=valid_generator,\n",
    "                              steps_per_epoch=100, \n",
    "                              validation_steps=25, \n",
    "                              epochs = 3)\n",
    "\n",
    "plt.plot(history.history['loss'])\n",
    "plt.ylabel(\"loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.title(\"Training Loss Curve\")\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xB5nsGKrn5yp"
   },
   "source": [
    "<a name='4-1'></a>\n",
    "### 4.1 Training on the Larger Dataset\n",
    "\n",
    "Given that the original dataset is 40GB+ in size and the training process on the full dataset takes a few hours, we have trained the model on a GPU-equipped machine for you and provided the weights file from our model (with a batch size of 32 instead) to be used for the rest of this assignment. \n",
    "\n",
    "The model architecture for our pre-trained model is exactly the same, but we used a few useful Keras \"callbacks\" for this training. Do spend time to read about these callbacks at your leisure as they will be very useful for managing long-running training sessions:\n",
    "\n",
    "1. You can use `ModelCheckpoint` callback to monitor your model's `val_loss` metric and keep a snapshot of your model at the point. \n",
    "2. You can use the `TensorBoard` to use the Tensorflow Tensorboard utility to monitor your runs in real-time. \n",
    "3. You can use the `ReduceLROnPlateau` to slowly decay the learning rate for your model as it stops getting better on a metric such as `val_loss` to fine-tune the model in the final steps of training.\n",
    "4. You can use the `EarlyStopping` callback to stop the training job when your model stops getting better in it's validation loss. You can set a `patience` value which is the number of epochs the model does not improve after which the training is terminated. This callback can also conveniently restore the weights for the best metric at the end of training to your model.\n",
    "\n",
    "You can read about these callbacks and other useful Keras callbacks [here](https://keras.io/callbacks/).\n",
    "\n",
    "Let's load our pre-trained weights into the model now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "887bSajLn5yq"
   },
   "outputs": [],
   "source": [
    "model.load_weights(\"./nih/pretrained_model.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mA90g8n6suRV"
   },
   "source": [
    "<a name='5'></a>\n",
    "## 5 Prediction and Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Kz1BEwOyxFbj"
   },
   "source": [
    "Now that we have a model, let's evaluate it using our test set. We can conveniently use the `predict_generator` function to generate the predictions for the images in our test set.\n",
    "\n",
    "**Note:** The following cell can take about 4 minutes to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QzNrhtf1w2bI",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-4bf3896b317d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpredicted_vals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_generator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_generator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_generator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/keras/legacy/interfaces.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     89\u001b[0m                 warnings.warn('Update your `' + object_name + '` call to the ' +\n\u001b[1;32m     90\u001b[0m                               'Keras 2 API: ' + signature, stacklevel=2)\n\u001b[0;32m---> 91\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     92\u001b[0m         \u001b[0mwrapper\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_original_function\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     93\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mpredict_generator\u001b[0;34m(self, generator, steps, callbacks, max_queue_size, workers, use_multiprocessing, verbose)\u001b[0m\n\u001b[1;32m   1844\u001b[0m             \u001b[0mworkers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mworkers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1845\u001b[0m             \u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_multiprocessing\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1846\u001b[0;31m             verbose=verbose)\n\u001b[0m\u001b[1;32m   1847\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1848\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/keras/engine/training_generator.py\u001b[0m in \u001b[0;36mpredict_generator\u001b[0;34m(model, generator, steps, callbacks, max_queue_size, workers, use_multiprocessing, verbose)\u001b[0m\n\u001b[1;32m    525\u001b[0m             \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_batch_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'predict'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'begin'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps_done\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_logs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    526\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 527\u001b[0;31m             \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_on_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    528\u001b[0m             \u001b[0mouts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mto_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mouts\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    529\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mpredict_on_batch\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m   1578\u001b[0m             \u001b[0mins\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1579\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_predict_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1580\u001b[0;31m         \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mins\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1581\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0munpack_singleton\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1582\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/tensorflow_core/python/keras/backend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m   3474\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3475\u001b[0m     fetched = self._callable_fn(*array_vals,\n\u001b[0;32m-> 3476\u001b[0;31m                                 run_metadata=self.run_metadata)\n\u001b[0m\u001b[1;32m   3477\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_fetch_callbacks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfetched\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fetches\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3478\u001b[0m     output_structure = nest.pack_sequence_as(\n",
      "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/tensorflow_core/python/client/session.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1470\u001b[0m         ret = tf_session.TF_SessionRunCallable(self._session._session,\n\u001b[1;32m   1471\u001b[0m                                                \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_handle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1472\u001b[0;31m                                                run_metadata_ptr)\n\u001b[0m\u001b[1;32m   1473\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1474\u001b[0m           \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "predicted_vals = model.predict_generator(test_generator, steps = len(test_generator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wtjCtaGen5yt"
   },
   "source": [
    "<a name='5-1'></a>\n",
    "### 5.1 ROC Curve and AUROC\n",
    "We'll cover topic of model evaluation in much more detail in later weeks, but for now we'll walk through computing a metric called the AUC (Area Under the Curve) from the ROC ([Receiver Operating Characteristic](https://en.wikipedia.org/wiki/Receiver_operating_characteristic)) curve. This is also referred to as the AUROC value, but you will see all three terms in reference to the technique, and often used almost interchangeably. \n",
    "\n",
    "For now, what you need to know in order to interpret the plot is that a curve that is more to the left and the top has more \"area\" under it, and indicates that the model is performing better.\n",
    "\n",
    "We will use the `util.get_roc_curve()` function which has been provided for you in `util.py`. Look through this function and note the use of the `sklearn` library functions to generate the ROC curves and AUROC values for our model. \n",
    "\n",
    "- [roc_curve](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html)\n",
    "- [roc_auc_score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 621
    },
    "colab_type": "code",
    "id": "6SLI8FHun5yw",
    "outputId": "4f5cc99c-4e1a-421b-fe2d-637df32d6416",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "auc_rocs = util.get_roc_curve(labels, predicted_vals, test_generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zWZkl01ruZ7P"
   },
   "source": [
    "You can compare the performance to the AUCs reported in the original ChexNeXt paper in the table below: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GZUoShw2n5yy"
   },
   "source": [
    "For reference, here's the AUC figure from the ChexNeXt paper which includes AUC values for their model as well as radiologists on this dataset:\n",
    "\n",
    "<img src=\"https://journals.plos.org/plosmedicine/article/figure/image?size=large&id=10.1371/journal.pmed.1002686.t001\" width=\"80%\">\n",
    "\n",
    "This method does take advantage of a few other tricks such as self-training and ensembling as well, which can give a significant boost to the performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Jzy7fLgFn5yy"
   },
   "source": [
    "For details about the best performing methods and their performance on this dataset, we encourage you to read the following papers:\n",
    "- [CheXNet](https://arxiv.org/abs/1711.05225)\n",
    "- [CheXpert](https://arxiv.org/pdf/1901.07031.pdf)\n",
    "- [ChexNeXt](https://journals.plos.org/plosmedicine/article?id=10.1371/journal.pmed.1002686)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G5aZAlVbn5yz"
   },
   "source": [
    "<a name='5-2'></a>\n",
    "### 5.2 Visualizing Learning with GradCAM \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gu9ExySryY6u"
   },
   "source": [
    "One of the challenges of using deep learning in medicine is that the complex architecture used for neural networks makes them much harder to interpret compared to traditional machine learning models (e.g. linear models). \n",
    "\n",
    "One of the most common approaches aimed at increasing the interpretability of models for computer vision tasks is to use Class Activation Maps (CAM). \n",
    "- Class activation maps are useful for understanding where the model is \"looking\" when classifying an image. \n",
    "\n",
    "In this section we will use a [GradCAM's](https://arxiv.org/abs/1610.02391) technique to produce a heatmap highlighting the important regions in the image for predicting the pathological condition. \n",
    "- This is done by extracting the gradients of each predicted class, flowing into our model's final convolutional layer. Look at the `util.compute_gradcam` which has been provided for you in `util.py` to see how this is done with the Keras framework. \n",
    "\n",
    "It is worth mentioning that GradCAM does not provide a full explanation of the reasoning for each classification probability. \n",
    "- However, it is still a useful tool for \"debugging\" our model and augmenting our prediction so that an expert could validate that a prediction is indeed due to the model focusing on the right regions of the image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we will load the small training set and setup to look at the 4 classes with the highest performing AUC measures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6kahoZbJn5yz",
    "outputId": "ade0a4e2-4591-4ba5-ec19-1a3487e3f972",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"nih/train-small.csv\")\n",
    "IMAGE_DIR = \"nih/images-small/\"\n",
    "\n",
    "# only show the lables with top 4 AUC\n",
    "labels_to_show = np.take(labels, np.argsort(auc_rocs)[::-1])[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at a few specific images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "util.compute_gradcam(model, '00008270_015.png', IMAGE_DIR, df, labels, labels_to_show)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JC2zy1Kpn5y1",
    "outputId": "9e38a769-e19d-4143-da41-db7a3173a533"
   },
   "outputs": [],
   "source": [
    "util.compute_gradcam(model, '00011355_002.png', IMAGE_DIR, df, labels, labels_to_show)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zCHVaLMQn5y2",
    "outputId": "57246709-2662-4590-9198-a412d2f1eea2",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "util.compute_gradcam(model, '00029855_001.png', IMAGE_DIR, df, labels, labels_to_show)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gGwL8FcFn5y4",
    "outputId": "681fb2de-194c-465e-c989-133f334b8299"
   },
   "outputs": [],
   "source": [
    "util.compute_gradcam(model, '00005410_000.png', IMAGE_DIR, df, labels, labels_to_show)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations, you've completed the first assignment of course one! You've learned how to preprocess data, check for data leakage, train a pre-trained model, and evaluate using the AUC. Great work!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "G5aZAlVbn5yz"
   ],
   "include_colab_link": true,
   "name": "C1M2_Assignment.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "coursera": {
   "schema_names": [
    "AI4MC1-1"
   ]
  },
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}