Convolution_model_Application.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolutional Neural Networks: Application\n",
    "\n",
    "Welcome to Course 4's second assignment! In this notebook, you will:\n",
    "\n",
    "- Create a mood classifer using the TF Keras Sequential API\n",
    "- Build a ConvNet to identify sign language digits using the TF Keras Functional API\n",
    "\n",
    "**After this assignment you will be able to:**\n",
    "\n",
    "- Build and train a ConvNet in TensorFlow for a __binary__ classification problem\n",
    "- Build and train a ConvNet in TensorFlow for a __multiclass__ classification problem\n",
    "- Explain different use cases for the Sequential and Functional APIs\n",
    "\n",
    "To complete this assignment, you should already be familiar with TensorFlow. If you are not, please refer back to the **TensorFlow Tutorial** of the third week of Course 2 (\"**Improving deep neural networks**\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "- [1 - Packages](#1)\n",
    "    - [1.1 - Load the Data and Split the Data into Train/Test Sets](#1-1)\n",
    "- [2 - Layers in TF Keras](#2)\n",
    "- [3 - The Sequential API](#3)\n",
    "    - [3.1 - Create the Sequential Model](#3-1)\n",
    "        - [Exercise 1 - happyModel](#ex-1)\n",
    "    - [3.2 - Train and Evaluate the Model](#3-2)\n",
    "- [4 - The Functional API](#4)\n",
    "    - [4.1 - Load the SIGNS Dataset](#4-1)\n",
    "    - [4.2 - Split the Data into Train/Test Sets](#4-2)\n",
    "    - [4.3 - Forward Propagation](#4-3)\n",
    "        - [Exercise 2 - convolutional_model](#ex-2)\n",
    "    - [4.4 - Train the Model](#4-4)\n",
    "- [5 - History Object](#5)\n",
    "- [6 - Bibliography](#6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='1'></a>\n",
    "## 1 - Packages\n",
    "\n",
    "As usual, begin by loading in the packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import imread\n",
    "import scipy\n",
    "from PIL import Image\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras.layers as tfl\n",
    "from tensorflow.python.framework import ops\n",
    "from cnn_utils import *\n",
    "from test_utils import summary, comparator\n",
    "\n",
    "%matplotlib inline\n",
    "np.random.seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='1-1'></a>\n",
    "### 1.1 - Load the Data and Split the Data into Train/Test Sets\n",
    "\n",
    "You'll be using the Happy House dataset for this part of the assignment, which contains images of peoples' faces. Your task will be to build a ConvNet that determines whether the people in the images are smiling or not -- because they only get to enter the house if they're smiling!  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 600\n",
      "number of test examples = 150\n",
      "X_train shape: (600, 64, 64, 3)\n",
      "Y_train shape: (600, 1)\n",
      "X_test shape: (150, 64, 64, 3)\n",
      "Y_test shape: (150, 1)\n"
     ]
    }
   ],
   "source": [
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_happy_dataset()\n",
    "\n",
    "# Normalize image vectors\n",
    "X_train = X_train_orig/255.\n",
    "X_test = X_test_orig/255.\n",
    "\n",
    "# Reshape\n",
    "Y_train = Y_train_orig.T\n",
    "Y_test = Y_test_orig.T\n",
    "\n",
    "print (\"number of training examples = \" + str(X_train.shape[0]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[0]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can display the images contained in the dataset. Images are **64x64** pixels in RGB format (3 channels)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "index = 124\n",
    "plt.imshow(X_train_orig[index]) #display sample training image\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2'></a>\n",
    "## 2 - Layers in TF Keras \n",
    "\n",
    "In the previous assignment, you created layers manually in numpy. In TF Keras, you don't have to write code directly to create layers. Rather, TF Keras has pre-defined layers you can use. \n",
    "\n",
    "When you create a layer in TF Keras, you are creating a function that takes some input and transforms it into an output you can reuse later. Nice and easy! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='3'></a>\n",
    "## 3 - The Sequential API\n",
    "\n",
    "In the previous assignment, you built helper functions using `numpy` to understand the mechanics behind convolutional neural networks. Most practical applications of deep learning today are built using programming frameworks, which have many built-in functions you can simply call. Keras is a high-level abstraction built on top of TensorFlow, which allows for even more simplified and optimized model creation and training. \n",
    "\n",
    "For the first part of this assignment, you'll create a model using TF Keras' Sequential API, which allows you to build layer by layer, and is ideal for building models where each layer has **exactly one** input tensor and **one** output tensor. \n",
    "\n",
    "As you'll see, using the Sequential API is simple and straightforward, but is only appropriate for simpler, more straightforward tasks. Later in this notebook you'll spend some time building with a more flexible, powerful alternative: the Functional API. \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='3-1'></a>\n",
    "### 3.1 - Create the Sequential Model\n",
    "\n",
    "As mentioned earlier, the TensorFlow Keras Sequential API can be used to build simple models with layer operations that proceed in a sequential order. \n",
    "\n",
    "You can also add layers incrementally to a Sequential model with the `.add()` method, or remove them using the `.pop()` method, much like you would in a regular Python list.\n",
    "\n",
    "Actually, you can think of a Sequential model as behaving like a list of layers. Like Python lists, Sequential layers are ordered, and the order in which they are specified matters.  If your model is non-linear or contains layers with multiple inputs or outputs, a Sequential model wouldn't be the right choice!\n",
    "\n",
    "For any layer construction in Keras, you'll need to specify the input shape in advance. This is because in Keras, the shape of the weights is based on the shape of the inputs. The weights are only created when the model first sees some input data. Sequential models can be created by passing a list of layers to the Sequential constructor, like you will do in the next assignment.\n",
    "\n",
    "<a name='ex-1'></a>\n",
    "### Exercise 1 - happyModel\n",
    "\n",
    "Implement the `happyModel` function below to build the following model: `ZEROPAD2D -> CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> FLATTEN -> DENSE`. Take help from [tf.keras.layers](https://www.tensorflow.org/api_docs/python/tf/keras/layers) \n",
    "\n",
    "Also, plug in the following parameters for all the steps:\n",
    "\n",
    " - [ZeroPadding2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/ZeroPadding2D): padding 3, input shape 64 x 64 x 3\n",
    " - [Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D): Use 32 7x7 filters, stride 1\n",
    " - [BatchNormalization](https://www.tensorflow.org/api_docs/python/tf/keras/layers/BatchNormalization): for axis 3\n",
    " - [ReLU](https://www.tensorflow.org/api_docs/python/tf/keras/layers/ReLU)\n",
    " - [MaxPool2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D): Using default parameters\n",
    " - [Flatten](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Flatten) the previous output.\n",
    " - Fully-connected ([Dense](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense)) layer: Apply a fully connected layer with 1 neuron and a sigmoid activation. \n",
    " \n",
    " \n",
    " **Hint:**\n",
    " \n",
    " Use **tfl** as shorthand for **tensorflow.keras.layers**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "95d28b191f257bdd5b70c7b8952559d5",
     "grade": false,
     "grade_id": "cell-0e56d3fc28b69aec",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: happyModel\n",
    "\n",
    "def happyModel():\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the binary classification model:\n",
    "    ZEROPAD2D -> CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> FLATTEN -> DENSE\n",
    "    \n",
    "    Note that for simplicity and grading purposes, you'll hard-code all the values\n",
    "    such as the stride and kernel (filter) sizes. \n",
    "    Normally, functions should take these values as function parameters.\n",
    "    \n",
    "    Arguments:\n",
    "    None\n",
    "\n",
    "    Returns:\n",
    "    model -- TF Keras model (object containing the information for the entire training process) \n",
    "    \"\"\"\n",
    "    model = tf.keras.Sequential([\n",
    "            ## ZeroPadding2D with padding 3, input shape of 64 x 64 x 3\n",
    "            tfl.ZeroPadding2D(padding=3, input_shape=(64,64,3)),\n",
    "            \n",
    "            ## Conv2D with 32 7x7 filters and stride of 1\n",
    "            tfl.Conv2D(filters=32, kernel_size=(7,7), strides=1),\n",
    "            ## BatchNormalization for axis 3\n",
    "            tfl.BatchNormalization(axis=3),\n",
    "            ## ReLU\n",
    "            tfl.ReLU(),\n",
    "            ## Max Pooling 2D with default parameters\n",
    "            tfl.MaxPooling2D(),\n",
    "            ## Flatten layer\n",
    "            tfl.Flatten(),\n",
    "            ## Dense layer with 1 unit for output & 'sigmoid' activation\n",
    "            tfl.Dense(units=1, activation='sigmoid')\n",
    "            # YOUR CODE STARTS HERE\n",
    "            \n",
    "            \n",
    "            # YOUR CODE ENDS HERE\n",
    "        ])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8d3575c950e2e78149be2d05d671c80d",
     "grade": true,
     "grade_id": "cell-e3e1046e5c33d775",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ZeroPadding2D', (None, 70, 70, 3), 0, ((3, 3), (3, 3))]\n",
      "['Conv2D', (None, 64, 64, 32), 4736, 'valid', 'linear', 'GlorotUniform']\n",
      "['BatchNormalization', (None, 64, 64, 32), 128]\n",
      "['ReLU', (None, 64, 64, 32), 0]\n",
      "['MaxPooling2D', (None, 32, 32, 32), 0, (2, 2), (2, 2), 'valid']\n",
      "['Flatten', (None, 32768), 0]\n",
      "['Dense', (None, 1), 32769, 'sigmoid']\n",
      "\u001b[32mAll tests passed!\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "happy_model = happyModel()\n",
    "# Print a summary for each layer\n",
    "for layer in summary(happy_model):\n",
    "    print(layer)\n",
    "    \n",
    "output = [['ZeroPadding2D', (None, 70, 70, 3), 0, ((3, 3), (3, 3))],\n",
    "            ['Conv2D', (None, 64, 64, 32), 4736, 'valid', 'linear', 'GlorotUniform'],\n",
    "            ['BatchNormalization', (None, 64, 64, 32), 128],\n",
    "            ['ReLU', (None, 64, 64, 32), 0],\n",
    "            ['MaxPooling2D', (None, 32, 32, 32), 0, (2, 2), (2, 2), 'valid'],\n",
    "            ['Flatten', (None, 32768), 0],\n",
    "            ['Dense', (None, 1), 32769, 'sigmoid']]\n",
    "    \n",
    "comparator(summary(happy_model), output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that your model is created, you can compile it for training with an optimizer and loss of your choice. When the string `accuracy` is specified as a metric, the type of accuracy used will be automatically converted based on the loss function used. This is one of the many optimizations built into TensorFlow that make your life easier! If you'd like to read more on how the compiler operates, check the docs [here](https://www.tensorflow.org/api_docs/python/tf/keras/Model#compile)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "happy_model.compile(optimizer='adam',\n",
    "                   loss='binary_crossentropy',\n",
    "                   metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's time to check your model's parameters with the `.summary()` method. This will display the types of layers you have, the shape of the outputs, and how many parameters are in each layer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_7\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "zero_padding2d_9 (ZeroPaddin (None, 70, 70, 3)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_9 (Conv2D)            (None, 64, 64, 32)        4736      \n",
      "_________________________________________________________________\n",
      "batch_normalization_8 (Batch (None, 64, 64, 32)        128       \n",
      "_________________________________________________________________\n",
      "re_lu (ReLU)                 (None, 64, 64, 32)        0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_8 (MaxPooling2 (None, 32, 32, 32)        0         \n",
      "_________________________________________________________________\n",
      "flatten_8 (Flatten)          (None, 32768)             0         \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 1)                 32769     \n",
      "=================================================================\n",
      "Total params: 37,633\n",
      "Trainable params: 37,569\n",
      "Non-trainable params: 64\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "happy_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='3-2'></a>\n",
    "### 3.2 - Train and Evaluate the Model\n",
    "\n",
    "After creating the model, compiling it with your choice of optimizer and loss function, and doing a sanity check on its contents, you are now ready to build! \n",
    "\n",
    "Simply call `.fit()` to train. That's it! No need for mini-batching, saving, or complex backpropagation computations. That's all been done for you, as you're using a TensorFlow dataset with the batches specified already. You do have the option to specify epoch number or minibatch size if you like (for example, in the case of an un-batched dataset)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "38/38 [==============================] - 4s 105ms/step - loss: 0.8517 - accuracy: 0.7333\n",
      "Epoch 2/10\n",
      "38/38 [==============================] - 4s 98ms/step - loss: 0.2323 - accuracy: 0.9167\n",
      "Epoch 3/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.1258 - accuracy: 0.9517\n",
      "Epoch 4/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.1013 - accuracy: 0.9633\n",
      "Epoch 5/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.0983 - accuracy: 0.9583\n",
      "Epoch 6/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.1374 - accuracy: 0.9467\n",
      "Epoch 7/10\n",
      "38/38 [==============================] - 4s 98ms/step - loss: 0.0917 - accuracy: 0.9717\n",
      "Epoch 8/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.3217 - accuracy: 0.8883\n",
      "Epoch 9/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.1643 - accuracy: 0.9350\n",
      "Epoch 10/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.1279 - accuracy: 0.9500\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f4f501da310>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "happy_model.fit(X_train, Y_train, epochs=10, batch_size=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After that completes, just use `.evaluate()` to evaluate against your test set. This function will print the value of the loss function and the performance metrics specified during the compilation of the model. In this case, the `binary_crossentropy` and the `accuracy` respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 0s 34ms/step - loss: 0.2667 - accuracy: 0.9000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.26668858528137207, 0.8999999761581421]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "happy_model.evaluate(X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Easy, right? But what if you need to build a model with shared layers, branches, or multiple inputs and outputs? This is where Sequential, with its beautifully simple yet limited functionality, won't be able to help you. \n",
    "\n",
    "Next up: Enter the Functional API, your slightly more complex, highly flexible friend.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4'></a>\n",
    "## 4 - The Functional API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the second half of the assignment, where you'll use Keras' flexible [Functional API](https://www.tensorflow.org/guide/keras/functional) to build a ConvNet that can differentiate between 6 sign language digits. \n",
    "\n",
    "The Functional API can handle models with non-linear topology, shared layers, as well as layers with multiple inputs or outputs. Imagine that, where the Sequential API requires the model to move in a linear fashion through its layers, the Functional API allows much more flexibility. Where Sequential is a straight line, a Functional model is a graph, where the nodes of the layers can connect in many more ways than one. \n",
    "\n",
    "In the visual example below, the one possible direction of the movement Sequential model is shown in contrast to a skip connection, which is just one of the many ways a Functional model can be constructed. A skip connection, as you might have guessed, skips some layer in the network and feeds the output to a later layer in the network. Don't worry, you'll be spending more time with skip connections very soon! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/seq_vs_func.png\" style=\"width:350px;height:200px;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-1'></a>\n",
    "### 4.1 - Load the SIGNS Dataset\n",
    "\n",
    "As a reminder, the SIGNS dataset is a collection of 6 signs representing numbers from 0 to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the data (signs)\n",
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_signs_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/SIGNS.png\" style=\"width:800px;height:300px;\">\n",
    "\n",
    "The next cell will show you an example of a labelled image in the dataset. Feel free to change the value of `index` below and re-run to see different examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 4\n"
     ]
    },
    {
     "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": [
    "# Example of an image from the dataset\n",
    "index = 9\n",
    "plt.imshow(X_train_orig[index])\n",
    "print (\"y = \" + str(np.squeeze(Y_train_orig[:, index])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-2'></a>\n",
    "### 4.2 - Split the Data into Train/Test Sets\n",
    "\n",
    "In Course 2, you built a fully-connected network for this dataset. But since this is an image dataset, it is more natural to apply a ConvNet to it.\n",
    "\n",
    "To get started, let's examine the shapes of your data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (1080, 64, 64, 3)\n",
      "Y_train shape: (1080, 6)\n",
      "X_test shape: (120, 64, 64, 3)\n",
      "Y_test shape: (120, 6)\n"
     ]
    }
   ],
   "source": [
    "X_train = X_train_orig/255.\n",
    "X_test = X_test_orig/255.\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6).T\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6).T\n",
    "print (\"number of training examples = \" + str(X_train.shape[0]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[0]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-3'></a>\n",
    "### 4.3 - Forward Propagation\n",
    "\n",
    "In TensorFlow, there are built-in functions that implement the convolution steps for you. By now, you should be familiar with how TensorFlow builds computational graphs. In the [Functional API](https://www.tensorflow.org/guide/keras/functional), you create a graph of layers. This is what allows such great flexibility.\n",
    "\n",
    "However, the following model could also be defined using the Sequential API since the information flow is on a single line. But don't deviate. What we want you to learn is to use the functional API.\n",
    "\n",
    "Begin building your graph of layers by creating an input node that functions as a callable object:\n",
    "\n",
    "- **input_img = tf.keras.Input(shape=input_shape):** \n",
    "\n",
    "Then, create a new node in the graph of layers by calling a layer on the `input_img` object: \n",
    "\n",
    "- **tf.keras.layers.Conv2D(filters= ... , kernel_size= ... , padding='same')(input_img):** Read the full documentation on [Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D).\n",
    "\n",
    "- **tf.keras.layers.MaxPool2D(pool_size=(f, f), strides=(s, s), padding='same'):** `MaxPool2D()` downsamples your input using a window of size (f, f) and strides of size (s, s) to carry out max pooling over each window.  For max pooling, you usually operate on a single example at a time and a single channel at a time. Read the full documentation on [MaxPool2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D).\n",
    "\n",
    "- **tf.keras.layers.ReLU():** computes the elementwise ReLU of Z (which can be any shape). You can read the full documentation on [ReLU](https://www.tensorflow.org/api_docs/python/tf/keras/layers/ReLU).\n",
    "\n",
    "- **tf.keras.layers.Flatten()**: given a tensor \"P\", this function takes each training (or test) example in the batch and flattens it into a 1D vector.  \n",
    "\n",
    "    * If a tensor P has the shape (batch_size,h,w,c), it returns a flattened tensor with shape (batch_size, k), where $k=h \\times w \\times c$.  \"k\" equals the product of all the dimension sizes other than the first dimension.\n",
    "    \n",
    "    * For example, given a tensor with dimensions [100, 2, 3, 4], it flattens the tensor to be of shape [100, 24], where 24 = 2 * 3 * 4.  You can read the full documentation on [Flatten](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Flatten).\n",
    "\n",
    "- **tf.keras.layers.Dense(units= ... , activation='softmax')(F):** given the flattened input F, it returns the output computed using a fully connected layer. You can read the full documentation on [Dense](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense).\n",
    "\n",
    "In the last function above (`tf.keras.layers.Dense()`), the fully connected layer automatically initializes weights in the graph and keeps on training them as you train the model. Hence, you did not need to initialize those weights when initializing the parameters.\n",
    "\n",
    "Lastly, before creating the model, you'll need to define the output using the last of the function's compositions (in this example, a Dense layer): \n",
    "\n",
    "- **outputs = tf.keras.layers.Dense(units=6, activation='softmax')(F)**\n",
    "\n",
    "\n",
    "#### Window, kernel, filter, pool\n",
    "\n",
    "The words \"kernel\" and \"filter\" are used to refer to the same thing. The word \"filter\" accounts for the amount of \"kernels\" that will be used in a single convolution layer. \"Pool\" is the name of the operation that takes the max or average value of the kernels. \n",
    "\n",
    "This is why the parameter `pool_size` refers to `kernel_size`, and you use `(f,f)` to refer to the filter size. \n",
    "\n",
    "Pool size and kernel size refer to the same thing in different objects - They refer to the shape of the window where the operation takes place. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='ex-2'></a>\n",
    "### Exercise 2 - convolutional_model\n",
    "\n",
    "Implement the `convolutional_model` function below to build the following model: `CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> DENSE`. Use the functions above! \n",
    "\n",
    "Also, plug in the following parameters for all the steps:\n",
    "\n",
    " - [Conv2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Conv2D): Use 8 4 by 4 filters, stride 1, padding is \"SAME\"\n",
    " - [ReLU](https://www.tensorflow.org/api_docs/python/tf/keras/layers/ReLU)\n",
    " - [MaxPool2D](https://www.tensorflow.org/api_docs/python/tf/keras/layers/MaxPool2D): Use an 8 by 8 filter size and an 8 by 8 stride, padding is \"SAME\"\n",
    " - **Conv2D**: Use 16 2 by 2 filters, stride 1, padding is \"SAME\"\n",
    " - **ReLU**\n",
    " - **MaxPool2D**: Use a 4 by 4 filter size and a 4 by 4 stride, padding is \"SAME\"\n",
    " - [Flatten](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Flatten) the previous output.\n",
    " - Fully-connected ([Dense](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense)) layer: Apply a fully connected layer with 6 neurons and a softmax activation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f58643806aa8380c96225fc8b4c5e7aa",
     "grade": false,
     "grade_id": "cell-dac51744a9e03f51",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: convolutional_model\n",
    "\n",
    "def convolutional_model(input_shape):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> DENSE\n",
    "    \n",
    "    Note that for simplicity and grading purposes, you'll hard-code some values\n",
    "    such as the stride and kernel (filter) sizes. \n",
    "    Normally, functions should take these values as function parameters.\n",
    "    \n",
    "    Arguments:\n",
    "    input_img -- input dataset, of shape (input_shape)\n",
    "\n",
    "    Returns:\n",
    "    model -- TF Keras model (object containing the information for the entire training process) \n",
    "    \"\"\"\n",
    "\n",
    "    input_img = tf.keras.Input(shape=input_shape)\n",
    "    ## CONV2D: 8 filters 4x4, stride of 1, padding 'SAME'\n",
    "    Z1 = tfl.Conv2D(filters=8, kernel_size=(4,4), strides=1, padding='SAME')(input_img)\n",
    "    ## RELU\n",
    "    A1 = tfl.ReLU()(Z1)\n",
    "    ## MAXPOOL: window 8x8, stride 8, padding 'SAME'\n",
    "    P1 = tfl.MaxPooling2D(pool_size=(8,8), strides=8, padding='SAME')(A1)\n",
    "    ## CONV2D: 16 filters 2x2, stride 1, padding 'SAME'\n",
    "    Z2 = tfl.Conv2D(filters=16, strides=1, kernel_size=(2,2), padding='SAME')(P1)\n",
    "    ## RELU\n",
    "    A2 = A1 = tfl.ReLU()(Z2)\n",
    "    ## MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2 = tfl.MaxPooling2D(pool_size=(4,4), strides=4, padding='SAME')(A2)\n",
    "    ## FLATTEN\n",
    "    F = tfl.Flatten()(P2)\n",
    "    ## Dense layer\n",
    "    ## 6 neurons in output layer. Hint: one of the arguments should be \"activation='softmax'\" \n",
    "    outputs = tfl.Dense(units=6, activation='softmax')(F)\n",
    "    # YOUR CODE STARTS HERE\n",
    "    \n",
    "    \n",
    "    # YOUR CODE ENDS HERE\n",
    "    model = tf.keras.Model(inputs=input_img, outputs=outputs)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "483d626949930a0b0ef20997e7c6ba72",
     "grade": true,
     "grade_id": "cell-45d22e92042174c9",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"functional_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_3 (InputLayer)         [(None, 64, 64, 3)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_14 (Conv2D)           (None, 64, 64, 8)         392       \n",
      "_________________________________________________________________\n",
      "re_lu_5 (ReLU)               (None, 64, 64, 8)         0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_13 (MaxPooling (None, 8, 8, 8)           0         \n",
      "_________________________________________________________________\n",
      "conv2d_15 (Conv2D)           (None, 8, 8, 16)          528       \n",
      "_________________________________________________________________\n",
      "re_lu_6 (ReLU)               (None, 8, 8, 16)          0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_14 (MaxPooling (None, 2, 2, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten_10 (Flatten)         (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 6)                 390       \n",
      "=================================================================\n",
      "Total params: 1,310\n",
      "Trainable params: 1,310\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "\u001b[32mAll tests passed!\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "conv_model = convolutional_model((64, 64, 3))\n",
    "conv_model.compile(optimizer='adam',\n",
    "                  loss='categorical_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "conv_model.summary()\n",
    "    \n",
    "output = [['InputLayer', [(None, 64, 64, 3)], 0],\n",
    "        ['Conv2D', (None, 64, 64, 8), 392, 'same', 'linear', 'GlorotUniform'],\n",
    "        ['ReLU', (None, 64, 64, 8), 0],\n",
    "        ['MaxPooling2D', (None, 8, 8, 8), 0, (8, 8), (8, 8), 'same'],\n",
    "        ['Conv2D', (None, 8, 8, 16), 528, 'same', 'linear', 'GlorotUniform'],\n",
    "        ['ReLU', (None, 8, 8, 16), 0],\n",
    "        ['MaxPooling2D', (None, 2, 2, 16), 0, (4, 4), (4, 4), 'same'],\n",
    "        ['Flatten', (None, 64), 0],\n",
    "        ['Dense', (None, 6), 390, 'softmax']]\n",
    "    \n",
    "comparator(summary(conv_model), output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both the Sequential and Functional APIs return a TF Keras model object. The only difference is how inputs are handled inside the object model! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-4'></a>\n",
    "### 4.4 - Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "17/17 [==============================] - 2s 108ms/step - loss: 1.8533 - accuracy: 0.1806 - val_loss: 1.7955 - val_accuracy: 0.1667\n",
      "Epoch 2/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7871 - accuracy: 0.1880 - val_loss: 1.7820 - val_accuracy: 0.2083\n",
      "Epoch 3/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7784 - accuracy: 0.2481 - val_loss: 1.7735 - val_accuracy: 0.2750\n",
      "Epoch 4/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.7709 - accuracy: 0.2407 - val_loss: 1.7650 - val_accuracy: 0.2750\n",
      "Epoch 5/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7628 - accuracy: 0.2676 - val_loss: 1.7578 - val_accuracy: 0.2417\n",
      "Epoch 6/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7537 - accuracy: 0.2852 - val_loss: 1.7490 - val_accuracy: 0.2917\n",
      "Epoch 7/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7432 - accuracy: 0.3306 - val_loss: 1.7372 - val_accuracy: 0.3000\n",
      "Epoch 8/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7307 - accuracy: 0.3463 - val_loss: 1.7249 - val_accuracy: 0.3083\n",
      "Epoch 9/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7161 - accuracy: 0.3704 - val_loss: 1.7084 - val_accuracy: 0.3417\n",
      "Epoch 10/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6982 - accuracy: 0.3824 - val_loss: 1.6891 - val_accuracy: 0.3333\n",
      "Epoch 11/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6772 - accuracy: 0.3991 - val_loss: 1.6677 - val_accuracy: 0.3417\n",
      "Epoch 12/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6539 - accuracy: 0.4185 - val_loss: 1.6444 - val_accuracy: 0.3833\n",
      "Epoch 13/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6270 - accuracy: 0.4352 - val_loss: 1.6166 - val_accuracy: 0.3750\n",
      "Epoch 14/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.5964 - accuracy: 0.4491 - val_loss: 1.5874 - val_accuracy: 0.3667\n",
      "Epoch 15/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 1.5637 - accuracy: 0.4657 - val_loss: 1.5582 - val_accuracy: 0.3750\n",
      "Epoch 16/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 1.5282 - accuracy: 0.4870 - val_loss: 1.5237 - val_accuracy: 0.4083\n",
      "Epoch 17/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.4889 - accuracy: 0.5056 - val_loss: 1.4900 - val_accuracy: 0.4250\n",
      "Epoch 18/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.4484 - accuracy: 0.5167 - val_loss: 1.4501 - val_accuracy: 0.4667\n",
      "Epoch 19/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.4046 - accuracy: 0.5333 - val_loss: 1.4147 - val_accuracy: 0.4583\n",
      "Epoch 20/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.3629 - accuracy: 0.5407 - val_loss: 1.3780 - val_accuracy: 0.4833\n",
      "Epoch 21/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.3215 - accuracy: 0.5556 - val_loss: 1.3413 - val_accuracy: 0.5000\n",
      "Epoch 22/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.2824 - accuracy: 0.5722 - val_loss: 1.3118 - val_accuracy: 0.4917\n",
      "Epoch 23/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.2468 - accuracy: 0.5870 - val_loss: 1.2788 - val_accuracy: 0.4833\n",
      "Epoch 24/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.2103 - accuracy: 0.6037 - val_loss: 1.2442 - val_accuracy: 0.5000\n",
      "Epoch 25/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.1766 - accuracy: 0.6083 - val_loss: 1.2137 - val_accuracy: 0.5167\n",
      "Epoch 26/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.1457 - accuracy: 0.6194 - val_loss: 1.1841 - val_accuracy: 0.5417\n",
      "Epoch 27/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1171 - accuracy: 0.6333 - val_loss: 1.1569 - val_accuracy: 0.5333\n",
      "Epoch 28/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0885 - accuracy: 0.6481 - val_loss: 1.1274 - val_accuracy: 0.5417\n",
      "Epoch 29/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0621 - accuracy: 0.6546 - val_loss: 1.1020 - val_accuracy: 0.5583\n",
      "Epoch 30/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0365 - accuracy: 0.6676 - val_loss: 1.0767 - val_accuracy: 0.5667\n",
      "Epoch 31/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0129 - accuracy: 0.6722 - val_loss: 1.0534 - val_accuracy: 0.5917\n",
      "Epoch 32/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9901 - accuracy: 0.6833 - val_loss: 1.0308 - val_accuracy: 0.6000\n",
      "Epoch 33/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.9682 - accuracy: 0.6880 - val_loss: 1.0094 - val_accuracy: 0.6083\n",
      "Epoch 34/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9480 - accuracy: 0.6963 - val_loss: 0.9883 - val_accuracy: 0.6333\n",
      "Epoch 35/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.9278 - accuracy: 0.7046 - val_loss: 0.9690 - val_accuracy: 0.6667\n",
      "Epoch 36/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.9095 - accuracy: 0.7139 - val_loss: 0.9499 - val_accuracy: 0.6750\n",
      "Epoch 37/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.8919 - accuracy: 0.7139 - val_loss: 0.9334 - val_accuracy: 0.6833\n",
      "Epoch 38/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.8757 - accuracy: 0.7241 - val_loss: 0.9162 - val_accuracy: 0.7000\n",
      "Epoch 39/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.8594 - accuracy: 0.7333 - val_loss: 0.9007 - val_accuracy: 0.6917\n",
      "Epoch 40/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8459 - accuracy: 0.7380 - val_loss: 0.8862 - val_accuracy: 0.7000\n",
      "Epoch 41/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8302 - accuracy: 0.7472 - val_loss: 0.8701 - val_accuracy: 0.7167\n",
      "Epoch 42/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.8164 - accuracy: 0.7546 - val_loss: 0.8538 - val_accuracy: 0.7083\n",
      "Epoch 43/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.8010 - accuracy: 0.7648 - val_loss: 0.8401 - val_accuracy: 0.7000\n",
      "Epoch 44/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.7884 - accuracy: 0.7648 - val_loss: 0.8280 - val_accuracy: 0.7083\n",
      "Epoch 45/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7748 - accuracy: 0.7676 - val_loss: 0.8145 - val_accuracy: 0.7083\n",
      "Epoch 46/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7629 - accuracy: 0.7713 - val_loss: 0.8023 - val_accuracy: 0.7000\n",
      "Epoch 47/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.7518 - accuracy: 0.7713 - val_loss: 0.7923 - val_accuracy: 0.7000\n",
      "Epoch 48/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.7403 - accuracy: 0.7796 - val_loss: 0.7807 - val_accuracy: 0.7167\n",
      "Epoch 49/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7301 - accuracy: 0.7778 - val_loss: 0.7699 - val_accuracy: 0.7167\n",
      "Epoch 50/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7200 - accuracy: 0.7815 - val_loss: 0.7602 - val_accuracy: 0.7167\n",
      "Epoch 51/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7100 - accuracy: 0.7843 - val_loss: 0.7497 - val_accuracy: 0.7167\n",
      "Epoch 52/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7006 - accuracy: 0.7870 - val_loss: 0.7409 - val_accuracy: 0.7167\n",
      "Epoch 53/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.6920 - accuracy: 0.7889 - val_loss: 0.7324 - val_accuracy: 0.7167\n",
      "Epoch 54/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.6836 - accuracy: 0.7926 - val_loss: 0.7241 - val_accuracy: 0.7167\n",
      "Epoch 55/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6752 - accuracy: 0.7944 - val_loss: 0.7161 - val_accuracy: 0.7167\n",
      "Epoch 56/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6674 - accuracy: 0.7963 - val_loss: 0.7085 - val_accuracy: 0.7250\n",
      "Epoch 57/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6600 - accuracy: 0.7972 - val_loss: 0.7015 - val_accuracy: 0.7250\n",
      "Epoch 58/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.6528 - accuracy: 0.8000 - val_loss: 0.6945 - val_accuracy: 0.7250\n",
      "Epoch 59/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6459 - accuracy: 0.8009 - val_loss: 0.6875 - val_accuracy: 0.7333\n",
      "Epoch 60/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6390 - accuracy: 0.8009 - val_loss: 0.6805 - val_accuracy: 0.7333\n",
      "Epoch 61/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.6327 - accuracy: 0.8019 - val_loss: 0.6739 - val_accuracy: 0.7333\n",
      "Epoch 62/100\n",
      "17/17 [==============================] - 2s 113ms/step - loss: 0.6264 - accuracy: 0.8019 - val_loss: 0.6678 - val_accuracy: 0.7333\n",
      "Epoch 63/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.6205 - accuracy: 0.8028 - val_loss: 0.6624 - val_accuracy: 0.7333\n",
      "Epoch 64/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.6144 - accuracy: 0.8046 - val_loss: 0.6562 - val_accuracy: 0.7417\n",
      "Epoch 65/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6086 - accuracy: 0.8037 - val_loss: 0.6508 - val_accuracy: 0.7500\n",
      "Epoch 66/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6031 - accuracy: 0.8065 - val_loss: 0.6452 - val_accuracy: 0.7417\n",
      "Epoch 67/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5974 - accuracy: 0.8056 - val_loss: 0.6402 - val_accuracy: 0.7500\n",
      "Epoch 68/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5921 - accuracy: 0.8065 - val_loss: 0.6350 - val_accuracy: 0.7583\n",
      "Epoch 69/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5871 - accuracy: 0.8074 - val_loss: 0.6305 - val_accuracy: 0.7583\n",
      "Epoch 70/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5819 - accuracy: 0.8111 - val_loss: 0.6255 - val_accuracy: 0.7583\n",
      "Epoch 71/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5769 - accuracy: 0.8120 - val_loss: 0.6207 - val_accuracy: 0.7500\n",
      "Epoch 72/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5720 - accuracy: 0.8139 - val_loss: 0.6159 - val_accuracy: 0.7500\n",
      "Epoch 73/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5674 - accuracy: 0.8148 - val_loss: 0.6112 - val_accuracy: 0.7500\n",
      "Epoch 74/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5627 - accuracy: 0.8148 - val_loss: 0.6073 - val_accuracy: 0.7500\n",
      "Epoch 75/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5583 - accuracy: 0.8157 - val_loss: 0.6033 - val_accuracy: 0.7500\n",
      "Epoch 76/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5541 - accuracy: 0.8148 - val_loss: 0.5987 - val_accuracy: 0.7500\n",
      "Epoch 77/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5498 - accuracy: 0.8157 - val_loss: 0.5947 - val_accuracy: 0.7500\n",
      "Epoch 78/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5458 - accuracy: 0.8167 - val_loss: 0.5905 - val_accuracy: 0.7500\n",
      "Epoch 79/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5419 - accuracy: 0.8176 - val_loss: 0.5869 - val_accuracy: 0.7500\n",
      "Epoch 80/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5378 - accuracy: 0.8176 - val_loss: 0.5829 - val_accuracy: 0.7500\n",
      "Epoch 81/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5341 - accuracy: 0.8213 - val_loss: 0.5790 - val_accuracy: 0.7583\n",
      "Epoch 82/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5301 - accuracy: 0.8213 - val_loss: 0.5753 - val_accuracy: 0.7583\n",
      "Epoch 83/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5262 - accuracy: 0.8222 - val_loss: 0.5719 - val_accuracy: 0.7583\n",
      "Epoch 84/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5226 - accuracy: 0.8231 - val_loss: 0.5686 - val_accuracy: 0.7583\n",
      "Epoch 85/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5190 - accuracy: 0.8241 - val_loss: 0.5649 - val_accuracy: 0.7750\n",
      "Epoch 86/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5155 - accuracy: 0.8250 - val_loss: 0.5614 - val_accuracy: 0.7750\n",
      "Epoch 87/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5118 - accuracy: 0.8278 - val_loss: 0.5578 - val_accuracy: 0.7750\n",
      "Epoch 88/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5081 - accuracy: 0.8278 - val_loss: 0.5554 - val_accuracy: 0.7750\n",
      "Epoch 89/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.5048 - accuracy: 0.8287 - val_loss: 0.5520 - val_accuracy: 0.7833\n",
      "Epoch 90/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5017 - accuracy: 0.8296 - val_loss: 0.5489 - val_accuracy: 0.7833\n",
      "Epoch 91/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4985 - accuracy: 0.8306 - val_loss: 0.5460 - val_accuracy: 0.7833\n",
      "Epoch 92/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4954 - accuracy: 0.8296 - val_loss: 0.5429 - val_accuracy: 0.7917\n",
      "Epoch 93/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4920 - accuracy: 0.8306 - val_loss: 0.5402 - val_accuracy: 0.7833\n",
      "Epoch 94/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.4889 - accuracy: 0.8324 - val_loss: 0.5373 - val_accuracy: 0.7833\n",
      "Epoch 95/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.4859 - accuracy: 0.8343 - val_loss: 0.5345 - val_accuracy: 0.7917\n",
      "Epoch 96/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4828 - accuracy: 0.8343 - val_loss: 0.5315 - val_accuracy: 0.7917\n",
      "Epoch 97/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.4796 - accuracy: 0.8352 - val_loss: 0.5284 - val_accuracy: 0.7917\n",
      "Epoch 98/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4766 - accuracy: 0.8343 - val_loss: 0.5251 - val_accuracy: 0.8000\n",
      "Epoch 99/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4735 - accuracy: 0.8333 - val_loss: 0.5218 - val_accuracy: 0.8000\n",
      "Epoch 100/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4704 - accuracy: 0.8370 - val_loss: 0.5190 - val_accuracy: 0.8000\n"
     ]
    }
   ],
   "source": [
    "train_dataset = tf.data.Dataset.from_tensor_slices((X_train, Y_train)).batch(64)\n",
    "test_dataset = tf.data.Dataset.from_tensor_slices((X_test, Y_test)).batch(64)\n",
    "history = conv_model.fit(train_dataset, epochs=100, validation_data=test_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='5'></a>\n",
    "## 5 - History Object \n",
    "\n",
    "The history object is an output of the `.fit()` operation, and provides a record of all the loss and metric values in memory. It's stored as a dictionary that you can retrieve at `history.history`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.8533127307891846,\n",
       "  1.7870854139328003,\n",
       "  1.7783982753753662,\n",
       "  1.7708640098571777,\n",
       "  1.7627638578414917,\n",
       "  1.7536652088165283,\n",
       "  1.743180274963379,\n",
       "  1.730667233467102,\n",
       "  1.7161026000976562,\n",
       "  1.6982371807098389,\n",
       "  1.6772135496139526,\n",
       "  1.6538790464401245,\n",
       "  1.626952886581421,\n",
       "  1.5963635444641113,\n",
       "  1.5636930465698242,\n",
       "  1.5281800031661987,\n",
       "  1.4889105558395386,\n",
       "  1.448406457901001,\n",
       "  1.4046334028244019,\n",
       "  1.3628515005111694,\n",
       "  1.3214666843414307,\n",
       "  1.2824286222457886,\n",
       "  1.2468243837356567,\n",
       "  1.2103140354156494,\n",
       "  1.1765509843826294,\n",
       "  1.1457394361495972,\n",
       "  1.1170628070831299,\n",
       "  1.0885142087936401,\n",
       "  1.0621176958084106,\n",
       "  1.0365315675735474,\n",
       "  1.0129011869430542,\n",
       "  0.990094006061554,\n",
       "  0.9681808948516846,\n",
       "  0.9479696750640869,\n",
       "  0.9278326034545898,\n",
       "  0.9095199108123779,\n",
       "  0.891910970211029,\n",
       "  0.8757330775260925,\n",
       "  0.8593580722808838,\n",
       "  0.8458781838417053,\n",
       "  0.8302127122879028,\n",
       "  0.8163806200027466,\n",
       "  0.8009768724441528,\n",
       "  0.7884421944618225,\n",
       "  0.7747886180877686,\n",
       "  0.7628806233406067,\n",
       "  0.7517611384391785,\n",
       "  0.7402938008308411,\n",
       "  0.7301439642906189,\n",
       "  0.7200248837471008,\n",
       "  0.7100251913070679,\n",
       "  0.7005794048309326,\n",
       "  0.6919810175895691,\n",
       "  0.6835758686065674,\n",
       "  0.6751785278320312,\n",
       "  0.667373776435852,\n",
       "  0.6599719524383545,\n",
       "  0.6528473496437073,\n",
       "  0.6459318399429321,\n",
       "  0.639045238494873,\n",
       "  0.6326912641525269,\n",
       "  0.626358151435852,\n",
       "  0.620543360710144,\n",
       "  0.6143825054168701,\n",
       "  0.6086271405220032,\n",
       "  0.6030628681182861,\n",
       "  0.5974368453025818,\n",
       "  0.5920614004135132,\n",
       "  0.5871219635009766,\n",
       "  0.5819299221038818,\n",
       "  0.5769443511962891,\n",
       "  0.5719678997993469,\n",
       "  0.5673826336860657,\n",
       "  0.5627332329750061,\n",
       "  0.5583151578903198,\n",
       "  0.5540506839752197,\n",
       "  0.5498075485229492,\n",
       "  0.5457550883293152,\n",
       "  0.5419117212295532,\n",
       "  0.5378395318984985,\n",
       "  0.534086287021637,\n",
       "  0.5301220417022705,\n",
       "  0.526164710521698,\n",
       "  0.522562563419342,\n",
       "  0.5189783573150635,\n",
       "  0.515494704246521,\n",
       "  0.5117610692977905,\n",
       "  0.5080661177635193,\n",
       "  0.5047930479049683,\n",
       "  0.5017099976539612,\n",
       "  0.49852070212364197,\n",
       "  0.49544045329093933,\n",
       "  0.4920198917388916,\n",
       "  0.4888986051082611,\n",
       "  0.48587289452552795,\n",
       "  0.48279255628585815,\n",
       "  0.4796135723590851,\n",
       "  0.47661346197128296,\n",
       "  0.4735026955604553,\n",
       "  0.47036823630332947],\n",
       " 'accuracy': [0.1805555522441864,\n",
       "  0.18796296417713165,\n",
       "  0.2481481432914734,\n",
       "  0.24074074625968933,\n",
       "  0.26759257912635803,\n",
       "  0.28518518805503845,\n",
       "  0.3305555582046509,\n",
       "  0.3462963104248047,\n",
       "  0.37037035822868347,\n",
       "  0.38240739703178406,\n",
       "  0.39907407760620117,\n",
       "  0.4185185134410858,\n",
       "  0.43518519401550293,\n",
       "  0.44907405972480774,\n",
       "  0.46574074029922485,\n",
       "  0.4870370328426361,\n",
       "  0.5055555701255798,\n",
       "  0.5166666507720947,\n",
       "  0.5333333611488342,\n",
       "  0.5407407283782959,\n",
       "  0.5555555820465088,\n",
       "  0.5722222328186035,\n",
       "  0.5870370268821716,\n",
       "  0.6037036776542664,\n",
       "  0.6083333492279053,\n",
       "  0.6194444298744202,\n",
       "  0.6333333253860474,\n",
       "  0.6481481194496155,\n",
       "  0.654629647731781,\n",
       "  0.6675925850868225,\n",
       "  0.6722221970558167,\n",
       "  0.6833333373069763,\n",
       "  0.6879629492759705,\n",
       "  0.6962962746620178,\n",
       "  0.7046296000480652,\n",
       "  0.7138888835906982,\n",
       "  0.7138888835906982,\n",
       "  0.7240740656852722,\n",
       "  0.7333333492279053,\n",
       "  0.7379629611968994,\n",
       "  0.7472222447395325,\n",
       "  0.7546296119689941,\n",
       "  0.7648147940635681,\n",
       "  0.7648147940635681,\n",
       "  0.7675926089286804,\n",
       "  0.7712963223457336,\n",
       "  0.7712963223457336,\n",
       "  0.779629647731781,\n",
       "  0.7777777910232544,\n",
       "  0.7814815044403076,\n",
       "  0.7842592597007751,\n",
       "  0.7870370149612427,\n",
       "  0.7888888716697693,\n",
       "  0.7925925850868225,\n",
       "  0.7944444417953491,\n",
       "  0.7962962985038757,\n",
       "  0.7972221970558167,\n",
       "  0.800000011920929,\n",
       "  0.8009259104728699,\n",
       "  0.8009259104728699,\n",
       "  0.8018518686294556,\n",
       "  0.8018518686294556,\n",
       "  0.8027777671813965,\n",
       "  0.8046296238899231,\n",
       "  0.8037037253379822,\n",
       "  0.8064814805984497,\n",
       "  0.8055555820465088,\n",
       "  0.8064814805984497,\n",
       "  0.8074073791503906,\n",
       "  0.8111110925674438,\n",
       "  0.8120370507240295,\n",
       "  0.8138889074325562,\n",
       "  0.8148148059844971,\n",
       "  0.8148148059844971,\n",
       "  0.8157407641410828,\n",
       "  0.8148148059844971,\n",
       "  0.8157407641410828,\n",
       "  0.8166666626930237,\n",
       "  0.8175926208496094,\n",
       "  0.8175926208496094,\n",
       "  0.8212962746620178,\n",
       "  0.8212962746620178,\n",
       "  0.8222222328186035,\n",
       "  0.8231481313705444,\n",
       "  0.8240740895271301,\n",
       "  0.824999988079071,\n",
       "  0.8277778029441833,\n",
       "  0.8277778029441833,\n",
       "  0.8287037014961243,\n",
       "  0.8296296000480652,\n",
       "  0.8305555582046509,\n",
       "  0.8296296000480652,\n",
       "  0.8305555582046509,\n",
       "  0.8324074149131775,\n",
       "  0.8342592716217041,\n",
       "  0.8342592716217041,\n",
       "  0.835185170173645,\n",
       "  0.8342592716217041,\n",
       "  0.8333333134651184,\n",
       "  0.8370370268821716],\n",
       " 'val_loss': [1.7955294847488403,\n",
       "  1.7819591760635376,\n",
       "  1.7734729051589966,\n",
       "  1.765036702156067,\n",
       "  1.7578125,\n",
       "  1.749040126800537,\n",
       "  1.7372326850891113,\n",
       "  1.724852204322815,\n",
       "  1.708351969718933,\n",
       "  1.6890507936477661,\n",
       "  1.6677323579788208,\n",
       "  1.644354224205017,\n",
       "  1.6165987253189087,\n",
       "  1.5874440670013428,\n",
       "  1.558245301246643,\n",
       "  1.5237101316452026,\n",
       "  1.489953875541687,\n",
       "  1.4500826597213745,\n",
       "  1.414685845375061,\n",
       "  1.3779990673065186,\n",
       "  1.341257095336914,\n",
       "  1.3118306398391724,\n",
       "  1.2787737846374512,\n",
       "  1.2442492246627808,\n",
       "  1.2136614322662354,\n",
       "  1.1841390132904053,\n",
       "  1.1569437980651855,\n",
       "  1.1274060010910034,\n",
       "  1.1019777059555054,\n",
       "  1.0767457485198975,\n",
       "  1.053423285484314,\n",
       "  1.0307804346084595,\n",
       "  1.0093554258346558,\n",
       "  0.9883300065994263,\n",
       "  0.9690428376197815,\n",
       "  0.9498676657676697,\n",
       "  0.9334166646003723,\n",
       "  0.9162381291389465,\n",
       "  0.9007274508476257,\n",
       "  0.8861508965492249,\n",
       "  0.8701300024986267,\n",
       "  0.8537629842758179,\n",
       "  0.8401304483413696,\n",
       "  0.8280372023582458,\n",
       "  0.8145135045051575,\n",
       "  0.8023180365562439,\n",
       "  0.79231858253479,\n",
       "  0.7807139754295349,\n",
       "  0.7699326872825623,\n",
       "  0.760245144367218,\n",
       "  0.7496693730354309,\n",
       "  0.7408915162086487,\n",
       "  0.7323541045188904,\n",
       "  0.7240666747093201,\n",
       "  0.7160510420799255,\n",
       "  0.708516538143158,\n",
       "  0.7015073895454407,\n",
       "  0.6944788694381714,\n",
       "  0.6874656081199646,\n",
       "  0.6805192232131958,\n",
       "  0.6738559603691101,\n",
       "  0.667758047580719,\n",
       "  0.6624235510826111,\n",
       "  0.6561747193336487,\n",
       "  0.6508222222328186,\n",
       "  0.6451927423477173,\n",
       "  0.6401723027229309,\n",
       "  0.63498854637146,\n",
       "  0.6305170655250549,\n",
       "  0.6255425214767456,\n",
       "  0.6206759810447693,\n",
       "  0.6158520579338074,\n",
       "  0.611242413520813,\n",
       "  0.6072724461555481,\n",
       "  0.60334712266922,\n",
       "  0.598673403263092,\n",
       "  0.5947150588035583,\n",
       "  0.5905171632766724,\n",
       "  0.5868940949440002,\n",
       "  0.5829204320907593,\n",
       "  0.5789833068847656,\n",
       "  0.5753155946731567,\n",
       "  0.5719060897827148,\n",
       "  0.568560779094696,\n",
       "  0.5648793578147888,\n",
       "  0.5613638758659363,\n",
       "  0.5578000545501709,\n",
       "  0.5553683042526245,\n",
       "  0.5519694089889526,\n",
       "  0.5489236116409302,\n",
       "  0.5460012555122375,\n",
       "  0.5428858995437622,\n",
       "  0.5401676297187805,\n",
       "  0.5372570157051086,\n",
       "  0.5345175266265869,\n",
       "  0.5315093398094177,\n",
       "  0.5283604264259338,\n",
       "  0.5251048803329468,\n",
       "  0.5217834115028381,\n",
       "  0.5190256834030151],\n",
       " 'val_accuracy': [0.1666666716337204,\n",
       "  0.2083333283662796,\n",
       "  0.2750000059604645,\n",
       "  0.2750000059604645,\n",
       "  0.24166665971279144,\n",
       "  0.2916666567325592,\n",
       "  0.30000001192092896,\n",
       "  0.3083333373069763,\n",
       "  0.34166666865348816,\n",
       "  0.3333333432674408,\n",
       "  0.34166666865348816,\n",
       "  0.38333332538604736,\n",
       "  0.375,\n",
       "  0.36666667461395264,\n",
       "  0.375,\n",
       "  0.40833333134651184,\n",
       "  0.42500001192092896,\n",
       "  0.46666666865348816,\n",
       "  0.4583333432674408,\n",
       "  0.4833333194255829,\n",
       "  0.5,\n",
       "  0.49166667461395264,\n",
       "  0.4833333194255829,\n",
       "  0.5,\n",
       "  0.5166666507720947,\n",
       "  0.5416666865348816,\n",
       "  0.5333333611488342,\n",
       "  0.5416666865348816,\n",
       "  0.5583333373069763,\n",
       "  0.5666666626930237,\n",
       "  0.5916666388511658,\n",
       "  0.6000000238418579,\n",
       "  0.6083333492279053,\n",
       "  0.6333333253860474,\n",
       "  0.6666666865348816,\n",
       "  0.675000011920929,\n",
       "  0.6833333373069763,\n",
       "  0.699999988079071,\n",
       "  0.6916666626930237,\n",
       "  0.699999988079071,\n",
       "  0.7166666388511658,\n",
       "  0.7083333134651184,\n",
       "  0.699999988079071,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.699999988079071,\n",
       "  0.699999988079071,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7416666746139526,\n",
       "  0.75,\n",
       "  0.7416666746139526,\n",
       "  0.75,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7749999761581421,\n",
       "  0.7749999761581421,\n",
       "  0.7749999761581421,\n",
       "  0.7749999761581421,\n",
       "  0.7833333611488342,\n",
       "  0.7833333611488342,\n",
       "  0.7833333611488342,\n",
       "  0.7916666865348816,\n",
       "  0.7833333611488342,\n",
       "  0.7833333611488342,\n",
       "  0.7916666865348816,\n",
       "  0.7916666865348816,\n",
       "  0.7916666865348816,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929]}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now visualize the loss over time using `history.history`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Accuracy'), Text(0.5, 0, 'Epoch')]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The history.history[\"loss\"] entry is a dictionary with as many values as epochs that the\n",
    "# model was trained on. \n",
    "df_loss_acc = pd.DataFrame(history.history)\n",
    "df_loss= df_loss_acc[['loss','val_loss']]\n",
    "df_loss.rename(columns={'loss':'train','val_loss':'validation'},inplace=True)\n",
    "df_acc= df_loss_acc[['accuracy','val_accuracy']]\n",
    "df_acc.rename(columns={'accuracy':'train','val_accuracy':'validation'},inplace=True)\n",
    "df_loss.plot(title='Model loss',figsize=(12,8)).set(xlabel='Epoch',ylabel='Loss')\n",
    "df_acc.plot(title='Model Accuracy',figsize=(12,8)).set(xlabel='Epoch',ylabel='Accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations**! You've finished the assignment and built two models: One that recognizes  smiles, and another that recognizes SIGN language with almost 80% accuracy on the test set. In addition to that, you now also understand the applications of two Keras APIs: Sequential and Functional. Nicely done! \n",
    "\n",
    "By now, you know a bit about how the Functional API works and may have glimpsed the possibilities. In your next assignment, you'll really get a feel for its power when you get the opportunity to build a very deep ConvNet, using ResNets! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='6'></a>\n",
    "## 6 - Bibliography\n",
    "\n",
    "You're always encouraged to read the official documentation. To that end, you can find the docs for the Sequential and Functional APIs here: \n",
    "\n",
    "https://www.tensorflow.org/guide/keras/sequential_model\n",
    "\n",
    "https://www.tensorflow.org/guide/keras/functional"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "convolutional-neural-networks",
   "graded_item_id": "bwbJV",
   "launcher_item_id": "0TkXB"
  },
  "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": 2
}