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**\").\n",
    "\n",
    "## Important Note on Submission to the AutoGrader\n",
    "\n",
    "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n",
    "\n",
    "1. You have not added any _extra_ `print` statement(s) in the assignment.\n",
    "2. You have not added any _extra_ code cell(s) in the assignment.\n",
    "3. You have not changed any of the function parameters.\n",
    "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n",
    "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n",
    "\n",
    "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/convolutional-neural-networks/supplement/DS4yP/h-ow-to-refresh-your-workspace)."
   ]
  },
  {
   "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": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "### v1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 3,
   "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": 4,
   "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": 17,
   "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",
    "            \n",
    "            ## Conv2D with 32 7x7 filters and stride of 1\n",
    "            \n",
    "            ## BatchNormalization for axis 3\n",
    "            \n",
    "            ## ReLU\n",
    "            \n",
    "            ## Max Pooling 2D with default parameters\n",
    "            \n",
    "            ## Flatten layer\n",
    "            \n",
    "            ## Dense layer with 1 unit for output & 'sigmoid' activation\n",
    "            \n",
    "            # YOUR CODE STARTS HERE\n",
    "            \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(\n",
    "                filters=32,\n",
    "                kernel_size=(7, 7),\n",
    "                strides=(1, 1),\n",
    "                padding='valid'\n",
    "            ),\n",
    "            \n",
    "            ## BatchNormalization for axis 3\n",
    "            tfl.BatchNormalization(\n",
    "                axis=3\n",
    "            ),\n",
    "            ## ReLU\n",
    "            tfl.ReLU(\n",
    "                max_value=None, negative_slope=0.0, threshold=0.0\n",
    "            ),\n",
    "            ## Max Pooling 2D with default parameters\n",
    "            tfl.MaxPool2D(\n",
    "                pool_size=(2, 2),\n",
    "                strides=None,\n",
    "                padding='valid',\n",
    "                data_format=None,\n",
    "                name=None\n",
    "            ),\n",
    "            ## Flatten layer\n",
    "            tfl.Flatten(\n",
    "                data_format=None\n",
    "            ),\n",
    "        \n",
    "            ## Dense layer with 1 unit for output & 'sigmoid' activation\n",
    "            tfl.Dense(\n",
    "                units=1,\n",
    "                activation='sigmoid'\n",
    "            )\n",
    "            \n",
    "            # YOUR CODE ENDS HERE\n",
    "        ])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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": [
    "#### Expected Output:\n",
    "\n",
    "```\n",
    "['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",
    "All tests passed!\n",
    "```"
   ]
  },
  {
   "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": 19,
   "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": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "zero_padding2d_1 (ZeroPaddin (None, 70, 70, 3)         0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 64, 64, 32)        4736      \n",
      "_________________________________________________________________\n",
      "batch_normalization_1 (Batch (None, 64, 64, 32)        128       \n",
      "_________________________________________________________________\n",
      "re_lu_1 (ReLU)               (None, 64, 64, 32)        0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 32, 32, 32)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 32768)             0         \n",
      "_________________________________________________________________\n",
      "dense_1 (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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.9463 - accuracy: 0.7600\n",
      "Epoch 2/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.1992 - accuracy: 0.9150\n",
      "Epoch 3/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.1124 - accuracy: 0.9650\n",
      "Epoch 4/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.1418 - accuracy: 0.9517\n",
      "Epoch 5/10\n",
      "38/38 [==============================] - 4s 92ms/step - loss: 0.0990 - accuracy: 0.9683\n",
      "Epoch 6/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.0849 - accuracy: 0.9617\n",
      "Epoch 7/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.0738 - accuracy: 0.9750\n",
      "Epoch 8/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.0852 - accuracy: 0.9700\n",
      "Epoch 9/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.1537 - accuracy: 0.9433\n",
      "Epoch 10/10\n",
      "38/38 [==============================] - 4s 92ms/step - loss: 0.1527 - accuracy: 0.9517\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7940b0a30510>"
      ]
     },
     "execution_count": 21,
     "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": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 0s 35ms/step - loss: 0.3506 - accuracy: 0.8533\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.3506492078304291, 0.8533333539962769]"
      ]
     },
     "execution_count": 22,
     "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": 23,
   "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": 24,
   "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": 25,
   "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": 36,
   "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 = None\n",
    "    ## RELU\n",
    "    # A1 = None\n",
    "    ## MAXPOOL: window 8x8, stride 8, padding 'SAME'\n",
    "    # P1 = None\n",
    "    ## CONV2D: 16 filters 2x2, stride 1, padding 'SAME'\n",
    "    # Z2 = None\n",
    "    ## RELU\n",
    "    # A2 = None\n",
    "    ## MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    # P2 = None\n",
    "    ## FLATTEN\n",
    "    # F = None\n",
    "    ## Dense layer\n",
    "    ## 6 neurons in output layer. Hint: one of the arguments should be \"activation='softmax'\" \n",
    "    # outputs = None\n",
    "    # YOUR CODE STARTS HERE\n",
    "    \n",
    "    ## CONV2D: 8 filters 4x4, stride of 1, padding 'SAME'\n",
    "    Z1 = tfl.Conv2D(\n",
    "                filters=8,\n",
    "                kernel_size=(4, 4),\n",
    "                strides=(1, 1),\n",
    "                padding='same'\n",
    "                )(input_img)\n",
    "    \n",
    "    ## RELU\n",
    "    A1 = tfl.ReLU()(Z1)\n",
    "    \n",
    "    ## MAXPOOL: window 8x8, stride 8, padding 'SAME'\n",
    "    P1 = tfl.MaxPool2D(\n",
    "                pool_size=(8, 8),\n",
    "                strides=8,\n",
    "                padding='same'\n",
    "                )(A1)\n",
    "    \n",
    "    ## CONV2D: 16 filters 2x2, stride 1, padding 'SAME'\n",
    "    Z2 = tfl.Conv2D(\n",
    "                filters=16,\n",
    "                kernel_size=(2, 2),\n",
    "                strides=(1, 1),\n",
    "                padding='same'\n",
    "                )(P1)\n",
    "    \n",
    "    ## RELU\n",
    "    A2 = tfl.ReLU()(Z2)\n",
    "    \n",
    "    ## MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2 = tfl.MaxPool2D(\n",
    "                pool_size=(4, 4),\n",
    "                strides=4,\n",
    "                padding='same'\n",
    "                )(A2)\n",
    "    \n",
    "    ## FLATTEN\n",
    "    F = tfl.Flatten()(P2)\n",
    "    \n",
    "    ## Dense layer\n",
    "    ## 6 neurons in output layer. Hint: one of the arguments should be \"activation='softmax'\" \n",
    "    outputs = tfl.Dense(\n",
    "                units=6,\n",
    "                activation='softmax'\n",
    "                )(F)\n",
    "    \n",
    "    # YOUR CODE ENDS HERE\n",
    "    model = tf.keras.Model(inputs=input_img, outputs=outputs)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "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_3\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_5 (InputLayer)         [(None, 64, 64, 3)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_10 (Conv2D)           (None, 64, 64, 8)         392       \n",
      "_________________________________________________________________\n",
      "re_lu_10 (ReLU)              (None, 64, 64, 8)         0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_10 (MaxPooling (None, 8, 8, 8)           0         \n",
      "_________________________________________________________________\n",
      "conv2d_11 (Conv2D)           (None, 8, 8, 16)          528       \n",
      "_________________________________________________________________\n",
      "re_lu_11 (ReLU)              (None, 8, 8, 16)          0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_11 (MaxPooling (None, 2, 2, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten_6 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_5 (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": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.8642 - accuracy: 0.1954 - val_loss: 1.7965 - val_accuracy: 0.1917\n",
      "Epoch 2/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7863 - accuracy: 0.2306 - val_loss: 1.7802 - val_accuracy: 0.2667\n",
      "Epoch 3/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.7730 - accuracy: 0.2407 - val_loss: 1.7724 - val_accuracy: 0.2750\n",
      "Epoch 4/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7647 - accuracy: 0.2769 - val_loss: 1.7667 - val_accuracy: 0.3417\n",
      "Epoch 5/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7579 - accuracy: 0.3157 - val_loss: 1.7613 - val_accuracy: 0.3333\n",
      "Epoch 6/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.7503 - accuracy: 0.3204 - val_loss: 1.7545 - val_accuracy: 0.3500\n",
      "Epoch 7/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7405 - accuracy: 0.3380 - val_loss: 1.7464 - val_accuracy: 0.3583\n",
      "Epoch 8/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.7274 - accuracy: 0.3509 - val_loss: 1.7357 - val_accuracy: 0.3417\n",
      "Epoch 9/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7109 - accuracy: 0.3667 - val_loss: 1.7227 - val_accuracy: 0.3667\n",
      "Epoch 10/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.6894 - accuracy: 0.4056 - val_loss: 1.7076 - val_accuracy: 0.3500\n",
      "Epoch 11/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6649 - accuracy: 0.4389 - val_loss: 1.6894 - val_accuracy: 0.3667\n",
      "Epoch 12/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6362 - accuracy: 0.4602 - val_loss: 1.6688 - val_accuracy: 0.3917\n",
      "Epoch 13/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6036 - accuracy: 0.4685 - val_loss: 1.6458 - val_accuracy: 0.4083\n",
      "Epoch 14/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.5686 - accuracy: 0.4852 - val_loss: 1.6209 - val_accuracy: 0.4250\n",
      "Epoch 15/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.5317 - accuracy: 0.4963 - val_loss: 1.5918 - val_accuracy: 0.4250\n",
      "Epoch 16/100\n",
      "17/17 [==============================] - 2s 105ms/step - loss: 1.4928 - accuracy: 0.5074 - val_loss: 1.5602 - val_accuracy: 0.4417\n",
      "Epoch 17/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.4534 - accuracy: 0.5056 - val_loss: 1.5304 - val_accuracy: 0.4500\n",
      "Epoch 18/100\n",
      "17/17 [==============================] - 2s 105ms/step - loss: 1.4169 - accuracy: 0.5148 - val_loss: 1.4986 - val_accuracy: 0.4500\n",
      "Epoch 19/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.3821 - accuracy: 0.5287 - val_loss: 1.4661 - val_accuracy: 0.4583\n",
      "Epoch 20/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.3461 - accuracy: 0.5491 - val_loss: 1.4336 - val_accuracy: 0.4333\n",
      "Epoch 21/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.3129 - accuracy: 0.5583 - val_loss: 1.4012 - val_accuracy: 0.4917\n",
      "Epoch 22/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.2796 - accuracy: 0.5722 - val_loss: 1.3731 - val_accuracy: 0.4917\n",
      "Epoch 23/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.2483 - accuracy: 0.5750 - val_loss: 1.3434 - val_accuracy: 0.5250\n",
      "Epoch 24/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.2180 - accuracy: 0.5824 - val_loss: 1.3124 - val_accuracy: 0.5167\n",
      "Epoch 25/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1869 - accuracy: 0.6019 - val_loss: 1.2816 - val_accuracy: 0.5083\n",
      "Epoch 26/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1574 - accuracy: 0.6204 - val_loss: 1.2500 - val_accuracy: 0.5417\n",
      "Epoch 27/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1297 - accuracy: 0.6250 - val_loss: 1.2216 - val_accuracy: 0.5417\n",
      "Epoch 28/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1025 - accuracy: 0.6398 - val_loss: 1.1946 - val_accuracy: 0.5417\n",
      "Epoch 29/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0753 - accuracy: 0.6500 - val_loss: 1.1669 - val_accuracy: 0.5583\n",
      "Epoch 30/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0505 - accuracy: 0.6639 - val_loss: 1.1411 - val_accuracy: 0.5583\n",
      "Epoch 31/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0254 - accuracy: 0.6722 - val_loss: 1.1154 - val_accuracy: 0.5667\n",
      "Epoch 32/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0013 - accuracy: 0.6815 - val_loss: 1.0905 - val_accuracy: 0.5667\n",
      "Epoch 33/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.9798 - accuracy: 0.6880 - val_loss: 1.0674 - val_accuracy: 0.5750\n",
      "Epoch 34/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9572 - accuracy: 0.6935 - val_loss: 1.0447 - val_accuracy: 0.5917\n",
      "Epoch 35/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9374 - accuracy: 0.7009 - val_loss: 1.0231 - val_accuracy: 0.5917\n",
      "Epoch 36/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9171 - accuracy: 0.7074 - val_loss: 1.0039 - val_accuracy: 0.5917\n",
      "Epoch 37/100\n",
      "17/17 [==============================] - 2s 101ms/step - loss: 0.8983 - accuracy: 0.7139 - val_loss: 0.9846 - val_accuracy: 0.5750\n",
      "Epoch 38/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8796 - accuracy: 0.7148 - val_loss: 0.9661 - val_accuracy: 0.5833\n",
      "Epoch 39/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.8627 - accuracy: 0.7176 - val_loss: 0.9485 - val_accuracy: 0.6250\n",
      "Epoch 40/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8450 - accuracy: 0.7241 - val_loss: 0.9328 - val_accuracy: 0.6250\n",
      "Epoch 41/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8295 - accuracy: 0.7296 - val_loss: 0.9172 - val_accuracy: 0.6417\n",
      "Epoch 42/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8139 - accuracy: 0.7306 - val_loss: 0.9020 - val_accuracy: 0.6500\n",
      "Epoch 43/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.7991 - accuracy: 0.7370 - val_loss: 0.8881 - val_accuracy: 0.6417\n",
      "Epoch 44/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7854 - accuracy: 0.7417 - val_loss: 0.8738 - val_accuracy: 0.6250\n",
      "Epoch 45/100\n",
      "17/17 [==============================] - 2s 102ms/step - loss: 0.7724 - accuracy: 0.7509 - val_loss: 0.8606 - val_accuracy: 0.6417\n",
      "Epoch 46/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7591 - accuracy: 0.7574 - val_loss: 0.8481 - val_accuracy: 0.6500\n",
      "Epoch 47/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.7463 - accuracy: 0.7611 - val_loss: 0.8356 - val_accuracy: 0.6583\n",
      "Epoch 48/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7341 - accuracy: 0.7667 - val_loss: 0.8243 - val_accuracy: 0.6750\n",
      "Epoch 49/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7227 - accuracy: 0.7713 - val_loss: 0.8125 - val_accuracy: 0.6833\n",
      "Epoch 50/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.7109 - accuracy: 0.7796 - val_loss: 0.8001 - val_accuracy: 0.7000\n",
      "Epoch 51/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6996 - accuracy: 0.7815 - val_loss: 0.7900 - val_accuracy: 0.7083\n",
      "Epoch 52/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6889 - accuracy: 0.7861 - val_loss: 0.7793 - val_accuracy: 0.7083\n",
      "Epoch 53/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6784 - accuracy: 0.7898 - val_loss: 0.7690 - val_accuracy: 0.7083\n",
      "Epoch 54/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6680 - accuracy: 0.7926 - val_loss: 0.7592 - val_accuracy: 0.7083\n",
      "Epoch 55/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6579 - accuracy: 0.7935 - val_loss: 0.7493 - val_accuracy: 0.7083\n",
      "Epoch 56/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6482 - accuracy: 0.7981 - val_loss: 0.7411 - val_accuracy: 0.7083\n",
      "Epoch 57/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6388 - accuracy: 0.8028 - val_loss: 0.7320 - val_accuracy: 0.7167\n",
      "Epoch 58/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6292 - accuracy: 0.8037 - val_loss: 0.7228 - val_accuracy: 0.7167\n",
      "Epoch 59/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6203 - accuracy: 0.8065 - val_loss: 0.7144 - val_accuracy: 0.7250\n",
      "Epoch 60/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6112 - accuracy: 0.8120 - val_loss: 0.7063 - val_accuracy: 0.7333\n",
      "Epoch 61/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6026 - accuracy: 0.8139 - val_loss: 0.6971 - val_accuracy: 0.7333\n",
      "Epoch 62/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5942 - accuracy: 0.8185 - val_loss: 0.6891 - val_accuracy: 0.7333\n",
      "Epoch 63/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5861 - accuracy: 0.8231 - val_loss: 0.6812 - val_accuracy: 0.7333\n",
      "Epoch 64/100\n",
      "17/17 [==============================] - 2s 101ms/step - loss: 0.5782 - accuracy: 0.8241 - val_loss: 0.6742 - val_accuracy: 0.7333\n",
      "Epoch 65/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5702 - accuracy: 0.8278 - val_loss: 0.6660 - val_accuracy: 0.7333\n",
      "Epoch 66/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5620 - accuracy: 0.8315 - val_loss: 0.6586 - val_accuracy: 0.7333\n",
      "Epoch 67/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5549 - accuracy: 0.8333 - val_loss: 0.6517 - val_accuracy: 0.7417\n",
      "Epoch 68/100\n",
      "17/17 [==============================] - 2s 101ms/step - loss: 0.5472 - accuracy: 0.8361 - val_loss: 0.6439 - val_accuracy: 0.7417\n",
      "Epoch 69/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5398 - accuracy: 0.8380 - val_loss: 0.6376 - val_accuracy: 0.7500\n",
      "Epoch 70/100\n",
      "17/17 [==============================] - 2s 101ms/step - loss: 0.5321 - accuracy: 0.8389 - val_loss: 0.6313 - val_accuracy: 0.7583\n",
      "Epoch 71/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5252 - accuracy: 0.8398 - val_loss: 0.6255 - val_accuracy: 0.7583\n",
      "Epoch 72/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5185 - accuracy: 0.8417 - val_loss: 0.6191 - val_accuracy: 0.7583\n",
      "Epoch 73/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5118 - accuracy: 0.8435 - val_loss: 0.6149 - val_accuracy: 0.7667\n",
      "Epoch 74/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5048 - accuracy: 0.8491 - val_loss: 0.6090 - val_accuracy: 0.7667\n",
      "Epoch 75/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4988 - accuracy: 0.8463 - val_loss: 0.6032 - val_accuracy: 0.7833\n",
      "Epoch 76/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4926 - accuracy: 0.8500 - val_loss: 0.5992 - val_accuracy: 0.7750\n",
      "Epoch 77/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4864 - accuracy: 0.8509 - val_loss: 0.5942 - val_accuracy: 0.7833\n",
      "Epoch 78/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4804 - accuracy: 0.8546 - val_loss: 0.5886 - val_accuracy: 0.7833\n",
      "Epoch 79/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4746 - accuracy: 0.8565 - val_loss: 0.5840 - val_accuracy: 0.7917\n",
      "Epoch 80/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.4690 - accuracy: 0.8574 - val_loss: 0.5806 - val_accuracy: 0.8000\n",
      "Epoch 81/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.4635 - accuracy: 0.8602 - val_loss: 0.5757 - val_accuracy: 0.8000\n",
      "Epoch 82/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4571 - accuracy: 0.8611 - val_loss: 0.5718 - val_accuracy: 0.8000\n",
      "Epoch 83/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4523 - accuracy: 0.8630 - val_loss: 0.5682 - val_accuracy: 0.8000\n",
      "Epoch 84/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4468 - accuracy: 0.8639 - val_loss: 0.5639 - val_accuracy: 0.8000\n",
      "Epoch 85/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4412 - accuracy: 0.8676 - val_loss: 0.5610 - val_accuracy: 0.8000\n",
      "Epoch 86/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.4364 - accuracy: 0.8667 - val_loss: 0.5571 - val_accuracy: 0.8000\n",
      "Epoch 87/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4311 - accuracy: 0.8704 - val_loss: 0.5538 - val_accuracy: 0.8000\n",
      "Epoch 88/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.4266 - accuracy: 0.8694 - val_loss: 0.5487 - val_accuracy: 0.8000\n",
      "Epoch 89/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4207 - accuracy: 0.8750 - val_loss: 0.5450 - val_accuracy: 0.8000\n",
      "Epoch 90/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4167 - accuracy: 0.8713 - val_loss: 0.5418 - val_accuracy: 0.8000\n",
      "Epoch 91/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4114 - accuracy: 0.8750 - val_loss: 0.5388 - val_accuracy: 0.8000\n",
      "Epoch 92/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4072 - accuracy: 0.8787 - val_loss: 0.5353 - val_accuracy: 0.8083\n",
      "Epoch 93/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4021 - accuracy: 0.8796 - val_loss: 0.5324 - val_accuracy: 0.8083\n",
      "Epoch 94/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.3981 - accuracy: 0.8796 - val_loss: 0.5294 - val_accuracy: 0.8083\n",
      "Epoch 95/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3932 - accuracy: 0.8806 - val_loss: 0.5290 - val_accuracy: 0.8083\n",
      "Epoch 96/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3893 - accuracy: 0.8824 - val_loss: 0.5238 - val_accuracy: 0.8083\n",
      "Epoch 97/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3845 - accuracy: 0.8861 - val_loss: 0.5210 - val_accuracy: 0.8083\n",
      "Epoch 98/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3811 - accuracy: 0.8870 - val_loss: 0.5187 - val_accuracy: 0.8083\n",
      "Epoch 99/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3767 - accuracy: 0.8907 - val_loss: 0.5163 - val_accuracy: 0.8083\n",
      "Epoch 100/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3729 - accuracy: 0.8935 - val_loss: 0.5149 - val_accuracy: 0.8083\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": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.8641932010650635,\n",
       "  1.786259651184082,\n",
       "  1.7729789018630981,\n",
       "  1.7646965980529785,\n",
       "  1.7578508853912354,\n",
       "  1.750253438949585,\n",
       "  1.7405191659927368,\n",
       "  1.727419137954712,\n",
       "  1.710869550704956,\n",
       "  1.6894288063049316,\n",
       "  1.6648812294006348,\n",
       "  1.6361651420593262,\n",
       "  1.603553295135498,\n",
       "  1.5686129331588745,\n",
       "  1.5317213535308838,\n",
       "  1.4928429126739502,\n",
       "  1.4534437656402588,\n",
       "  1.4169409275054932,\n",
       "  1.382072925567627,\n",
       "  1.3460623025894165,\n",
       "  1.312904715538025,\n",
       "  1.2795991897583008,\n",
       "  1.248252272605896,\n",
       "  1.2180403470993042,\n",
       "  1.186899185180664,\n",
       "  1.1574428081512451,\n",
       "  1.1296669244766235,\n",
       "  1.1024725437164307,\n",
       "  1.0753371715545654,\n",
       "  1.0504754781723022,\n",
       "  1.025441288948059,\n",
       "  1.0013484954833984,\n",
       "  0.9798114895820618,\n",
       "  0.957234799861908,\n",
       "  0.9373780488967896,\n",
       "  0.917104184627533,\n",
       "  0.8982904553413391,\n",
       "  0.8796076774597168,\n",
       "  0.862723171710968,\n",
       "  0.845047116279602,\n",
       "  0.8295180201530457,\n",
       "  0.8138618469238281,\n",
       "  0.7990612983703613,\n",
       "  0.785383403301239,\n",
       "  0.7723829746246338,\n",
       "  0.7591096758842468,\n",
       "  0.7463192939758301,\n",
       "  0.7340965270996094,\n",
       "  0.722732663154602,\n",
       "  0.7108646035194397,\n",
       "  0.6996496319770813,\n",
       "  0.688925564289093,\n",
       "  0.6783546805381775,\n",
       "  0.6679698824882507,\n",
       "  0.657924473285675,\n",
       "  0.6481576561927795,\n",
       "  0.638765275478363,\n",
       "  0.6291698217391968,\n",
       "  0.6202954649925232,\n",
       "  0.6111711263656616,\n",
       "  0.6025853753089905,\n",
       "  0.5942215919494629,\n",
       "  0.5860615372657776,\n",
       "  0.5782095193862915,\n",
       "  0.570207417011261,\n",
       "  0.5620072484016418,\n",
       "  0.5548596382141113,\n",
       "  0.5471681356430054,\n",
       "  0.5398092269897461,\n",
       "  0.5320659279823303,\n",
       "  0.525172770023346,\n",
       "  0.5184502005577087,\n",
       "  0.511825442314148,\n",
       "  0.5047699809074402,\n",
       "  0.4987697899341583,\n",
       "  0.4925796091556549,\n",
       "  0.4863904118537903,\n",
       "  0.48044976592063904,\n",
       "  0.4745617210865021,\n",
       "  0.4690248966217041,\n",
       "  0.4634934365749359,\n",
       "  0.45710188150405884,\n",
       "  0.45228397846221924,\n",
       "  0.4468076527118683,\n",
       "  0.44123488664627075,\n",
       "  0.4364108145236969,\n",
       "  0.43114498257637024,\n",
       "  0.4266207218170166,\n",
       "  0.42070844769477844,\n",
       "  0.4166785180568695,\n",
       "  0.4113605320453644,\n",
       "  0.4071948528289795,\n",
       "  0.4021291136741638,\n",
       "  0.39807403087615967,\n",
       "  0.39318323135375977,\n",
       "  0.38933083415031433,\n",
       "  0.38447535037994385,\n",
       "  0.3810907304286957,\n",
       "  0.376697838306427,\n",
       "  0.37285032868385315],\n",
       " 'accuracy': [0.1953703761100769,\n",
       "  0.23055554926395416,\n",
       "  0.24074074625968933,\n",
       "  0.2768518626689911,\n",
       "  0.3157407343387604,\n",
       "  0.3203703761100769,\n",
       "  0.33796295523643494,\n",
       "  0.35092592239379883,\n",
       "  0.36666667461395264,\n",
       "  0.4055555462837219,\n",
       "  0.43888887763023376,\n",
       "  0.4601851999759674,\n",
       "  0.46851852536201477,\n",
       "  0.4851851761341095,\n",
       "  0.4962962865829468,\n",
       "  0.5074074268341064,\n",
       "  0.5055555701255798,\n",
       "  0.5148147940635681,\n",
       "  0.5287036895751953,\n",
       "  0.5490740537643433,\n",
       "  0.5583333373069763,\n",
       "  0.5722222328186035,\n",
       "  0.574999988079071,\n",
       "  0.5824074149131775,\n",
       "  0.6018518805503845,\n",
       "  0.6203703880310059,\n",
       "  0.625,\n",
       "  0.6398147940635681,\n",
       "  0.6499999761581421,\n",
       "  0.6638888716697693,\n",
       "  0.6722221970558167,\n",
       "  0.6814814805984497,\n",
       "  0.6879629492759705,\n",
       "  0.6935185194015503,\n",
       "  0.7009259462356567,\n",
       "  0.7074074149131775,\n",
       "  0.7138888835906982,\n",
       "  0.7148148417472839,\n",
       "  0.7175925970077515,\n",
       "  0.7240740656852722,\n",
       "  0.729629635810852,\n",
       "  0.730555534362793,\n",
       "  0.7370370626449585,\n",
       "  0.7416666746139526,\n",
       "  0.7509258985519409,\n",
       "  0.7574074268341064,\n",
       "  0.7611111402511597,\n",
       "  0.7666666507720947,\n",
       "  0.7712963223457336,\n",
       "  0.779629647731781,\n",
       "  0.7814815044403076,\n",
       "  0.7861111164093018,\n",
       "  0.789814829826355,\n",
       "  0.7925925850868225,\n",
       "  0.7935185432434082,\n",
       "  0.7981481552124023,\n",
       "  0.8027777671813965,\n",
       "  0.8037037253379822,\n",
       "  0.8064814805984497,\n",
       "  0.8120370507240295,\n",
       "  0.8138889074325562,\n",
       "  0.8185185194015503,\n",
       "  0.8231481313705444,\n",
       "  0.8240740895271301,\n",
       "  0.8277778029441833,\n",
       "  0.8314814567565918,\n",
       "  0.8333333134651184,\n",
       "  0.8361111283302307,\n",
       "  0.8379629850387573,\n",
       "  0.8388888835906982,\n",
       "  0.8398148417472839,\n",
       "  0.8416666388511658,\n",
       "  0.8435184955596924,\n",
       "  0.8490740656852722,\n",
       "  0.8462963104248047,\n",
       "  0.8500000238418579,\n",
       "  0.8509259223937988,\n",
       "  0.854629635810852,\n",
       "  0.8564814925193787,\n",
       "  0.8574073910713196,\n",
       "  0.8601852059364319,\n",
       "  0.8611111044883728,\n",
       "  0.8629629611968994,\n",
       "  0.8638888597488403,\n",
       "  0.8675925731658936,\n",
       "  0.8666666746139526,\n",
       "  0.8703703880310059,\n",
       "  0.8694444298744202,\n",
       "  0.875,\n",
       "  0.8712962865829468,\n",
       "  0.875,\n",
       "  0.8787037134170532,\n",
       "  0.8796296119689941,\n",
       "  0.8796296119689941,\n",
       "  0.8805555701255798,\n",
       "  0.8824074268341064,\n",
       "  0.8861111402511597,\n",
       "  0.8870370388031006,\n",
       "  0.8907407522201538,\n",
       "  0.8935185074806213],\n",
       " 'val_loss': [1.7964694499969482,\n",
       "  1.7802491188049316,\n",
       "  1.7724156379699707,\n",
       "  1.7667351961135864,\n",
       "  1.7612780332565308,\n",
       "  1.7544571161270142,\n",
       "  1.7463957071304321,\n",
       "  1.7357099056243896,\n",
       "  1.722666621208191,\n",
       "  1.7075899839401245,\n",
       "  1.6894105672836304,\n",
       "  1.6688138246536255,\n",
       "  1.645785927772522,\n",
       "  1.6209427118301392,\n",
       "  1.591778039932251,\n",
       "  1.5602163076400757,\n",
       "  1.5303813219070435,\n",
       "  1.4986103773117065,\n",
       "  1.4660987854003906,\n",
       "  1.4336432218551636,\n",
       "  1.40115225315094,\n",
       "  1.3731335401535034,\n",
       "  1.3434042930603027,\n",
       "  1.3123888969421387,\n",
       "  1.28164803981781,\n",
       "  1.2499504089355469,\n",
       "  1.2215813398361206,\n",
       "  1.1945592164993286,\n",
       "  1.1668983697891235,\n",
       "  1.1410791873931885,\n",
       "  1.1153923273086548,\n",
       "  1.0904771089553833,\n",
       "  1.0673762559890747,\n",
       "  1.0446889400482178,\n",
       "  1.023098349571228,\n",
       "  1.0038965940475464,\n",
       "  0.9846119284629822,\n",
       "  0.9660955667495728,\n",
       "  0.9485304355621338,\n",
       "  0.9328174591064453,\n",
       "  0.9171756505966187,\n",
       "  0.901950478553772,\n",
       "  0.8880776166915894,\n",
       "  0.8737577795982361,\n",
       "  0.8605507612228394,\n",
       "  0.8480927348136902,\n",
       "  0.8356038928031921,\n",
       "  0.8242554068565369,\n",
       "  0.8124658465385437,\n",
       "  0.8001229763031006,\n",
       "  0.7899654507637024,\n",
       "  0.7793197631835938,\n",
       "  0.7690041661262512,\n",
       "  0.7592363953590393,\n",
       "  0.7493478059768677,\n",
       "  0.741100013256073,\n",
       "  0.7320113778114319,\n",
       "  0.722805917263031,\n",
       "  0.7144121527671814,\n",
       "  0.7063201665878296,\n",
       "  0.6971234679222107,\n",
       "  0.689102828502655,\n",
       "  0.6812340021133423,\n",
       "  0.6741710901260376,\n",
       "  0.6660035252571106,\n",
       "  0.6586483716964722,\n",
       "  0.6516914963722229,\n",
       "  0.6438842415809631,\n",
       "  0.6376379132270813,\n",
       "  0.6313478946685791,\n",
       "  0.6254786252975464,\n",
       "  0.6191399693489075,\n",
       "  0.6149187088012695,\n",
       "  0.6090231537818909,\n",
       "  0.6031673550605774,\n",
       "  0.5992223024368286,\n",
       "  0.5942367315292358,\n",
       "  0.5885969996452332,\n",
       "  0.5840122103691101,\n",
       "  0.5806311368942261,\n",
       "  0.5757204294204712,\n",
       "  0.5717618465423584,\n",
       "  0.5682419538497925,\n",
       "  0.5639169216156006,\n",
       "  0.560961902141571,\n",
       "  0.5571077466011047,\n",
       "  0.5538252592086792,\n",
       "  0.5487139225006104,\n",
       "  0.5450469255447388,\n",
       "  0.541793704032898,\n",
       "  0.5388137698173523,\n",
       "  0.5353049635887146,\n",
       "  0.532410740852356,\n",
       "  0.5294045209884644,\n",
       "  0.5289560556411743,\n",
       "  0.5238452553749084,\n",
       "  0.5209751129150391,\n",
       "  0.5186845660209656,\n",
       "  0.5162560343742371,\n",
       "  0.5148934721946716],\n",
       " 'val_accuracy': [0.19166666269302368,\n",
       "  0.2666666805744171,\n",
       "  0.2750000059604645,\n",
       "  0.34166666865348816,\n",
       "  0.3333333432674408,\n",
       "  0.3499999940395355,\n",
       "  0.3583333194255829,\n",
       "  0.34166666865348816,\n",
       "  0.36666667461395264,\n",
       "  0.3499999940395355,\n",
       "  0.36666667461395264,\n",
       "  0.3916666805744171,\n",
       "  0.40833333134651184,\n",
       "  0.42500001192092896,\n",
       "  0.42500001192092896,\n",
       "  0.4416666626930237,\n",
       "  0.44999998807907104,\n",
       "  0.44999998807907104,\n",
       "  0.4583333432674408,\n",
       "  0.4333333373069763,\n",
       "  0.49166667461395264,\n",
       "  0.49166667461395264,\n",
       "  0.5249999761581421,\n",
       "  0.5166666507720947,\n",
       "  0.5083333253860474,\n",
       "  0.5416666865348816,\n",
       "  0.5416666865348816,\n",
       "  0.5416666865348816,\n",
       "  0.5583333373069763,\n",
       "  0.5583333373069763,\n",
       "  0.5666666626930237,\n",
       "  0.5666666626930237,\n",
       "  0.574999988079071,\n",
       "  0.5916666388511658,\n",
       "  0.5916666388511658,\n",
       "  0.5916666388511658,\n",
       "  0.574999988079071,\n",
       "  0.5833333134651184,\n",
       "  0.625,\n",
       "  0.625,\n",
       "  0.6416666507720947,\n",
       "  0.6499999761581421,\n",
       "  0.6416666507720947,\n",
       "  0.625,\n",
       "  0.6416666507720947,\n",
       "  0.6499999761581421,\n",
       "  0.6583333611488342,\n",
       "  0.675000011920929,\n",
       "  0.6833333373069763,\n",
       "  0.699999988079071,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.75,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7833333611488342,\n",
       "  0.7749999761581421,\n",
       "  0.7833333611488342,\n",
       "  0.7833333611488342,\n",
       "  0.7916666865348816,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.800000011920929,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763]}"
      ]
     },
     "execution_count": 39,
     "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": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Accuracy'), Text(0.5, 0, 'Epoch')]"
      ]
     },
     "execution_count": 40,
     "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
}