Deep_Learning_Specialization/Course_4_Convolutional_Neural_Networks/Week1/DL_C4_week1_2_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": 16,
   "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",
    "            # YOUR CODE STARTS HERE\n",
    "            tfl.Input((64,64,3)), \n",
    "            ## ZeroPadding2D with padding 3, input shape of 64 x 64 x 3\n",
    "            tfl.ZeroPadding2D(padding=(3, 3)),\n",
    "            ## Conv2D with 32 7x7 filters and stride of 1\n",
    "            tfl.Conv2D(32, (7, 7), strides = (1, 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((2, 2)),\n",
    "            ## Flatten layer\n",
    "            tfl.Flatten(),\n",
    "            ## Dense layer with 1 unit for output & 'sigmoid' activation\n",
    "            tfl.Dense(1, activation='sigmoid'),\n",
    "            # YOUR CODE ENDS HERE\n",
    "        ])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\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": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "38/38 [==============================] - 4s 105ms/step - loss: 1.2552 - accuracy: 0.7217\n",
      "Epoch 2/10\n",
      "38/38 [==============================] - 4s 100ms/step - loss: 0.2040 - accuracy: 0.9200\n",
      "Epoch 3/10\n",
      "38/38 [==============================] - 4s 95ms/step - loss: 0.1477 - accuracy: 0.9450\n",
      "Epoch 4/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.2093 - accuracy: 0.9183\n",
      "Epoch 5/10\n",
      "38/38 [==============================] - 4s 98ms/step - loss: 0.1061 - accuracy: 0.9583\n",
      "Epoch 6/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.0737 - accuracy: 0.9717\n",
      "Epoch 7/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.2025 - accuracy: 0.9317\n",
      "Epoch 8/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.1309 - accuracy: 0.9450\n",
      "Epoch 9/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 0.0922 - accuracy: 0.9600\n",
      "Epoch 10/10\n",
      "38/38 [==============================] - 4s 98ms/step - loss: 0.2291 - accuracy: 0.9300\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f42183af090>"
      ]
     },
     "execution_count": 20,
     "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 30ms/step - loss: 0.2239 - accuracy: 0.8800\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.22393254935741425, 0.8799999952316284]"
      ]
     },
     "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": 26,
   "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(filters= 8 , kernel_size= (4,4) , padding='same')(input_img)\n",
    "    ## RELU\n",
    "    A1 = tfl.ReLU()(Z1)\n",
    "    ## MAXPOOL: window 8x8, stride 8, padding 'SAME'\n",
    "    P1 = tfl.MaxPool2D(pool_size=(8, 8), strides=(8, 8), padding='same')(A1)\n",
    "    ## CONV2D: 16 filters 2x2, stride 1, padding 'SAME'\n",
    "    Z2 = tfl.Conv2D(filters= 16 , kernel_size= (2,2) , padding='same')(P1)\n",
    "    ## RELU\n",
    "    A2 = tfl.ReLU()(Z2)\n",
    "    ## MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2 = tfl.MaxPool2D(pool_size=(4, 4), strides=(4, 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",
    "    \n",
    "    # YOUR CODE ENDS HERE\n",
    "    model = tf.keras.Model(inputs=input_img, outputs=outputs)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_3 (InputLayer)         [(None, 64, 64, 3)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 64, 64, 8)         392       \n",
      "_________________________________________________________________\n",
      "re_lu_2 (ReLU)               (None, 64, 64, 8)         0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 8, 8, 8)           0         \n",
      "_________________________________________________________________\n",
      "conv2d_3 (Conv2D)            (None, 8, 8, 16)          528       \n",
      "_________________________________________________________________\n",
      "re_lu_3 (ReLU)               (None, 8, 8, 16)          0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_3 (MaxPooling2 (None, 2, 2, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten_2 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_2 (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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.8046 - accuracy: 0.1806 - val_loss: 1.7924 - val_accuracy: 0.2000\n",
      "Epoch 2/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7880 - accuracy: 0.2000 - val_loss: 1.7844 - val_accuracy: 0.2000\n",
      "Epoch 3/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.7805 - accuracy: 0.2509 - val_loss: 1.7783 - val_accuracy: 0.3333\n",
      "Epoch 4/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7752 - accuracy: 0.2722 - val_loss: 1.7720 - val_accuracy: 0.3333\n",
      "Epoch 5/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7684 - accuracy: 0.3056 - val_loss: 1.7654 - val_accuracy: 0.3250\n",
      "Epoch 6/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 1.7608 - accuracy: 0.3370 - val_loss: 1.7574 - val_accuracy: 0.3667\n",
      "Epoch 7/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.7516 - accuracy: 0.3556 - val_loss: 1.7477 - val_accuracy: 0.3917\n",
      "Epoch 8/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.7402 - accuracy: 0.3639 - val_loss: 1.7350 - val_accuracy: 0.4000\n",
      "Epoch 9/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.7259 - accuracy: 0.4000 - val_loss: 1.7193 - val_accuracy: 0.4417\n",
      "Epoch 10/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 1.7095 - accuracy: 0.4157 - val_loss: 1.7012 - val_accuracy: 0.4500\n",
      "Epoch 11/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6896 - accuracy: 0.4380 - val_loss: 1.6796 - val_accuracy: 0.4667\n",
      "Epoch 12/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 1.6667 - accuracy: 0.4472 - val_loss: 1.6537 - val_accuracy: 0.4583\n",
      "Epoch 13/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.6414 - accuracy: 0.4620 - val_loss: 1.6270 - val_accuracy: 0.4583\n",
      "Epoch 14/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.6112 - accuracy: 0.4704 - val_loss: 1.5947 - val_accuracy: 0.4833\n",
      "Epoch 15/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.5792 - accuracy: 0.4852 - val_loss: 1.5609 - val_accuracy: 0.4750\n",
      "Epoch 16/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 1.5454 - accuracy: 0.4963 - val_loss: 1.5263 - val_accuracy: 0.4583\n",
      "Epoch 17/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.5091 - accuracy: 0.5204 - val_loss: 1.4891 - val_accuracy: 0.4667\n",
      "Epoch 18/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.4722 - accuracy: 0.5343 - val_loss: 1.4507 - val_accuracy: 0.4750\n",
      "Epoch 19/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.4354 - accuracy: 0.5546 - val_loss: 1.4132 - val_accuracy: 0.4750\n",
      "Epoch 20/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.3987 - accuracy: 0.5639 - val_loss: 1.3754 - val_accuracy: 0.4833\n",
      "Epoch 21/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.3623 - accuracy: 0.5778 - val_loss: 1.3395 - val_accuracy: 0.4833\n",
      "Epoch 22/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.3251 - accuracy: 0.5935 - val_loss: 1.3036 - val_accuracy: 0.5167\n",
      "Epoch 23/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.2886 - accuracy: 0.6037 - val_loss: 1.2684 - val_accuracy: 0.5417\n",
      "Epoch 24/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 1.2531 - accuracy: 0.6157 - val_loss: 1.2340 - val_accuracy: 0.5417\n",
      "Epoch 25/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.2188 - accuracy: 0.6222 - val_loss: 1.2007 - val_accuracy: 0.5500\n",
      "Epoch 26/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1860 - accuracy: 0.6306 - val_loss: 1.1681 - val_accuracy: 0.5667\n",
      "Epoch 27/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.1543 - accuracy: 0.6333 - val_loss: 1.1375 - val_accuracy: 0.5667\n",
      "Epoch 28/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.1238 - accuracy: 0.6435 - val_loss: 1.1077 - val_accuracy: 0.5917\n",
      "Epoch 29/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0945 - accuracy: 0.6500 - val_loss: 1.0800 - val_accuracy: 0.5917\n",
      "Epoch 30/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.0667 - accuracy: 0.6602 - val_loss: 1.0533 - val_accuracy: 0.6000\n",
      "Epoch 31/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 1.0401 - accuracy: 0.6722 - val_loss: 1.0282 - val_accuracy: 0.6000\n",
      "Epoch 32/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.0152 - accuracy: 0.6796 - val_loss: 1.0042 - val_accuracy: 0.6417\n",
      "Epoch 33/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9908 - accuracy: 0.6880 - val_loss: 0.9815 - val_accuracy: 0.6583\n",
      "Epoch 34/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.9685 - accuracy: 0.6963 - val_loss: 0.9610 - val_accuracy: 0.6667\n",
      "Epoch 35/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.9468 - accuracy: 0.7037 - val_loss: 0.9414 - val_accuracy: 0.6833\n",
      "Epoch 36/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.9266 - accuracy: 0.7083 - val_loss: 0.9235 - val_accuracy: 0.6833\n",
      "Epoch 37/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.9070 - accuracy: 0.7139 - val_loss: 0.9070 - val_accuracy: 0.6750\n",
      "Epoch 38/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8888 - accuracy: 0.7185 - val_loss: 0.8907 - val_accuracy: 0.6833\n",
      "Epoch 39/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.8706 - accuracy: 0.7278 - val_loss: 0.8762 - val_accuracy: 0.6917\n",
      "Epoch 40/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.8536 - accuracy: 0.7380 - val_loss: 0.8614 - val_accuracy: 0.7000\n",
      "Epoch 41/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.8373 - accuracy: 0.7398 - val_loss: 0.8469 - val_accuracy: 0.7083\n",
      "Epoch 42/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.8213 - accuracy: 0.7472 - val_loss: 0.8332 - val_accuracy: 0.7083\n",
      "Epoch 43/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.8060 - accuracy: 0.7537 - val_loss: 0.8202 - val_accuracy: 0.7167\n",
      "Epoch 44/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.7913 - accuracy: 0.7574 - val_loss: 0.8083 - val_accuracy: 0.7250\n",
      "Epoch 45/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.7775 - accuracy: 0.7593 - val_loss: 0.7970 - val_accuracy: 0.7250\n",
      "Epoch 46/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7637 - accuracy: 0.7593 - val_loss: 0.7856 - val_accuracy: 0.7250\n",
      "Epoch 47/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7506 - accuracy: 0.7639 - val_loss: 0.7749 - val_accuracy: 0.7250\n",
      "Epoch 48/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.7380 - accuracy: 0.7685 - val_loss: 0.7644 - val_accuracy: 0.7250\n",
      "Epoch 49/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7258 - accuracy: 0.7741 - val_loss: 0.7548 - val_accuracy: 0.7167\n",
      "Epoch 50/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7141 - accuracy: 0.7778 - val_loss: 0.7457 - val_accuracy: 0.7167\n",
      "Epoch 51/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.7026 - accuracy: 0.7796 - val_loss: 0.7363 - val_accuracy: 0.7167\n",
      "Epoch 52/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6915 - accuracy: 0.7796 - val_loss: 0.7277 - val_accuracy: 0.7250\n",
      "Epoch 53/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6805 - accuracy: 0.7815 - val_loss: 0.7189 - val_accuracy: 0.7250\n",
      "Epoch 54/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6704 - accuracy: 0.7833 - val_loss: 0.7108 - val_accuracy: 0.7250\n",
      "Epoch 55/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6604 - accuracy: 0.7870 - val_loss: 0.7031 - val_accuracy: 0.7250\n",
      "Epoch 56/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6507 - accuracy: 0.7935 - val_loss: 0.6942 - val_accuracy: 0.7333\n",
      "Epoch 57/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6409 - accuracy: 0.7981 - val_loss: 0.6855 - val_accuracy: 0.7333\n",
      "Epoch 58/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6313 - accuracy: 0.8009 - val_loss: 0.6767 - val_accuracy: 0.7333\n",
      "Epoch 59/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.6217 - accuracy: 0.8083 - val_loss: 0.6685 - val_accuracy: 0.7417\n",
      "Epoch 60/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6125 - accuracy: 0.8074 - val_loss: 0.6601 - val_accuracy: 0.7417\n",
      "Epoch 61/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.6040 - accuracy: 0.8083 - val_loss: 0.6523 - val_accuracy: 0.7417\n",
      "Epoch 62/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5954 - accuracy: 0.8102 - val_loss: 0.6449 - val_accuracy: 0.7417\n",
      "Epoch 63/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5870 - accuracy: 0.8148 - val_loss: 0.6373 - val_accuracy: 0.7500\n",
      "Epoch 64/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5791 - accuracy: 0.8213 - val_loss: 0.6300 - val_accuracy: 0.7583\n",
      "Epoch 65/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5713 - accuracy: 0.8222 - val_loss: 0.6233 - val_accuracy: 0.7583\n",
      "Epoch 66/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5638 - accuracy: 0.8250 - val_loss: 0.6168 - val_accuracy: 0.7750\n",
      "Epoch 67/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.5563 - accuracy: 0.8231 - val_loss: 0.6100 - val_accuracy: 0.7833\n",
      "Epoch 68/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.5493 - accuracy: 0.8213 - val_loss: 0.6039 - val_accuracy: 0.7917\n",
      "Epoch 69/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5423 - accuracy: 0.8231 - val_loss: 0.5979 - val_accuracy: 0.7833\n",
      "Epoch 70/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.5352 - accuracy: 0.8250 - val_loss: 0.5918 - val_accuracy: 0.7833\n",
      "Epoch 71/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5283 - accuracy: 0.8287 - val_loss: 0.5860 - val_accuracy: 0.8083\n",
      "Epoch 72/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5214 - accuracy: 0.8324 - val_loss: 0.5808 - val_accuracy: 0.8083\n",
      "Epoch 73/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.5147 - accuracy: 0.8352 - val_loss: 0.5759 - val_accuracy: 0.8083\n",
      "Epoch 74/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.5084 - accuracy: 0.8380 - val_loss: 0.5709 - val_accuracy: 0.8000\n",
      "Epoch 75/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.5022 - accuracy: 0.8389 - val_loss: 0.5665 - val_accuracy: 0.8167\n",
      "Epoch 76/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4962 - accuracy: 0.8435 - val_loss: 0.5616 - val_accuracy: 0.8167\n",
      "Epoch 77/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4899 - accuracy: 0.8472 - val_loss: 0.5571 - val_accuracy: 0.8167\n",
      "Epoch 78/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4836 - accuracy: 0.8500 - val_loss: 0.5528 - val_accuracy: 0.8167\n",
      "Epoch 79/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4777 - accuracy: 0.8528 - val_loss: 0.5487 - val_accuracy: 0.8167\n",
      "Epoch 80/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.4720 - accuracy: 0.8565 - val_loss: 0.5449 - val_accuracy: 0.8167\n",
      "Epoch 81/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.4666 - accuracy: 0.8574 - val_loss: 0.5410 - val_accuracy: 0.8167\n",
      "Epoch 82/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.4613 - accuracy: 0.8593 - val_loss: 0.5371 - val_accuracy: 0.8167\n",
      "Epoch 83/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4560 - accuracy: 0.8602 - val_loss: 0.5333 - val_accuracy: 0.8167\n",
      "Epoch 84/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4510 - accuracy: 0.8620 - val_loss: 0.5294 - val_accuracy: 0.8167\n",
      "Epoch 85/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4461 - accuracy: 0.8630 - val_loss: 0.5258 - val_accuracy: 0.8167\n",
      "Epoch 86/100\n",
      "17/17 [==============================] - 2s 107ms/step - loss: 0.4413 - accuracy: 0.8667 - val_loss: 0.5221 - val_accuracy: 0.8167\n",
      "Epoch 87/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4365 - accuracy: 0.8694 - val_loss: 0.5200 - val_accuracy: 0.8167\n",
      "Epoch 88/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4315 - accuracy: 0.8769 - val_loss: 0.5167 - val_accuracy: 0.8083\n",
      "Epoch 89/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4270 - accuracy: 0.8778 - val_loss: 0.5136 - val_accuracy: 0.8167\n",
      "Epoch 90/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.4222 - accuracy: 0.8796 - val_loss: 0.5098 - val_accuracy: 0.8083\n",
      "Epoch 91/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.4177 - accuracy: 0.8806 - val_loss: 0.5068 - val_accuracy: 0.8083\n",
      "Epoch 92/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.4135 - accuracy: 0.8796 - val_loss: 0.5040 - val_accuracy: 0.8083\n",
      "Epoch 93/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.4095 - accuracy: 0.8815 - val_loss: 0.5008 - val_accuracy: 0.8083\n",
      "Epoch 94/100\n",
      "17/17 [==============================] - 2s 112ms/step - loss: 0.4054 - accuracy: 0.8815 - val_loss: 0.4980 - val_accuracy: 0.8083\n",
      "Epoch 95/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.4012 - accuracy: 0.8843 - val_loss: 0.4946 - val_accuracy: 0.8083\n",
      "Epoch 96/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3973 - accuracy: 0.8843 - val_loss: 0.4921 - val_accuracy: 0.8167\n",
      "Epoch 97/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 0.3933 - accuracy: 0.8852 - val_loss: 0.4889 - val_accuracy: 0.8167\n",
      "Epoch 98/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.3898 - accuracy: 0.8852 - val_loss: 0.4872 - val_accuracy: 0.8167\n",
      "Epoch 99/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.3857 - accuracy: 0.8861 - val_loss: 0.4838 - val_accuracy: 0.8167\n",
      "Epoch 100/100\n",
      "17/17 [==============================] - 2s 111ms/step - loss: 0.3818 - accuracy: 0.8870 - val_loss: 0.4814 - 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": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.804575800895691,\n",
       "  1.7880141735076904,\n",
       "  1.7805262804031372,\n",
       "  1.7751625776290894,\n",
       "  1.7683864831924438,\n",
       "  1.7607616186141968,\n",
       "  1.751592755317688,\n",
       "  1.7402479648590088,\n",
       "  1.7259442806243896,\n",
       "  1.709488868713379,\n",
       "  1.6896253824234009,\n",
       "  1.666666865348816,\n",
       "  1.6413618326187134,\n",
       "  1.6111756563186646,\n",
       "  1.579219937324524,\n",
       "  1.545390248298645,\n",
       "  1.509113073348999,\n",
       "  1.4721540212631226,\n",
       "  1.4354487657546997,\n",
       "  1.3987234830856323,\n",
       "  1.3622734546661377,\n",
       "  1.3250538110733032,\n",
       "  1.2886303663253784,\n",
       "  1.2531033754348755,\n",
       "  1.2188173532485962,\n",
       "  1.1859710216522217,\n",
       "  1.1543254852294922,\n",
       "  1.1237651109695435,\n",
       "  1.094520926475525,\n",
       "  1.0666521787643433,\n",
       "  1.0400772094726562,\n",
       "  1.015235424041748,\n",
       "  0.9908419251441956,\n",
       "  0.968485951423645,\n",
       "  0.9468350410461426,\n",
       "  0.9265996813774109,\n",
       "  0.9069704413414001,\n",
       "  0.888789176940918,\n",
       "  0.8705661296844482,\n",
       "  0.853632926940918,\n",
       "  0.8373036980628967,\n",
       "  0.8213234543800354,\n",
       "  0.8059848546981812,\n",
       "  0.7913393378257751,\n",
       "  0.7775436639785767,\n",
       "  0.7637122273445129,\n",
       "  0.7505978345870972,\n",
       "  0.7379648685455322,\n",
       "  0.7257614731788635,\n",
       "  0.714057981967926,\n",
       "  0.7026292681694031,\n",
       "  0.6914731860160828,\n",
       "  0.6805344223976135,\n",
       "  0.670401930809021,\n",
       "  0.6604357957839966,\n",
       "  0.6506952047348022,\n",
       "  0.6408737897872925,\n",
       "  0.6313151717185974,\n",
       "  0.6216641068458557,\n",
       "  0.6125043034553528,\n",
       "  0.6039974689483643,\n",
       "  0.5953904390335083,\n",
       "  0.5870136618614197,\n",
       "  0.5790929198265076,\n",
       "  0.5713310837745667,\n",
       "  0.563786506652832,\n",
       "  0.55625319480896,\n",
       "  0.5493144392967224,\n",
       "  0.5422837734222412,\n",
       "  0.5351784229278564,\n",
       "  0.5283371806144714,\n",
       "  0.5213819146156311,\n",
       "  0.5146615505218506,\n",
       "  0.5083845257759094,\n",
       "  0.5022224187850952,\n",
       "  0.49618563055992126,\n",
       "  0.48992472887039185,\n",
       "  0.48361721634864807,\n",
       "  0.4776851534843445,\n",
       "  0.47204816341400146,\n",
       "  0.4666084051132202,\n",
       "  0.461274653673172,\n",
       "  0.4559875428676605,\n",
       "  0.4509797692298889,\n",
       "  0.4461205005645752,\n",
       "  0.4413484036922455,\n",
       "  0.4365232586860657,\n",
       "  0.43148350715637207,\n",
       "  0.4269898533821106,\n",
       "  0.4221944510936737,\n",
       "  0.41772451996803284,\n",
       "  0.41351741552352905,\n",
       "  0.4094543755054474,\n",
       "  0.4054068922996521,\n",
       "  0.4011521339416504,\n",
       "  0.3972596526145935,\n",
       "  0.3932817578315735,\n",
       "  0.3897661864757538,\n",
       "  0.3856815993785858,\n",
       "  0.38183847069740295],\n",
       " 'accuracy': [0.1805555522441864,\n",
       "  0.20000000298023224,\n",
       "  0.2509259283542633,\n",
       "  0.27222222089767456,\n",
       "  0.3055555522441864,\n",
       "  0.33703702688217163,\n",
       "  0.35555556416511536,\n",
       "  0.3638888895511627,\n",
       "  0.4000000059604645,\n",
       "  0.4157407283782959,\n",
       "  0.43796294927597046,\n",
       "  0.4472222328186035,\n",
       "  0.46203702688217163,\n",
       "  0.4703703820705414,\n",
       "  0.4851851761341095,\n",
       "  0.4962962865829468,\n",
       "  0.520370364189148,\n",
       "  0.5342592597007751,\n",
       "  0.5546296238899231,\n",
       "  0.5638889074325562,\n",
       "  0.5777778029441833,\n",
       "  0.5935184955596924,\n",
       "  0.6037036776542664,\n",
       "  0.6157407164573669,\n",
       "  0.6222222447395325,\n",
       "  0.6305555701255798,\n",
       "  0.6333333253860474,\n",
       "  0.6435185074806213,\n",
       "  0.6499999761581421,\n",
       "  0.6601851582527161,\n",
       "  0.6722221970558167,\n",
       "  0.6796296238899231,\n",
       "  0.6879629492759705,\n",
       "  0.6962962746620178,\n",
       "  0.7037037014961243,\n",
       "  0.7083333134651184,\n",
       "  0.7138888835906982,\n",
       "  0.7185184955596924,\n",
       "  0.7277777791023254,\n",
       "  0.7379629611968994,\n",
       "  0.739814817905426,\n",
       "  0.7472222447395325,\n",
       "  0.7537037134170532,\n",
       "  0.7574074268341064,\n",
       "  0.7592592835426331,\n",
       "  0.7592592835426331,\n",
       "  0.7638888955116272,\n",
       "  0.7685185074806213,\n",
       "  0.7740740776062012,\n",
       "  0.7777777910232544,\n",
       "  0.779629647731781,\n",
       "  0.779629647731781,\n",
       "  0.7814815044403076,\n",
       "  0.7833333611488342,\n",
       "  0.7870370149612427,\n",
       "  0.7935185432434082,\n",
       "  0.7981481552124023,\n",
       "  0.8009259104728699,\n",
       "  0.8083333373069763,\n",
       "  0.8074073791503906,\n",
       "  0.8083333373069763,\n",
       "  0.8101851940155029,\n",
       "  0.8148148059844971,\n",
       "  0.8212962746620178,\n",
       "  0.8222222328186035,\n",
       "  0.824999988079071,\n",
       "  0.8231481313705444,\n",
       "  0.8212962746620178,\n",
       "  0.8231481313705444,\n",
       "  0.824999988079071,\n",
       "  0.8287037014961243,\n",
       "  0.8324074149131775,\n",
       "  0.835185170173645,\n",
       "  0.8379629850387573,\n",
       "  0.8388888835906982,\n",
       "  0.8435184955596924,\n",
       "  0.8472222089767456,\n",
       "  0.8500000238418579,\n",
       "  0.8527777791023254,\n",
       "  0.8564814925193787,\n",
       "  0.8574073910713196,\n",
       "  0.8592592477798462,\n",
       "  0.8601852059364319,\n",
       "  0.8620370626449585,\n",
       "  0.8629629611968994,\n",
       "  0.8666666746139526,\n",
       "  0.8694444298744202,\n",
       "  0.8768518567085266,\n",
       "  0.8777777552604675,\n",
       "  0.8796296119689941,\n",
       "  0.8805555701255798,\n",
       "  0.8796296119689941,\n",
       "  0.8814814686775208,\n",
       "  0.8814814686775208,\n",
       "  0.8842592835426331,\n",
       "  0.8842592835426331,\n",
       "  0.885185182094574,\n",
       "  0.885185182094574,\n",
       "  0.8861111402511597,\n",
       "  0.8870370388031006],\n",
       " 'val_loss': [1.7923716306686401,\n",
       "  1.7844328880310059,\n",
       "  1.7782821655273438,\n",
       "  1.7720069885253906,\n",
       "  1.7654134035110474,\n",
       "  1.7574349641799927,\n",
       "  1.7477480173110962,\n",
       "  1.7350261211395264,\n",
       "  1.719261884689331,\n",
       "  1.7011940479278564,\n",
       "  1.6795928478240967,\n",
       "  1.6536715030670166,\n",
       "  1.6270232200622559,\n",
       "  1.5947355031967163,\n",
       "  1.5608792304992676,\n",
       "  1.5263341665267944,\n",
       "  1.489061951637268,\n",
       "  1.450742483139038,\n",
       "  1.4132193326950073,\n",
       "  1.3753514289855957,\n",
       "  1.339513897895813,\n",
       "  1.3036000728607178,\n",
       "  1.2683565616607666,\n",
       "  1.2339800596237183,\n",
       "  1.2006913423538208,\n",
       "  1.16812002658844,\n",
       "  1.1374781131744385,\n",
       "  1.1076653003692627,\n",
       "  1.079998254776001,\n",
       "  1.053346872329712,\n",
       "  1.028156042098999,\n",
       "  1.0042041540145874,\n",
       "  0.9815046787261963,\n",
       "  0.9610353112220764,\n",
       "  0.9413818120956421,\n",
       "  0.9235361218452454,\n",
       "  0.907014787197113,\n",
       "  0.8907409310340881,\n",
       "  0.8761695027351379,\n",
       "  0.8614025712013245,\n",
       "  0.846943736076355,\n",
       "  0.8332147598266602,\n",
       "  0.8201501965522766,\n",
       "  0.8083428144454956,\n",
       "  0.7970408201217651,\n",
       "  0.7856199145317078,\n",
       "  0.7748606204986572,\n",
       "  0.7644220590591431,\n",
       "  0.7548219561576843,\n",
       "  0.7457180023193359,\n",
       "  0.7363356351852417,\n",
       "  0.7276725769042969,\n",
       "  0.7189432978630066,\n",
       "  0.7108139395713806,\n",
       "  0.70307856798172,\n",
       "  0.6942135095596313,\n",
       "  0.6855155825614929,\n",
       "  0.6767328977584839,\n",
       "  0.6684579253196716,\n",
       "  0.6601080298423767,\n",
       "  0.6523479223251343,\n",
       "  0.644875168800354,\n",
       "  0.6373394131660461,\n",
       "  0.6299506425857544,\n",
       "  0.6233442425727844,\n",
       "  0.6167566180229187,\n",
       "  0.6100091338157654,\n",
       "  0.6039162278175354,\n",
       "  0.5978929996490479,\n",
       "  0.591845691204071,\n",
       "  0.5860083103179932,\n",
       "  0.5807727575302124,\n",
       "  0.5758739709854126,\n",
       "  0.5709259510040283,\n",
       "  0.5664964318275452,\n",
       "  0.5616061091423035,\n",
       "  0.5571291446685791,\n",
       "  0.5528131127357483,\n",
       "  0.5487251281738281,\n",
       "  0.5448560118675232,\n",
       "  0.5410205721855164,\n",
       "  0.5370997786521912,\n",
       "  0.53327476978302,\n",
       "  0.5293601751327515,\n",
       "  0.5258333683013916,\n",
       "  0.5220832228660583,\n",
       "  0.519957423210144,\n",
       "  0.5167224407196045,\n",
       "  0.5135696530342102,\n",
       "  0.5098081231117249,\n",
       "  0.5067710280418396,\n",
       "  0.5040417909622192,\n",
       "  0.5008105635643005,\n",
       "  0.4979958236217499,\n",
       "  0.49456146359443665,\n",
       "  0.4920658767223358,\n",
       "  0.4889011085033417,\n",
       "  0.4871637225151062,\n",
       "  0.4837813973426819,\n",
       "  0.48144659399986267],\n",
       " 'val_accuracy': [0.20000000298023224,\n",
       "  0.20000000298023224,\n",
       "  0.3333333432674408,\n",
       "  0.3333333432674408,\n",
       "  0.32499998807907104,\n",
       "  0.36666667461395264,\n",
       "  0.3916666805744171,\n",
       "  0.4000000059604645,\n",
       "  0.4416666626930237,\n",
       "  0.44999998807907104,\n",
       "  0.46666666865348816,\n",
       "  0.4583333432674408,\n",
       "  0.4583333432674408,\n",
       "  0.4833333194255829,\n",
       "  0.4749999940395355,\n",
       "  0.4583333432674408,\n",
       "  0.46666666865348816,\n",
       "  0.4749999940395355,\n",
       "  0.4749999940395355,\n",
       "  0.4833333194255829,\n",
       "  0.4833333194255829,\n",
       "  0.5166666507720947,\n",
       "  0.5416666865348816,\n",
       "  0.5416666865348816,\n",
       "  0.550000011920929,\n",
       "  0.5666666626930237,\n",
       "  0.5666666626930237,\n",
       "  0.5916666388511658,\n",
       "  0.5916666388511658,\n",
       "  0.6000000238418579,\n",
       "  0.6000000238418579,\n",
       "  0.6416666507720947,\n",
       "  0.6583333611488342,\n",
       "  0.6666666865348816,\n",
       "  0.6833333373069763,\n",
       "  0.6833333373069763,\n",
       "  0.675000011920929,\n",
       "  0.6833333373069763,\n",
       "  0.6916666626930237,\n",
       "  0.699999988079071,\n",
       "  0.7083333134651184,\n",
       "  0.7083333134651184,\n",
       "  0.7166666388511658,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7166666388511658,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7333333492279053,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.7416666746139526,\n",
       "  0.75,\n",
       "  0.7583333253860474,\n",
       "  0.7583333253860474,\n",
       "  0.7749999761581421,\n",
       "  0.7833333611488342,\n",
       "  0.7916666865348816,\n",
       "  0.7833333611488342,\n",
       "  0.7833333611488342,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.800000011920929,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8083333373069763,\n",
       "  0.8166666626930237,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8166666626930237,\n",
       "  0.8083333373069763]}"
      ]
     },
     "execution_count": 29,
     "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": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Accuracy'), Text(0.5, 0, 'Epoch')]"
      ]
     },
     "execution_count": 30,
     "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
}