hotspot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning on Traffic Hotspot\n",
    "In the following program, we would guide you through use Tensorflow library to load and process traffic data. Then we would teach you how to create and train your Tensorflow model.\n",
    "\n",
    "**Note: Hit the \"Run\" button to run the program block by block. We don't recommend you to use \"Run All\" in \"Cell\" because the first few blocks only need to be run once and they take some time to run.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Libraries\n",
    "The following block is used in Python to import necessary libraries. You might encounter error while trying to import tensorflow. This is becuase Tensorflow is not a default library that comes with the Python package you installed. Go to this link https://www.tensorflow.org/install/pip#system-install and follow the instructions on installing Tensorflow. If you encounter problems while trying to install Tensorflow you can add `--user` after `pip install`. This is because you did not create a virtual environment for your python packages. You can follow Step 2 on the website to create a virtual environment (recommended) or you can just install the package in your HOME environment.\n",
    "\n",
    "* `pandas` is used to process our data.\n",
    "\n",
    "* `numpy` is a great tool for mathematical processing and array creations.\n",
    "\n",
    "* `sklearn` is used to split the data into Training, Testing, and Validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the TensorBoard notebook extension.\n",
    "from datetime import datetime\n",
    "from packaging import version\n",
    "\n",
    "# Import Libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load and Clean up the Dataset\n",
    "To process the data, save the data.txt and label.txt file you downloaded from the Google Drive to the same directory where this Notebook is at.\n",
    "* `with open(label_src, 'r')` reads the data into label\n",
    "\n",
    "    * Note that we call `np` directly becuase we import `numpy as np`\n",
    "    \n",
    "* `.from_tensor_slices()` .would bind numpy array data and label together to creat a tensorflow data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_src = \"sample data\\\\data.txt\"\n",
    "label_src = \"sample data\\\\label.txt\"\n",
    "\n",
    "with open(label_src, 'r') as f:\n",
    "    label = np.array(f.read().split())\n",
    "label = label.astype(\"float\")\n",
    "\n",
    "data = []\n",
    "with open(data_src, 'r') as f:\n",
    "    for line in f:\n",
    "        data.append(line.split())\n",
    "data = np.array(data)\n",
    "data = data.astype(\"float\")\n",
    "\n",
    "dataset = tf.data.Dataset.from_tensor_slices((data, label))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We seperated the block above from the block below becuase we don't want you to read the data twice. Reading a large file as you might have experienced a few minutes ago take up quite some RAM and CPU.\n",
    "\n",
    "**To-do:** \n",
    "1. Print out the **shape** of our datasets. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of features is (7894, 200)\n",
      "shape of labels is (7894,)\n"
     ]
    }
   ],
   "source": [
    "print(\"shape of features is {}\".format(np.shape(data)))\n",
    "print(\"shape of labels is {}\".format(np.shape(label)))\n",
    "### Insert your code below ###\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By now, you acquire the shape of our dataset, the first demension give us the number of data points, and the second dimension give us teh size of each data point.\n",
    "    For example, feature size of (4000, 800) would represent a dataset of 4000 data, and each data is a 800 entry list. When designing model later, we must make sure the the input layer have the same input size as our data size.Later,we need to shuffle the data and separate it in to batches before we can use it. \n",
    "\n",
    "\n",
    "**To-do:**\n",
    "1. Shuffle the data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 1000\n",
    "SHUFFLE_BUFFER_SIZE = 100000 \n",
    "#dataset is fully shuffled only when shuffle_buffer_size larger the data size.\n",
    "\n",
    "# Shuffle the dataset\n",
    "dataset_shuffled = dataset.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the dataset would be divided in to different batches, we can check the number of batch by using following code. And we expect # batch = # data / batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of batches in dataset is 8\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of batches in dataset is {}\".format(tf.data.experimental.cardinality(dataset_shuffled)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Stop*\n",
    "*Before you proceed, make sure you finish reading \"Machine Learning Introduction\" in Step 3 of the lab. You should complete the Tensorflow playground exercise and take a screenshot of your results.*   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split Data for Machine Learning\n",
    "In machine learning, we often want to split our data into Training Set, Validation Set, and Test Set.\n",
    "* **Training Set**:\n",
    "Training Set is used to train our machine learning model while the Validation and Test Set aren't. \n",
    "* **Validation Set**:\n",
    "Having a Validation Set prevents overfitting of our machine learning model. Overfitting is when our model is tuned perfectly for a specific set of data, but is fitted poorly for other set of data. Take traffic emission data for example. If the data predicts $CO_2$ emission data within 10 mse (mean squared error) from Training Set, but predicts emission data over 50 mse from Validation data. Then we could see that the model is overfitted.\n",
    "* **Test Set**:\n",
    "Test set is used to evaluate the final model.\n",
    "\n",
    "A typical workflow will be: \n",
    "1. Train your model using *Training Set*.\n",
    "2. Validate your model using *Validation Set*.\n",
    "3. Adjust your model using results from *Validation Set*.\n",
    "4. Pick the model that produces best results from using *Validation Set*.\n",
    "5. Confirm your model with *Test Set*.\n",
    "\n",
    "**To-Do:**\n",
    "1. Tweak the `test_size` values for spilitting `train_dataset`, `test_dataset`, and `val_dataset`.\n",
    "\n",
    "2. In given code 80% of all data would be used for train, 10% data would be used for validation and 10% of data would be used for test, you can change this ratio by change parameter in calculating train_size, val_size and test_size\n",
    "\n",
    "3. You will come back and change some codes after you finish your first training. Instructions will be provided in the \"Train the Model\" section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total dataset size 8\n",
      "train dataset size 6\n",
      "test dataset size 0\n",
      "validation dataset size 2\n"
     ]
    }
   ],
   "source": [
    "DATASET_SIZE = tf.data.experimental.cardinality(dataset_shuffled).numpy()\n",
    "train_size = int(0.8 * DATASET_SIZE)\n",
    "val_size = int(0.1 * DATASET_SIZE)\n",
    "test_size = int(0.1 * DATASET_SIZE)\n",
    "\n",
    "train_dataset = dataset_shuffled.take(train_size)\n",
    "test_dataset = dataset_shuffled.skip(train_size)\n",
    "val_dataset = test_dataset.skip(val_size)\n",
    "test_dataset = test_dataset.take(test_size)\n",
    "\n",
    "print(\"total dataset size {}\".format(DATASET_SIZE))\n",
    "print(\"train dataset size {}\".format(tf.data.experimental.cardinality(train_dataset)))\n",
    "print(\"test dataset size {}\".format(tf.data.experimental.cardinality(test_dataset)))\n",
    "print(\"validation dataset size {}\".format(tf.data.experimental.cardinality(val_dataset)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Model and Training Function\n",
    "\n",
    "The below code block defines function for creating and trining a sequential Tensorflow model. You can also train the model without function definition. Just replace the function call in the next block after this one with: \n",
    "\n",
    "`model = tf.keras.models.Sequential()`\n",
    "<br>&emsp;&emsp;&emsp;&emsp;.\n",
    "<br>&emsp;&emsp;&emsp;&emsp;.\n",
    "<br>&emsp;&emsp;&emsp;&emsp;.\n",
    "<br>`model.save('my_model')`\n",
    "\n",
    "Also replace the input variables with the correct names. Note that the first function returns a variable. \n",
    "\n",
    "However, these function definitions make the code less messy. There is another way to write Tensorflow, which is called Functional API. It is more advanced. If you want to learn more, please go to https://www.tensorflow.org/guide/keras/functional. \n",
    "\n",
    "### Function Definition\n",
    "1. Create model \n",
    "    * `model.add()`: add layer to model\n",
    "    \n",
    "    * In `tf.keras.layers.Dense()`\n",
    "    \n",
    "        * `units`: number of nodes in that layer\n",
    "        \n",
    "        * `activation`: activation function used in that layer\n",
    "        \n",
    "        * `kernel_regularizer`: regularization function used in that layer\n",
    "        \n",
    "        * `name`: is just for us to keep track and debug\n",
    "        \n",
    "    * In `model.compile()`\n",
    "    \n",
    "        * `optimizer=tf.keras.optimizers.Adam(lr=learning_rate)`: Used to improve performance of the training\n",
    "        \n",
    "        * `Adam`: stochastic gradient descent method\n",
    "        \n",
    "        * `loss`: update the model according to specified loss function \n",
    "        \n",
    "        * `metrics`: evaluate the model according specified metrics\n",
    "        \n",
    "\n",
    "    \n",
    "**To-do:**\n",
    "See next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modelCreate(learning_rate):\n",
    "    \n",
    "    # Sequential is used in most simple keras models\n",
    "    model = tf.keras.models.Sequential([\n",
    "        \n",
    "        # First hidden layer with 80 nodes\n",
    "        tf.keras.layers.Dense(units=80, \n",
    "                              activation='relu',\n",
    "                              name='Hidden1'),\n",
    "        \n",
    "        # Dropout layer\n",
    "        tf.keras.layers.Dropout(0.5, name='Dropout1'),\n",
    "        \n",
    "        # Second hidden layer\n",
    "        tf.keras.layers.Dense(units=20, \n",
    "                              activation='relu', #change to relu \n",
    "                              name='Hidden2'),\n",
    "\n",
    "        \n",
    "        # Output layer\n",
    "        tf.keras.layers.Dense(units=1,  \n",
    "                              activation='sigmoid', #change to sigmoid\n",
    "                              name='Output')\n",
    "      \n",
    "        #Create your own model\n",
    "        \n",
    "        \n",
    "    ])\n",
    "\n",
    "    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),\n",
    "                  loss=tf.keras.losses.BinaryCrossentropy(from_logits=False),\n",
    "                  metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the Model\n",
    "As we mentioned in the lab document, Hyperparameters affect the performance of your model. In the following block, you would be training your model. We also want you to experience training both a small dataset and a large dataset. \n",
    "\n",
    "**To-do:**\n",
    "    \n",
    "    1. Adjust the Hyperparameters. Remember, a large learning rate might cause the model to never converge, but a very small learning rate would cause the model to converge very slow. If your accuracy is increasing but your program finishes before the acuracy reaches a big number, increase your epochs. Lastly, a large batch size might give you a better convergence, but it might also lead to poor generalization and slow training speed. Try batch sizes of 1000, 10000, 200000. We recommend you use a batch sizes of around 150000 for getting your final model, but do experiment with the batch sizes listed above. <u>Q: Do you notice any difference between using batch sizes of 1000, 10000, 200000?</u>\n",
    "    \n",
    "    2. In the function definitions:\n",
    "        * Press the stop button (**interrupt the kernal**) next to Run before you change the values in the functions above. \n",
    "        * Add or reduce Hidden layers if your model turns our poorly. \n",
    "        * Adjust the amount of nodes in each Hidden layer. \n",
    "        * Try out different activation functions. \n",
    "        * Try different regularizers. \n",
    "        * You should aim to get an **mse < 100**.\n",
    "        \n",
    "    3. The program will run for a longer time with large dataset input. Once you get a result with nice mse, you don't have to run `%tensorboard --logdir logs`. Please click on \"File -> Print Preview\" and a separate page should open. Press Cmd/Ctrl + p to print. Select \"Save as PDF\". We will look at your training for the large dataset based on the logs printed out during each epoch.\n",
    "    \n",
    "\n",
    "*Note: Ignore the warnings at the beginning and at the end.*\n",
    "\n",
    "<u>Type your answers to Q:</u>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 21ms/step - accuracy: 0.7097 - loss: 11.6985 - val_accuracy: 0.8115 - val_loss: 1.1411\n",
      "Epoch 2/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - accuracy: 0.6754 - loss: 2.9204 - val_accuracy: 0.8184 - val_loss: 0.7058\n",
      "Epoch 3/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.7945 - loss: 1.3447 - val_accuracy: 0.8395 - val_loss: 0.5527\n",
      "Epoch 4/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.7959 - loss: 0.7826 - val_accuracy: 0.7540 - val_loss: 0.5368\n",
      "Epoch 5/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 10ms/step - accuracy: 0.7980 - loss: 0.6058 - val_accuracy: 0.8258 - val_loss: 0.4947\n",
      "Epoch 6/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8269 - loss: 0.5124 - val_accuracy: 0.8485 - val_loss: 0.4588\n",
      "Epoch 7/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - accuracy: 0.8359 - loss: 0.4967 - val_accuracy: 0.8458 - val_loss: 0.4274\n",
      "Epoch 8/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8417 - loss: 0.4474 - val_accuracy: 0.8205 - val_loss: 0.4533\n",
      "Epoch 9/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8377 - loss: 0.4480 - val_accuracy: 0.8395 - val_loss: 0.4291\n",
      "Epoch 10/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8430 - loss: 0.4334 - val_accuracy: 0.8384 - val_loss: 0.4179\n",
      "Epoch 11/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8435 - loss: 0.4650 - val_accuracy: 0.8543 - val_loss: 0.4110\n",
      "Epoch 12/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8495 - loss: 0.4281 - val_accuracy: 0.8395 - val_loss: 0.4217\n",
      "Epoch 13/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8477 - loss: 0.4155 - val_accuracy: 0.8295 - val_loss: 0.4186\n",
      "Epoch 14/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8435 - loss: 0.4180 - val_accuracy: 0.8485 - val_loss: 0.3983\n",
      "Epoch 15/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8421 - loss: 0.4220 - val_accuracy: 0.8347 - val_loss: 0.4060\n",
      "Epoch 16/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - accuracy: 0.8493 - loss: 0.4086 - val_accuracy: 0.8432 - val_loss: 0.4118\n",
      "Epoch 17/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step - accuracy: 0.8429 - loss: 0.4103 - val_accuracy: 0.8405 - val_loss: 0.4204\n",
      "Epoch 18/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 9ms/step - accuracy: 0.8456 - loss: 0.4134 - val_accuracy: 0.8421 - val_loss: 0.4173\n",
      "Epoch 19/100\n",
      "\u001b[1m6/6\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 8ms/step - accuracy: 0.8466 - loss: 0.4043 - val_accuracy: 0.8400 - val_loss: 0.4052\n",
      "Epoch 19: early stopping\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "#useing EarlyStopping to avoid overfitting\n",
    "early_stopping = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=5, verbose=1, mode='min')\n",
    "\n",
    "LEARNING_RATE = 0.01 #change to 0.01 for better accuracy\n",
    "\n",
    "model = modelCreate(LEARNING_RATE)\n",
    "history = model.fit(train_dataset, batch_size=BATCH_SIZE, epochs=100, validation_data=val_dataset,  callbacks=[early_stopping])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may find the accuracy of data is hard to increase, this is because the data in this case is highly inbalance, which, in this case, means that the data cooresponding to no traffic hotspot is far more than the data cooresponding to existing traffic hotspot. You may explore methods of increasing the accuracy by using techniques like increasing sample size, down sampling, up sampling, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_17\"</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1mModel: \"sequential_17\"\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
       "│ Hidden1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">80</span>)             │        <span style=\"color: #00af00; text-decoration-color: #00af00\">16,080</span> │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ Dropout1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)              │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">80</span>)             │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ Hidden2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">20</span>)             │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,620</span> │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ Output (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)              │            <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span> │\n",
       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
       "</pre>\n"
      ],
      "text/plain": [
       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
       "│ Hidden1 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m80\u001b[0m)             │        \u001b[38;5;34m16,080\u001b[0m │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ Dropout1 (\u001b[38;5;33mDropout\u001b[0m)              │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m80\u001b[0m)             │             \u001b[38;5;34m0\u001b[0m │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ Hidden2 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m20\u001b[0m)             │         \u001b[38;5;34m1,620\u001b[0m │\n",
       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
       "│ Output (\u001b[38;5;33mDense\u001b[0m)                  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)              │            \u001b[38;5;34m21\u001b[0m │\n",
       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">53,165</span> (207.68 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m53,165\u001b[0m (207.68 KB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">17,721</span> (69.22 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m17,721\u001b[0m (69.22 KB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Optimizer params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">35,444</span> (138.46 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m35,444\u001b[0m (138.46 KB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs = range(1, len(train_loss) + 1)\n",
    "plt.plot(epochs, train_loss, 'bo-', label='Training Loss')\n",
    "plt.plot(epochs, val_loss, 'ro-', label='Validation Loss')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "## Well Done!\n",
    "**Congradulation on finishing the lab. Submit this .ipnyb Notebook file, the PDF, and loss graph screenshots to the link specified in the Google Doc.**  "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}