Breast Cancer Prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AWqcoPhU3RJN"
   },
   "source": [
    "# Breast Cancer Prediction\n",
    "\n",
    "In this exercise, you will train a neural network on the [Breast Cancer Dataset](https://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(original)) to predict if the tumor is malignant or benign.\n",
    "\n",
    "If you get stuck, we recommend that you review the ungraded labs for this week."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "st5AIBFZ5mEQ"
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JkMXve8XuN5X"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense, Input\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mticker\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import itertools\n",
    "from tqdm import tqdm\n",
    "import tensorflow_datasets as tfds\n",
    "\n",
    "tf.get_logger().setLevel('ERROR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yUc3HpEQ5s6U"
   },
   "source": [
    "## Load and Preprocess the Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7-TQFUXu5wS_"
   },
   "source": [
    "We first download the dataset and create a data frame using pandas. We explicitly specify the column names because the CSV file does not have column headers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HVh-W73J5TjS"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data\n",
      "24576/19889 [=====================================] - 0s 3us/step\n"
     ]
    }
   ],
   "source": [
    "DATASET_URL = \"https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data\"\n",
    "data_file = tf.keras.utils.get_file(\"breast_cancer.csv\", DATASET_URL)\n",
    "col_names = [\"id\", \"clump_thickness\", \"un_cell_size\", \"un_cell_shape\", \"marginal_adheshion\", \"single_eph_cell_size\", \"bare_nuclei\", \"bland_chromatin\", \"normal_nucleoli\", \"mitoses\", \"class\"]\n",
    "df = pd.read_csv(data_file, names=col_names, header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XEv8vS_P6HaV"
   },
   "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>id</th>\n",
       "      <th>clump_thickness</th>\n",
       "      <th>un_cell_size</th>\n",
       "      <th>un_cell_shape</th>\n",
       "      <th>marginal_adheshion</th>\n",
       "      <th>single_eph_cell_size</th>\n",
       "      <th>bare_nuclei</th>\n",
       "      <th>bland_chromatin</th>\n",
       "      <th>normal_nucleoli</th>\n",
       "      <th>mitoses</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000025</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1002945</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>7</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1015425</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1016277</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1017023</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        id  clump_thickness  un_cell_size  un_cell_shape  marginal_adheshion  \\\n",
       "0  1000025                5             1              1                   1   \n",
       "1  1002945                5             4              4                   5   \n",
       "2  1015425                3             1              1                   1   \n",
       "3  1016277                6             8              8                   1   \n",
       "4  1017023                4             1              1                   3   \n",
       "\n",
       "   single_eph_cell_size bare_nuclei  bland_chromatin  normal_nucleoli  \\\n",
       "0                     2           1                3                1   \n",
       "1                     7          10                3                2   \n",
       "2                     2           2                3                1   \n",
       "3                     3           4                3                7   \n",
       "4                     2           1                3                1   \n",
       "\n",
       "   mitoses  class  \n",
       "0        1      2  \n",
       "1        1      2  \n",
       "2        1      2  \n",
       "3        1      2  \n",
       "4        1      2  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NvvbnFL36L85"
   },
   "source": [
    "We have to do some preprocessing on the data. We first pop the id column since it is of no use for our problem at hand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nDeXwHdA5uUN"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      1000025\n",
       "1      1002945\n",
       "2      1015425\n",
       "3      1016277\n",
       "4      1017023\n",
       "        ...   \n",
       "694     776715\n",
       "695     841769\n",
       "696     888820\n",
       "697     897471\n",
       "698     897471\n",
       "Name: id, Length: 699, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.pop(\"id\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ubw5LueA6ZEY"
   },
   "source": [
    "Upon inspection of data, you can see that some values of the **bare_nuclei** column are unknown. We drop the rows with these unknown values. We also convert the **bare_nuclei** column to numeric. This is required for training the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MCcOrl1ITVhr"
   },
   "outputs": [],
   "source": [
    "df = df[df[\"bare_nuclei\"] != '?' ]\n",
    "df.bare_nuclei = pd.to_numeric(df.bare_nuclei)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UQMhcTQG7LzY"
   },
   "source": [
    "We check the class distribution of the data. You can see that there are two classes, 2.0 and 4.0\n",
    "According to the dataset:\n",
    "* **2.0 = benign**\n",
    "* **4.0 = malignant**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "SaAdQrBv8daS"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7ff0f0b9a350>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df['class'].hist(bins=20) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ENjMKvxQ6sWy"
   },
   "source": [
    "We are going to model this problem as a binary classification problem which detects whether the tumor is malignant or not. Hence, we change the dataset so that:\n",
    "* **benign(2.0) = 0**\n",
    "* **malignant(4.0) = 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1MVzeUwf_A3E",
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "df['class'] = np.where(df['class'] == 2, 0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EGbKO1bR8S9h"
   },
   "source": [
    "We then split the dataset into training and testing sets. Since the number of samples is small, we will perform validation on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aNUy7JcuAXjC"
   },
   "outputs": [],
   "source": [
    "train, test = train_test_split(df, test_size = 0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "H_ZKokUP8kP3"
   },
   "source": [
    "We get the statistics for training. We can look at statistics to get an idea about the distribution of plots. If you need more visualization, you can create additional data plots. We will also be using the mean and standard deviation from statistics for normalizing the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k86tBT_QAm2P"
   },
   "outputs": [],
   "source": [
    "train_stats = train.describe()\n",
    "train_stats.pop('class')\n",
    "train_stats = train_stats.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l8AJ0Crc8u9t"
   },
   "source": [
    "We pop the class column from the training and test sets to create train and test outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V7EGUV-tA5LZ"
   },
   "outputs": [],
   "source": [
    "train_Y = train.pop(\"class\")\n",
    "test_Y = test.pop(\"class\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N9wVRO5E9AgA"
   },
   "source": [
    "Here we normalize the data by using the formula: **X = (X - mean(X)) / StandardDeviation(X)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NDo__q_AA3j0"
   },
   "outputs": [],
   "source": [
    "def norm(x):\n",
    "    return (x - train_stats['mean']) / train_stats['std']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pdARlWaDA_8G"
   },
   "outputs": [],
   "source": [
    "norm_train_X = norm(train)\n",
    "norm_test_X = norm(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P6LIVZbj9Usv"
   },
   "source": [
    "We now create Tensorflow datasets for training and test sets to easily be able to build and manage an input pipeline for our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1S0RtsP1Xsj8"
   },
   "outputs": [],
   "source": [
    "train_dataset = tf.data.Dataset.from_tensor_slices((norm_train_X.values, train_Y.values))\n",
    "test_dataset = tf.data.Dataset.from_tensor_slices((norm_test_X.values, test_Y.values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-Nb44PpV9hR4"
   },
   "source": [
    "We shuffle and prepare a batched dataset to be used for training in our custom training loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h9qdsNPen5-F"
   },
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "train_dataset = train_dataset.shuffle(buffer_size=len(train)).batch(batch_size)\n",
    "\n",
    "test_dataset =  test_dataset.batch(batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "a = enumerate(train_dataset)\n",
    "\n",
    "print(len(list(a)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GcbOJ6C79qT5"
   },
   "source": [
    "## Define the Model\n",
    "\n",
    "Now we will define the model. Here, we use the Keras Functional API to create a simple network of two `Dense` layers. We have modelled the problem as a binary classification problem and hence we add a single layer with sigmoid activation as the final layer of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HU3qcM9WBcMh"
   },
   "outputs": [],
   "source": [
    "def base_model():\n",
    "    inputs = tf.keras.layers.Input(shape=(len(train.columns)))\n",
    "\n",
    "    x = tf.keras.layers.Dense(128, activation='relu')(inputs)\n",
    "    x = tf.keras.layers.Dense(64, activation='relu')(x)\n",
    "    outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)\n",
    "    model = tf.keras.Model(inputs=inputs, outputs=outputs)\n",
    "    return model\n",
    "\n",
    "model = base_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NBhKIcKQ-Bwe"
   },
   "source": [
    "## Define Optimizer and Loss\n",
    "\n",
    "We use RMSprop optimizer and binary crossentropy as our loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "v5B3vh6fs84i"
   },
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.001)\n",
    "loss_object = tf.keras.losses.BinaryCrossentropy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YSNDewgovSZ8"
   },
   "source": [
    "## Evaluate Untrained Model\n",
    "We calculate the loss on the model before training begins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TUScS3GbtPXt"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss before training 0.7211\n"
     ]
    }
   ],
   "source": [
    "outputs = model(norm_test_X.values)\n",
    "loss_value = loss_object(y_true=test_Y.values, y_pred=outputs)\n",
    "print(\"Loss before training %.4f\" % loss_value.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jPPb5ewkzMBY"
   },
   "source": [
    "We also plot the confusion matrix to visualize the true outputs against the outputs predicted by the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ueenYwWZvQM_"
   },
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, title='', labels=[0,1]):\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    cax = ax.matshow(cm)\n",
    "    plt.title(title)\n",
    "    fig.colorbar(cax)\n",
    "    ax.set_xticklabels([''] + labels)\n",
    "    ax.set_yticklabels([''] + labels)\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('True')\n",
    "    fmt = 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "          plt.text(j, i, format(cm[i, j], fmt),\n",
    "                  horizontalalignment=\"center\",\n",
    "                  color=\"black\" if cm[i, j] > thresh else \"white\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FApnBUNWv-ZR"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(test_Y.values, tf.round(outputs), title='Confusion Matrix for Untrained Model')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7-HTkbQb-gYp"
   },
   "source": [
    "## Define Metrics (Please complete this section)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AYUyRka1-j87"
   },
   "source": [
    "### Define Custom F1Score Metric\n",
    "In this example, we will define a custom F1Score metric using the formula. \n",
    "\n",
    "**F1 Score = 2 * ((precision * recall) / (precision + recall))**\n",
    "\n",
    "**precision = true_positives / (true_positives + false_positives)**\n",
    "\n",
    "**recall = true_positives / (true_positives + false_negatives)**\n",
    "\n",
    "We use `confusion_matrix` defined in `tf.math` to calculate precision and recall.\n",
    "\n",
    "Here you can see that we have subclassed `tf.keras.Metric` and implemented the three required methods `update_state`, `result` and `reset_states`.\n",
    "\n",
    "### Please complete the result() method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PdUe6cqvbzXy"
   },
   "outputs": [],
   "source": [
    "class F1Score(tf.keras.metrics.Metric):\n",
    "\n",
    "    def __init__(self, name='f1_score', **kwargs):\n",
    "        '''initializes attributes of the class'''\n",
    "        \n",
    "        # call the parent class init\n",
    "        super(F1Score, self).__init__(name=name, **kwargs)\n",
    "\n",
    "        # Initialize Required variables\n",
    "        # true positives\n",
    "        self.tp = tf.Variable(0, dtype = 'int32')\n",
    "        # false positives\n",
    "        self.fp = tf.Variable(0, dtype = 'int32')\n",
    "        # true negatives\n",
    "        self.tn = tf.Variable(0, dtype = 'int32')\n",
    "        # false negatives\n",
    "        self.fn = tf.Variable(0, dtype = 'int32')\n",
    "\n",
    "    def update_state(self, y_true, y_pred, sample_weight=None):\n",
    "        '''\n",
    "        Accumulates statistics for the metric\n",
    "        \n",
    "        Args:\n",
    "            y_true: target values from the test data\n",
    "            y_pred: predicted values by the model\n",
    "        '''\n",
    "\n",
    "        # Calulcate confusion matrix.\n",
    "        conf_matrix = tf.math.confusion_matrix(y_true, y_pred, num_classes=2)\n",
    "        \n",
    "        # Update values of true positives, true negatives, false positives and false negatives from confusion matrix.\n",
    "        self.tn.assign_add(conf_matrix[0][0])\n",
    "        self.tp.assign_add(conf_matrix[1][1])\n",
    "        self.fp.assign_add(conf_matrix[0][1])\n",
    "        self.fn.assign_add(conf_matrix[1][0])\n",
    "\n",
    "    def result(self):\n",
    "        '''Computes and returns the metric value tensor.'''\n",
    "\n",
    "        # Calculate precision\n",
    "        if (self.tp + self.fp == 0):\n",
    "            precision = 1.0\n",
    "        else:\n",
    "            precision = self.tp / (self.tp + self.fp)\n",
    "      \n",
    "        # Calculate recall\n",
    "        if (self.tp + self.fn == 0):\n",
    "            recall = 1.0\n",
    "        else:\n",
    "            recall = self.tp / (self.tp + self.fn)\n",
    "\n",
    "        # Return F1 Score\n",
    "        ### START CODE HERE ###\n",
    "        f1_score = 2*((precision*recall)/(precision+recall))\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        return f1_score\n",
    "\n",
    "    def reset_states(self):\n",
    "        '''Resets all of the metric state variables.'''\n",
    "        \n",
    "        # The state of the metric will be reset at the start of each epoch.\n",
    "        self.tp.assign(0)\n",
    "        self.tn.assign(0) \n",
    "        self.fp.assign(0)\n",
    "        self.fn.assign(0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=float64, numpy=0.2222222222222222>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test Code:\n",
    "\n",
    "test_F1Score = F1Score()\n",
    "\n",
    "test_F1Score.tp = tf.Variable(2, dtype = 'int32')\n",
    "test_F1Score.fp = tf.Variable(5, dtype = 'int32')\n",
    "test_F1Score.tn = tf.Variable(7, dtype = 'int32')\n",
    "test_F1Score.fn = tf.Variable(9, dtype = 'int32')\n",
    "test_F1Score.result()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "```txt\n",
    "<tf.Tensor: shape=(), dtype=float64, numpy=0.2222222222222222>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xiTa2CePAOTa"
   },
   "source": [
    "We initialize the seprate metrics required for training and validation. In addition to our custom F1Score metric, we are also using `BinaryAccuracy` defined in `tf.keras.metrics`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7Pa_x-5-CH_V"
   },
   "outputs": [],
   "source": [
    "train_f1score_metric = F1Score()\n",
    "val_f1score_metric = F1Score()\n",
    "\n",
    "train_acc_metric = tf.keras.metrics.BinaryAccuracy()\n",
    "val_acc_metric = tf.keras.metrics.BinaryAccuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1huOxRpEAxvf"
   },
   "source": [
    "## Apply Gradients (Please complete this section)\n",
    "\n",
    "The core of training is using the model to calculate the logits on specific set of inputs and compute the loss(in this case **binary crossentropy**) by comparing the predicted outputs to the true outputs. We then update the trainable weights using the optimizer algorithm chosen. The optimizer algorithm requires our computed loss and partial derivatives of loss with respect to each of the trainable weights to make updates to the same.\n",
    "\n",
    "We use gradient tape to calculate the gradients and then update the model trainable weights using the optimizer.\n",
    "\n",
    "### Please complete the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MMPe25Dstn0v"
   },
   "outputs": [],
   "source": [
    "def apply_gradient(optimizer, loss_object, model, x, y):\n",
    "    '''\n",
    "    applies the gradients to the trainable model weights\n",
    "    \n",
    "    Args:\n",
    "        optimizer: optimizer to update model weights\n",
    "        loss_object: type of loss to measure during training\n",
    "        model: the model we are training\n",
    "        x: input data to the model\n",
    "        y: target values for each input\n",
    "    '''\n",
    "    \n",
    "    with tf.GradientTape() as tape:\n",
    "    ### START CODE HERE ###\n",
    "        logits = model(x, training=True)\n",
    "        loss_value = loss_object(y, logits)\n",
    "  \n",
    "    gradients = tape.gradient(loss_value, model.trainable_weights)\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_weights))\n",
    "    ### END CODE HERE ###\n",
    "  \n",
    "    return logits, loss_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.45239708]\n",
      " [0.54946387]\n",
      " [0.5622323 ]\n",
      " [0.4562484 ]\n",
      " [0.5393631 ]\n",
      " [0.44855726]\n",
      " [0.485722  ]\n",
      " [0.5237527 ]]\n",
      "0.7027343\n"
     ]
    }
   ],
   "source": [
    "# Test Code:\n",
    "\n",
    "test_model = tf.keras.models.load_model('./test_model')\n",
    "test_logits, test_loss = apply_gradient(optimizer, loss_object, test_model, norm_test_X.values, test_Y.values)\n",
    "\n",
    "print(test_logits.numpy()[:8])\n",
    "print(test_loss.numpy())\n",
    "\n",
    "del test_model\n",
    "del test_logits\n",
    "del test_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "The output will be close to these values:\n",
    "```txt\n",
    "[[0.5516499 ]\n",
    " [0.52124363]\n",
    " [0.5412698 ]\n",
    " [0.54203206]\n",
    " [0.50022954]\n",
    " [0.5459626 ]\n",
    " [0.47841492]\n",
    " [0.54381996]]\n",
    "0.7030578\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JYM6GZPjB40r"
   },
   "source": [
    "## Training Loop (Please complete this section)\n",
    "\n",
    "This function performs training during one epoch. We run through all batches of training data in each epoch to make updates to trainable weights using our previous function.\n",
    "You can see that we also call `update_state` on our metrics to accumulate the value of our metrics. \n",
    "\n",
    "We are displaying a progress bar to indicate completion of training in each epoch. Here we use `tqdm` for displaying the progress bar. \n",
    "\n",
    "### Please complete the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3fHoh_hgz2PC"
   },
   "outputs": [],
   "source": [
    "def train_data_for_one_epoch(train_dataset, optimizer, loss_object, model, \n",
    "                             train_acc_metric, train_f1score_metric, verbose=True):\n",
    "    '''\n",
    "    Computes the loss then updates the weights and metrics for one epoch.\n",
    "    \n",
    "    Args:\n",
    "        train_dataset: the training dataset\n",
    "        optimizer: optimizer to update model weights\n",
    "        loss_object: type of loss to measure during training\n",
    "        model: the model we are training\n",
    "        train_acc_metric: calculates how often predictions match labels\n",
    "        train_f1score_metric: custom metric we defined earlier\n",
    "    '''\n",
    "    losses = []\n",
    "\n",
    "    #Iterate through all batches of training data\n",
    "    for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):\n",
    "\n",
    "        #Calculate loss and update trainable variables using optimizer\n",
    "        ### START CODE HERE ###\n",
    "        logits, loss_value = apply_gradient(optimizer, loss_object, model, x_batch_train, y_batch_train)\n",
    "        losses.append(loss_value)\n",
    "        ### END CODE HERE ###\n",
    "\n",
    "        #Round off logits to nearest integer and cast to integer for calulating metrics\n",
    "        logits = tf.round(logits)\n",
    "        logits = tf.cast(logits, 'int64')\n",
    "\n",
    "        #Update the training metrics\n",
    "        ### START CODE HERE ###\n",
    "        train_acc_metric.update_state(y_batch_train, logits)\n",
    "        train_f1score_metric.update_state(y_batch_train, logits)\n",
    "        ### END CODE HERE ###\n",
    "\n",
    "        #Update progress\n",
    "        if verbose:\n",
    "            print(\"Training loss for step %s: %.4f\" % (int(step), float(loss_value)))\n",
    "    \n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.75781775\n",
      "0.6066719\n",
      "0.5517784\n",
      "0.4853583\n",
      "0.46363205\n",
      "0.41398528\n",
      "0.39040083\n",
      "0.42418185\n",
      "0.33326966\n",
      "0.26886111\n",
      "0.2620352\n",
      "0.25372446\n",
      "0.30974358\n",
      "0.22986293\n",
      "0.2042087\n",
      "0.27507454\n",
      "0.22866216\n",
      "0.104268864\n"
     ]
    }
   ],
   "source": [
    "# TEST CODE\n",
    "\n",
    "test_model = tf.keras.models.load_model('./test_model')\n",
    "\n",
    "test_losses = train_data_for_one_epoch(train_dataset, optimizer, loss_object, test_model, \n",
    "                             train_acc_metric, train_f1score_metric, verbose=False)\n",
    "\n",
    "for test_loss in test_losses:\n",
    "    print(test_loss.numpy())\n",
    "\n",
    "del test_model\n",
    "del test_losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output:**\n",
    "\n",
    "The losses should generally be decreasing and will start from around 0.75. For example:\n",
    "\n",
    "```\n",
    "0.7600615\n",
    "0.6092045\n",
    "0.5525634\n",
    "0.4358902\n",
    "0.4765755\n",
    "0.43327087\n",
    "0.40585428\n",
    "0.32855004\n",
    "0.35755336\n",
    "0.3651728\n",
    "0.33971977\n",
    "0.27372319\n",
    "0.25026917\n",
    "0.29229593\n",
    "0.242178\n",
    "0.20602849\n",
    "0.15887335\n",
    "0.090397514\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "d9RJq8BLCsSF"
   },
   "source": [
    "At the end of each epoch, we have to validate the model on the test dataset. The following function calculates the loss on test dataset and updates the states of the validation metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5gLJyAJE0YRc"
   },
   "outputs": [],
   "source": [
    "def perform_validation():\n",
    "    losses = []\n",
    "\n",
    "    #Iterate through all batches of validation data.\n",
    "    for x_val, y_val in test_dataset:\n",
    "\n",
    "        #Calculate validation loss for current batch.\n",
    "        val_logits = model(x_val) \n",
    "        val_loss = loss_object(y_true=y_val, y_pred=val_logits)\n",
    "        losses.append(val_loss)\n",
    "\n",
    "        #Round off and cast outputs to either  or 1\n",
    "        val_logits = tf.cast(tf.round(model(x_val)), 'int64')\n",
    "\n",
    "        #Update validation metrics\n",
    "        val_acc_metric.update_state(y_val, val_logits)\n",
    "        val_f1score_metric.update_state(y_val, val_logits)\n",
    "        \n",
    "    return losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DLymSCkUC-CL"
   },
   "source": [
    "Next we define the training loop that runs through the training samples repeatedly over a fixed number of epochs. Here we combine the functions we built earlier to establish the following flow:\n",
    "1. Perform training over all batches of training data.\n",
    "2. Get values of metrics.\n",
    "3. Perform validation to calculate loss and update validation metrics on test data.\n",
    "4. Reset the metrics at the end of epoch.\n",
    "5. Display statistics at the end of each epoch.\n",
    "\n",
    "**Note** : We also calculate the training and validation losses for the whole epoch at the end of the epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OOO1x3VyuPUV"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start of epoch 0\n",
      "Training loss for step 0: 0.7776\n",
      "Training loss for step 1: 0.6091\n",
      "Training loss for step 2: 0.5372\n",
      "Training loss for step 3: 0.4540\n",
      "Training loss for step 4: 0.4788\n",
      "Training loss for step 5: 0.4574\n",
      "Training loss for step 6: 0.4469\n",
      "Training loss for step 7: 0.3224\n",
      "Training loss for step 8: 0.3302\n",
      "Training loss for step 9: 0.3519\n",
      "Training loss for step 10: 0.2611\n",
      "Training loss for step 11: 0.2898\n",
      "Training loss for step 12: 0.1931\n",
      "Training loss for step 13: 0.1809\n",
      "Training loss for step 14: 0.2080\n",
      "Training loss for step 15: 0.2164\n",
      "Training loss for step 16: 0.2757\n",
      "Training loss for step 17: 0.1041\n",
      "\n",
      " Epcoh 0: Train loss: 0.3608  Validation Loss: 0.2107, Train Accuracy: 0.9193, Validation Accuracy 0.9500, Train F1 Score: 0.8809, Validation F1 Score: 0.9310\n",
      "Start of epoch 1\n",
      "Training loss for step 0: 0.1476\n",
      "Training loss for step 1: 0.1737\n",
      "Training loss for step 2: 0.1475\n",
      "Training loss for step 3: 0.2514\n",
      "Training loss for step 4: 0.0998\n",
      "Training loss for step 5: 0.1599\n",
      "Training loss for step 6: 0.1046\n",
      "Training loss for step 7: 0.2323\n",
      "Training loss for step 8: 0.1125\n",
      "Training loss for step 9: 0.1011\n",
      "Training loss for step 10: 0.0852\n",
      "Training loss for step 11: 0.1334\n",
      "Training loss for step 12: 0.1653\n",
      "Training loss for step 13: 0.0495\n",
      "Training loss for step 14: 0.0647\n",
      "Training loss for step 15: 0.1315\n",
      "Training loss for step 16: 0.0675\n",
      "Training loss for step 17: 0.0149\n",
      "\n",
      " Epcoh 1: Train loss: 0.1246  Validation Loss: 0.1355, Train Accuracy: 0.9722, Validation Accuracy 0.9500, Train F1 Score: 0.9568, Validation F1 Score: 0.9310\n",
      "Start of epoch 2\n",
      "Training loss for step 0: 0.0600\n",
      "Training loss for step 1: 0.1304\n",
      "Training loss for step 2: 0.0865\n",
      "Training loss for step 3: 0.0302\n",
      "Training loss for step 4: 0.0420\n",
      "Training loss for step 5: 0.0814\n",
      "Training loss for step 6: 0.1421\n",
      "Training loss for step 7: 0.1697\n",
      "Training loss for step 8: 0.0922\n",
      "Training loss for step 9: 0.0386\n",
      "Training loss for step 10: 0.0480\n",
      "Training loss for step 11: 0.1750\n",
      "Training loss for step 12: 0.0964\n",
      "Training loss for step 13: 0.0444\n",
      "Training loss for step 14: 0.0184\n",
      "Training loss for step 15: 0.0870\n",
      "Training loss for step 16: 0.0222\n",
      "Training loss for step 17: 0.0114\n",
      "\n",
      " Epcoh 2: Train loss: 0.0764  Validation Loss: 0.1206, Train Accuracy: 0.9757, Validation Accuracy 0.9500, Train F1 Score: 0.9620, Validation F1 Score: 0.9310\n",
      "Start of epoch 3\n",
      "Training loss for step 0: 0.0851\n",
      "Training loss for step 1: 0.0856\n",
      "Training loss for step 2: 0.0249\n",
      "Training loss for step 3: 0.0324\n",
      "Training loss for step 4: 0.0256\n",
      "Training loss for step 5: 0.0649\n",
      "Training loss for step 6: 0.0165\n",
      "Training loss for step 7: 0.1438\n",
      "Training loss for step 8: 0.0204\n",
      "Training loss for step 9: 0.1981\n",
      "Training loss for step 10: 0.0361\n",
      "Training loss for step 11: 0.0233\n",
      "Training loss for step 12: 0.0334\n",
      "Training loss for step 13: 0.0356\n",
      "Training loss for step 14: 0.0092\n",
      "Training loss for step 15: 0.1370\n",
      "Training loss for step 16: 0.1329\n",
      "Training loss for step 17: 0.0022\n",
      "\n",
      " Epcoh 3: Train loss: 0.0615  Validation Loss: 0.1173, Train Accuracy: 0.9774, Validation Accuracy 0.9500, Train F1 Score: 0.9648, Validation F1 Score: 0.9310\n",
      "Start of epoch 4\n",
      "Training loss for step 0: 0.2352\n",
      "Training loss for step 1: 0.0194\n",
      "Training loss for step 2: 0.0304\n",
      "Training loss for step 3: 0.2045\n",
      "Training loss for step 4: 0.0267\n",
      "Training loss for step 5: 0.0246\n",
      "Training loss for step 6: 0.1175\n",
      "Training loss for step 7: 0.0147\n",
      "Training loss for step 8: 0.0169\n",
      "Training loss for step 9: 0.0101\n",
      "Training loss for step 10: 0.0489\n",
      "Training loss for step 11: 0.0478\n",
      "Training loss for step 12: 0.0203\n",
      "Training loss for step 13: 0.0097\n",
      "Training loss for step 14: 0.0111\n",
      "Training loss for step 15: 0.0379\n",
      "Training loss for step 16: 0.0979\n",
      "Training loss for step 17: 0.0155\n",
      "\n",
      " Epcoh 4: Train loss: 0.0550  Validation Loss: 0.1176, Train Accuracy: 0.9774, Validation Accuracy 0.9500, Train F1 Score: 0.9646, Validation F1 Score: 0.9310\n"
     ]
    }
   ],
   "source": [
    "# Iterate over epochs.\n",
    "epochs = 5\n",
    "epochs_val_losses, epochs_train_losses = [], []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    print('Start of epoch %d' % (epoch,))\n",
    "    #Perform Training over all batches of train data\n",
    "    losses_train = train_data_for_one_epoch(train_dataset, optimizer, loss_object, model, train_acc_metric, train_f1score_metric)\n",
    "\n",
    "    # Get results from training metrics\n",
    "    train_acc = train_acc_metric.result()\n",
    "    train_f1score = train_f1score_metric.result()\n",
    "\n",
    "    #Perform validation on all batches of test data\n",
    "    losses_val = perform_validation()\n",
    "\n",
    "    # Get results from validation metrics\n",
    "    val_acc = val_acc_metric.result()\n",
    "    val_f1score = val_f1score_metric.result()\n",
    "\n",
    "    #Calculate training and validation losses for current epoch\n",
    "    losses_train_mean = np.mean(losses_train)\n",
    "    losses_val_mean = np.mean(losses_val)\n",
    "    epochs_val_losses.append(losses_val_mean)\n",
    "    epochs_train_losses.append(losses_train_mean)\n",
    "\n",
    "    print('\\n Epcoh %s: Train loss: %.4f  Validation Loss: %.4f, Train Accuracy: %.4f, Validation Accuracy %.4f, Train F1 Score: %.4f, Validation F1 Score: %.4f' % (epoch, float(losses_train_mean), float(losses_val_mean), float(train_acc), float(val_acc), train_f1score, val_f1score))\n",
    "\n",
    "    #Reset states of all metrics\n",
    "    train_acc_metric.reset_states()\n",
    "    val_acc_metric.reset_states()\n",
    "    val_f1score_metric.reset_states()\n",
    "    train_f1score_metric.reset_states()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JoLxueMdzm14"
   },
   "source": [
    "## Evaluate the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6EGW3HVUzqBX"
   },
   "source": [
    "### Plots for Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "t8Wsr6wG0T4h"
   },
   "source": [
    "We plot the progress of loss as training proceeds over number of epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MsmF_2n307SP"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAY9UlEQVR4nO3df3RU9Z3/8ec7kwQIP0Qh8iOCiKBIsWANRLfVVmsrWL+1v4+6rdW6Ze3RHt3aVt3qdre2p+227tKuWspXac+6ba3daquu/enWr/arBoIgGhBFKhh+CCwoPyUkee8fnwkmk8n8gJlM5pPX45x7JvfeT+68Z8TX/eQz937G3B0RESl/FaUuQERECkOBLiISCQW6iEgkFOgiIpFQoIuIREKBLiISCQW6iEgkFOgyIJjZK2Z2XqnrECkmBbqISCQU6DJgmdkgM1tgZpuSywIzG5TcN9rMHjaz181sh5k9YWYVyX03mNlGM9ttZmvM7L2lfSUiQWWpCxApoa8AZwCzAAd+DdwM3AJcD7QAtcm2ZwBuZicD1wCz3X2TmU0CEn1btkh66qHLQPbXwNfcfau7bwP+CfhUct9BYBxwvLsfdPcnPEx81A4MAqabWZW7v+LuL5ekepEUCnQZyMYD67usr09uA/gOsBb4vZmtM7MbAdx9LXAd8I/AVjO718zGI9IPKNBlINsEHN9lfWJyG+6+292vd/fJwP8BvtA5Vu7uP3X3dyV/14Fv923ZIukp0GUgqTKzwZ0L8DPgZjOrNbPRwD8A/wFgZhea2RQzM2AXYail3cxONrNzkx+evgnsT+4TKTkFugwkjxACuHMZDDQBK4HngGeAryfbTgX+COwBngLudPfHCOPn3wK2A1uAY4G/77NXIJKB6QsuRETioB66iEgksga6mS02s61m9nwv+83Mvm9ma81spZm9o/BliohINrn00H8MzM2wfx5hvHEqMB/4wZGXJSIi+coa6O7+OLAjQ5OLgH/34GlgpJmNK1SBIiKSm0Lc+l8HvNplvSW5bXNqQzObT+jFM3To0NOnTZtWgKcXERk4li1btt3da9PtK0SgW5ptaS+dcfdFwCKA+vp6b2pqKsDTi4gMHGa2vrd9hbjKpQWY0GX9OJJ324mISN8pRKA/CFyWvNrlDOANd+8x3CIiIsWVdcjFzH4GvAcYbWYtwFeBKgB3X0i4++4CwkRG+4ArilWsiIj0Lmugu/slWfY7cHXBKhIRkcOiO0VFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEgp0EZFIKNBFRCKhQBcRiYQCXUQkEjkFupnNNbM1ZrbWzG5Ms/8oM3vIzJ41s2Yzu6LwpYqISCZZA93MEsAdwDxgOnCJmU1PaXY1sMrdZwLvAW4zs+oC1yoiIhnk0kOfA6x193Xu3grcC1yU0saB4WZmwDBgB9BW0EpFRCSjXAK9Dni1y3pLcltXtwOnAJuA54Br3b0j9UBmNt/Mmsysadu2bYdZsoiIpJNLoFuabZ6yfj6wAhgPzAJuN7MRPX7JfZG717t7fW1tbd7FiohI73IJ9BZgQpf14wg98a6uAO73YC3wF2BaYUoUEZFc5BLoS4GpZnZC8oPOi4EHU9psAN4LYGZjgJOBdYUsVEREMqvM1sDd28zsGuB3QAJY7O7NZnZVcv9C4Fbgx2b2HGGI5gZ3317EukVEJEXWQAdw90eAR1K2Lezy8ybg/YUtTURE8qE7RUVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJRE6BbmZzzWyNma01sxt7afMeM1thZs1m9v8KW6aIiGRTma2BmSWAO4D3AS3AUjN70N1XdWkzErgTmOvuG8zs2GIVLCIi6eXSQ58DrHX3de7eCtwLXJTS5lLgfnffAODuWwtbpoiIZJNLoNcBr3ZZb0lu6+ok4Ggze8zMlpnZZekOZGbzzazJzJq2bdt2eBWLiEhauQS6pdnmKeuVwOnAB4DzgVvM7KQev+S+yN3r3b2+trY272JFRKR3WcfQCT3yCV3WjwM2pWmz3d33AnvN7HFgJvBiQaoUEZGscumhLwWmmtkJZlYNXAw8mNLm18BZZlZpZjVAA7C6sKWKiEgmWXvo7t5mZtcAvwMSwGJ3bzazq5L7F7r7ajP7LbAS6ADucvfni1m4iIh0Z+6pw+F9o76+3puamkry3CIi5crMlrl7fbp9ulNURCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIqFAFxGJhAJdRCQSCnQRkUgo0EVEIpFToJvZXDNbY2ZrzezGDO1mm1m7mX2scCWKiEgusga6mSWAO4B5wHTgEjOb3ku7bwO/K3SRIiKSXS499DnAWndf5+6twL3ARWnafR74JbC1gPWJiEiOcgn0OuDVLustyW2HmFkd8GFgYaYDmdl8M2sys6Zt27blW6uIiGSQS6Bbmm2esr4AuMHd2zMdyN0XuXu9u9fX1tbmWqOIiOSgMoc2LcCELuvHAZtS2tQD95oZwGjgAjNrc/dfFaRKERHJKpdAXwpMNbMTgI3AxcClXRu4+wmdP5vZj4GHFeYiIn0ra6C7e5uZXUO4eiUBLHb3ZjO7Krk/47i5iIj0jVx66Lj7I8AjKdvSBrm7X37kZYmISL50p6iISCTKLtB374Z//mdobS11JSIi/UvZBfovfwk33ABz5sCzz5a6GhGR/qPsAv3yy+FXv4LNm2H2bPj616GtrdRViYiUXtkFOsBFF0FzM3zkI3DLLXDmmbBqVamrEhEprbIMdIDRo+Hee+G+++Avf4F3vAO+8x1oz3ivqohIvMo20Dt9/OOhtz5vHnz5y3DWWfDii6WuSkSk75V9oAOMGQP33w/33AOrV8OsWfC970FHR6krExHpO1EEOoAZfPKTobd+zjlw3XVw7rmwbl2pKxMR6RvRBHqn8ePh4Yfh7rvhmWfg7W+HhQvBU+eHFBGJTHSBDqG3/pnPwPPPhytgPvc5eP/7YcOGUlcmIlI8UQZ6p4kT4fe/hzvvhKeeglNPhcWL1VsXkThFHegQeuuf+xysXBk+LL3ySrjwQtiUOqO7iEiZiz7QO02eDH/6EyxYEB5nzICf/ES9dRGJx4AJdICKCrj2WlixAqZNC1fFfPSj8Nprpa5MROTIDahA73TSSfDEE2HWxv/6r9Bb/8UvSl2ViMiRGZCBDpBIwJe+BMuXw6RJ8IlPwMUXw/btpa5MROTwDNhA7zR9Ojz5JNx6a7jbdMYM+PWvS12ViEj+BnygA1RVwc03w9KlMHYsfOhDcNllsHNnqSsTEcmdAr2LmTNhyZIwJe9Pfxp667/9bamrEhHJjQI9RXU1fO1r8PTTMHJkmMXxs5+FXbtKXZmISGYK9F7U18OyZWFK3sWLw12mjz5a6qpERHqnQM9g8GD49rfhz3+GQYPgvPPg6qthz55SVyYi0pMCPQdnnhluRrruOvjBD8JY+xNPlLoqEZHuFOg5qqmBf/1XeOyxMF3Au98NX/gC7N9f6spERAIFep7OPjtM9HXVVSHgZ80KH6CKiJSaAv0wDBsWpuT9wx9CD/2d74Qbb4QDB0pdmYgMZAr0I3DeefDcc3DFFeHD09NPD1fGiIiUggL9CB11FNx1V5jka+dOaGiAr34VWltLXZmIDDQK9AK54ILwlXeXXBJuTGpoCGPtIiJ9RYFeQEcfDffcAw88EL4Rqb4evvENaGsrdWUiMhAo0IvgQx+C5ubwePPN8Fd/BatXl7oqEYmdAr1IRo+G++6Dn/8c1q2D006D734X2ttLXZmIxEqBXmSf+ETorc+dG75Q4+yz4aWXSl2ViMQop0A3s7lmtsbM1prZjWn2/7WZrUwuT5rZzMKXGjz56pOc9aOz+OLvv8gvmn/Bhjc24P38m57HjAnj6vfcA6tWhakDvv996OgodWUiEpPKbA3MLAHcAbwPaAGWmtmD7r6qS7O/AO92951mNg9YBDQUo+A3296kraON25fczm3ttwEwdthYGuoawnJcA7PHz2b4oOHFePrDZha+lPqcc8J0vNdeG74h6Uc/ghNOKHV1IhIDy9a7NbMzgX909/OT6zcBuPs3e2l/NPC8u9dlOm59fb03NTUdVtEAre2tPLvlWRo3NoalpZGXdoSxDMN427Fv6xbyb6t9G4mKxGE/XyG5hyl5/+7vQi/9u9+Fv/3bEPoiIpmY2TJ3r0+7L4dA/xgw193/Jrn+KaDB3a/ppf0XgWmd7VP2zQfmA0ycOPH09evX5/VCstmxfwdLNi6hsaXxUNDv2L8DgKFVQ6kfX38o4BvqGqgbkfGcU3QbNsCVV8If/wjvex/cfTdMmFDSkkSknzvSQP84cH5KoM9x98+naXsOcCfwLnf/n0zHPdIeei7cnZd3vtwt4JdvXs7BjoMA1A2vOxTuDXUNnD7+dIZVDytqTT1rhIULwwemiQQsWACXX67euoikd6SBntOQi5m9HXgAmOfuL2Yrqi8CPZ0DbQdYsWVFt6Gal3e+DECFVTDj2BndhmpOGX1KnwzVrFsX5oR5/HG48EL44Q9h/PiiP62IlJkjDfRK4EXgvcBGYClwqbs3d2kzEfhv4DJ3fzKXokoV6Ols37e921DNko1L2PnmTgCGVw/vMVQzbvi4otTR0RGufrnpJhgyBP7t3+DSS9VbF5G3HFGgJw9wAbAASACL3f0bZnYVgLsvNLO7gI8CnYPibb09Yaf+FOip3J2XdrxEY0sjT7c8TePGRp597VnaOsI9/BNGTOgxVFNTVVOw51+zJgy7PP00fPjDYUjm2GMLdngRKWNHHOjF0J8DPZ39B/ezfMvybuPxr7z+CgAJS3DqmFO7DdVMGz2NCjv8+7ba2+G22+CWW2DEiPDVdx/7WIFejIiULQV6kWzdu7VbwC/ZuIRdB3YBMGLQCGaPn91tqGbMsDF5P0dzM3z602Ge9Ysvhttvh1GjCv1KRKRcKND7SId3sGb7mkMftjZubGTlaytp9zCBy6SRk7r14k8bexpDqoZkPe7Bg/Ctb4VpeUeNgkWL4IMfLParEZH+SIFeQvsO7uOZzc9068lveGMDAJUVlcwcM7NbL37qqKm9DtWsWBF66ytXwmWXwfe+ByNH9uWrEZFSU6D3M5t3bw5X1SQDfunGpexu3Q3AyMEjmVM3p1tPfnTN6EO/29oKt94K3/wmjB0bvi1p7txSvRIR6WsK9H6uvaOdF7a/0G2o5rmtz9HhYfauyUdP7jFUs3L5ID796TDP+mc/Gz5AHd6/pq8RkSJQoJehPa17WLZpWbcboDbu3ghAVUUVs8bO4vSxDWx4soFH/m8DE4dN4UeLjXPPLXHhIlJUCvRIbNy1sVsvvmlTE3sP7gWg4sAxdGyYw+zxDdz0qQbOPnEOo2p0OYxIbBTokWrraGPVtlU0tjTy/9c38vDyRv4n0QwW/ptOOWYKDXUN1I+vZ9SQUQytHsrQqqHUVNUc+rnrY3WiusSvSESyUaAPIL95dDefuaWJLYlGTnx3I3tHNrJl7+acfreyojJj4A+teuvnmqqa9Pt7OWnUVNUc0Y1WIhJkCvSsX3Ah5WXee4fzUsM5fOlL57DwG3DSyc7dP9zGSafuYm/rXvYe3Hvocd/BfT22HXpM/rzv4D52t+5my54tPdo5+XUGhlQOyfpXwuGeNKoT1ZgmvZEBToEeoWHDwlQBH/kIXHml8YH3HEtt7bFMmQInnth9mTIFamvznwDM3Xmz7c1wUkh3Qsh00khp99qe13psO9B+IK96EpbI+ldC15NFppNKTVUNlRWVJCxBhVWQqEg+Jtfz2aaTjPQlDblE7o03wrXqL7wAa9fCyy9DS0uYh73TsGHdA75r4E+YEOZp72ttHW2HTgaFOGmkHqPzktBiMyznE0Dneq7bCnKsAj13V+kyJfWvudQ26f7ay9amnI9x9vFnc/6U83u0y4WGXAawo46C66/vvu3NN+GVV94K+M6luRkeeihMNdCpqip852lqr/7EE8P2wYOLU3dlRSUjBo1gxKARBT+2u3Og/UDGwG/vaKfDO2j35GNyPd22zvVct2U6Vgd5tu+y7WD7wYLXk/p7+Q6zxcro/pdX6l9iqftT2zh+2IGeiQJ9ABo8GKZNC0uq9vbQg+8a9J3B/+c/w+7db7U1g7q6nr36zqW/TktgZgyuHMzgysGMQpd25sPdDwV8Z+C3d7TnHWjp2qQbnso3OIt1jHKhQJduEgk4/viwpN6k5A7bt3cP+c7loYdg69bu7UeN6n0oZ+xYfXFHOTIzEpYgQf/4wnXpToEuOTMLH6DW1sIZZ/Tcv3t3+Cq91J79U0/Bz38evpGpU01N+g9oTzwRJk6ESv3LFMmb/reRghk+HGbODEuq1lZYv75nz/7FF+E3v4EDXS5qqawMfyGkG8qZPDmcDESkJwW69Inqapg6NSypOjpg06b04/aNjfD6693bjx/f+1DOMcf0zesR6Y902aL0ezt29OzZd4b+5pSbYEeO7BnynevjxkGFblaVMqfLFqWsHXMMzJkTllT79qUft29qgv/8z3DVTqfBg8OQTbqe/aRJ4RJNkXKmQJeyVlMDM2aEJVVbG2zYkL53/+ij4WTQKZEIH8Z2jtOPHAlDh/a+1NT03Fatuc2kxBToEq3KyhDOkyf33OcOW7akH7d/4AHYtav7B7W5Pl8+J4B82g4ZouEiyU6BLgOSWRhTHzcO3vWu9G3a2kIvfu/e9EumfV2XN94IH/qmts/346veTgr5nCx6a6/hpjgo0EV6UVkJI0aEpdDcwxQM2U4GuZw0Nm3q2b61Nb96qqqO7GRRXR2OUVkZHrsu6bal216KOYNio0AXKQGzMIwyZAiMHp29fb4OHsz9L4hM7V5/HTZu7Nm+GMxyPyGUy7bKyr69I1qBLhKhqqowMdtRRxX+2O6wf3/3kG9tDSeRtrbwmLqk216obXv35v+7falruHcG/uc/D1/5ShGeq/CHFJGYmYWhmJqaMA1EuXEPl7P21Qkn3bZTTinOa1Ogi8iA0jm0U1kZhrxioguhREQioUAXEYmEAl1EJBIKdBGRSCjQRUQioUAXEYmEAl1EJBI5BbqZzTWzNWa21sxuTLPfzOz7yf0rzewdhS9VREQyyRroZpYA7gDmAdOBS8xsekqzecDU5DIf+EGB6xQRkSxy6aHPAda6+zp3bwXuBS5KaXMR8O8ePA2MNLNxBa5VREQyyOXW/zrg1S7rLUBDDm3qgG7f+Ghm8wk9eIA9ZrYmr2rfMhrYfpi/O1DpPcuP3q/86P3Kz5G8X8f3tiOXQE83+WPq1Py5tMHdFwGLcnjOzAWZNfX2JamSnt6z/Oj9yo/er/wU6/3KZcilBZjQZf04YNNhtBERkSLKJdCXAlPN7AQzqwYuBh5MafMgcFnyapczgDfcfXPqgUREpHiyDrm4e5uZXQP8DkgAi9292cyuSu5fCDwCXACsBfYBVxSvZKAAwzYDkN6z/Oj9yo/er/wU5f0yz/ebakVEpF/SnaIiIpFQoIuIRKLsAj3bNATyFjNbbGZbzez5UtdSDsxsgpn9ycxWm1mzmV1b6pr6MzMbbGZLzOzZ5Pv1T6WuqRyYWcLMlpvZw4U+dlkFeo7TEMhbfgzMLXURZaQNuN7dTwHOAK7Wv6+MDgDnuvtMYBYwN3mVm2R2LbC6GAcuq0Ant2kIJMndHwd2lLqOcuHum939meTPuwn/09WVtqr+KznVx57kalVy0VUWGZjZccAHgLuKcfxyC/TephgQKSgzmwScBjSWtpL+LTl8sALYCvzB3fV+ZbYA+DLQUYyDl1ug5zTFgMiRMLNhwC+B69x9V6nr6c/cvd3dZxHuDp9jZjNKXVN/ZWYXAlvdfVmxnqPcAl1TDEhRmVkVIcx/4u73l7qecuHurwOPoc9sMnkn8EEze4UwXHyumf1HIZ+g3AI9l2kIRA6LmRlwN7Da3f+l1PX0d2ZWa2Yjkz8PAc4DXihtVf2Xu9/k7se5+yRCdv23u3+ykM9RVoHu7m1A5zQEq4H73L25tFX1X2b2M+Ap4GQzazGzK0tdUz/3TuBThJ7TiuRyQamL6sfGAX8ys5WEztYf3L3gl+JJ7nTrv4hIJMqqhy4iIr1ToIuIREKBLiISCQW6iEgkFOgiIpFQoIuIREKBLiISif8FO3eSbTBAuywAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_metrics(train_metric, val_metric, metric_name, title, ylim=5):\n",
    "    plt.title(title)\n",
    "    plt.ylim(0,ylim)\n",
    "    plt.gca().xaxis.set_major_locator(mticker.MultipleLocator(1))\n",
    "    plt.plot(train_metric,color='blue',label=metric_name)\n",
    "    plt.plot(val_metric,color='green',label='val_' + metric_name)\n",
    "\n",
    "plot_metrics(epochs_train_losses, epochs_val_losses, \"Loss\", \"Loss\", ylim=1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "27fXX7Yqyu5S"
   },
   "source": [
    "We plot the confusion matrix to visualize the true values against the values predicted by the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_9n2XJ9MwpDS"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_outputs = model(norm_test_X.values)\n",
    "plot_confusion_matrix(test_Y.values, tf.round(test_outputs), title='Confusion Matrix for Untrained Model')"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "schema_names": [
    "TF3C2W2-1",
    "TF3C2W2-2",
    "TF3C2W2-3"
   ]
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}