Convolutional Neural Networks/week1/2 Convolution_model_Applications/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": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD7CAYAAACscuKmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO29a6xk2XUettY5p573ffs9090zfIz5ECWOpDFNgYIxJk2DcQzzlwILcMAEBOaPbMiIA5O0gQAOYIBGAscJECQYxIoJWLFMWJZJC45tZmI6siSS07RIaobDeWjYnH7f9731PHUeOz+quta31r1VfWe6u24Pa33Axd2n9q599tnn7Dpr7bXWtziEQA6H46cf0UkPwOFwzAa+2B2OOYEvdodjTuCL3eGYE/hidzjmBL7YHY45wX0tdmb+DDO/ysxvMPMXH9SgHA7Hgwe/Uzs7M8dE9BoRfZqIrhPRi0T0qyGEHz644TkcjgeF5D6++zEieiOE8CYRETP/FhF9logmLvb19ZVw6eJZIiIKpalkKZamLpTyg1SpVrFm4uCiyFwaH92Wme0n0nvITdvkyDKRvRg8Vzyxf6JC1ZRBjtW5DglgdsyTzj2t3YPFtJcGTrFtxyzXFsz95IlH9lw4/8cVVu3cTHvpzW4e7xdXr16lra2tIwd8P4v9cSK6BsfXiejPTPvCpYtn6f/+V/8LERFlqZlcuEdpqhdP2hmMyxeeeGJcLvOBasdwOc2ldV0X4cKScydJRY+D5TgbbKuqSm1NypXT0lvoq3b4IxHFC7p/qkC7jqrpZXvjci2Rc8VRQw+RKupInZsGx2qn8U61OZnHLMsn1kXQfV7oH7hqRX68C8pUXax+8GT8ZdDtAsn8R2znyv7YSs2k8R4Gzo/93qQfmgfx42HurXoZHP0CeOaZZyb2dj86+1EjPnSFzPwcM19h5ivbOwf3cTqHw3E/uJ83+3UiugTHF4nopm0UQnieiJ4nIvq5n30qZMXwDVAU+nem3+uNy6trZ1VdJUrH5TSVt+3y2nnVrhjI26XMW6qOY/mFz/pdGV9jUbdjeWt02l1Vt1qTcQ1y+eFio5PEMYim5q3PoE7YX+dm9TQcoboyTRWwwu6kW3r/b+90YCWYAGX9rbwQCaNeq8soDg0DJIBDbyt5kxVqHnW7iFF60mMs4c3Lak7tuwolDj2Hh9UoXfv2Pic6/E483pv+8NtcUJbFxLq7uJ83+4tE9BQzv4eZq0T0V4jo6/fRn8PheIh4x2/2EELOzH+NiP4tDV89vxFCePmBjczhcDxQ3I8YTyGEf01E//oBjcXhcDxE3Ndif7uIk5iW14a7zN0DvRN9a3N3XF5cv6TqOBFdPM1Fp964eUOfYCC6/eLykqqqLcjufKct+nxe6F3kak30v6WlFVXX78hueaUmu75RpHX2AvTEmGp6jBHolEFPvzKaMezos76W4+6sB7W7rcfIqg/7GIQjy5ExU3IUH9mOiKgE+ynuU0RGaS/AIhEZrRL17RKsDDFbCwe0C21Vo8152IfetUcryeF9j2lmPzpm3eR9lne2Oz/J3DvFHH3Mszgcjnc5fLE7HHOCmYrxHEVUbw5FsDLXvzMhEzFqb+O2qsv7IuLXVkWkzXa1KnD2sQvSnxEX40TMP4urItIniW5XrYt5bX9LWxLTvoj/6+eelIrIik5i4imtww2YSJJImxgjkjESi4ich5ZpJ6rB0BACXyPlrgYVWl3R3npG1VAiopSTyjSTlJ5HjuB8LH0E4zWYlzg/2kkqsLSNYIyx8YYsgqhXGZSJ9HUmSnTX54p5Gc9MGpPVFSLjlDWxHeL+PSAPOSyOTcYuxjsccw9f7A7HnMAXu8MxJ5ipzk7ERGGo/5SUqppaInpd0d1UdfFKE3oQHalR1+aT5sqZcfnO9bdUXSUWfbgkcc3NU+OKGkQHbi5rV1qMmanVoY6NWQv0y2B0Q6yLWPevhgFms0MmL9DleIoZhyGoJy90XAIGkxRBuwXXYH+DQc897DaKZj4TwUdoLhVzWJbrPQx0U22neg+mVpV7U0vkGYhgfEREaSku1MHo8zmcr4zkXjQTa/bE+2TdkydH1bG67nf67rRmtEnAe2uDZGwg0mH4m93hmBP4Ync45gSzFeNDSWU2FN+rkRaVqiD2NdZ1LHqyJKJke0PMcBFpMX5vS0x2fTDXEREN+hB5FctlZ5lWJ4p8a1xeMtF3CcReBxjvXdVk3H+EpjFrmpks+qLnFkZoTY7J1v0dPhaRtii0iW6QiRhYrVpzzdGPxWFyCVC9Si2C92EeIzAPDkotbmYwBZVkVddlIoLn0H9szF3tDFUUrSY0QPxPInkGQtDqFYFaaU2RmhfAmIxhTniquW0a3gnhyGQSkEnwN7vDMSfwxe5wzAlmKsaHMlDeH+6EVxs6mOHskxfH5eqyDkBZWBBShxQ2sK+9/j3VLk1FdFw5vazqCMScAcSHrBiVAXc5rWhUb8rJy0LExRhExVEtlI/PQadvx2TvNI3jeWqVpRZ9r96UHeyz67ru1Ioco+Viv6U9+ZYXROyuVLToGwWZkwDjzwpNKZUGGWOzogN+cgh4aSQidrf6t1S7AQQzdQba6rDUEPF8JZJzxZG+5phxXFaUnqZGIdBT0Ko8eG+nkVdME+mPS531Tls4HI6fCvhidzjmBL7YHY45wYyj3mKqLg515N0DTTzRyfbH5WrXkDSCrrW88r5x+dIHfla1O9h/fVxuVLUO2dkH01AMHm7G42pv84700eypuoUVoXeOKvA7aVRvjtDrTOuG6PEWpvLNT/PMmrYncDSqJmItgjm9dmdf1TXq4KVYk32K3X3tabe9syHtmnq+b++LGXQJ9mDimvYazDIkrdSm1CrJHsEi6PO7La2XD3Iwsyb62Tnoy3XWwXRar+n9ASY8tuZSvGeZqcN7geZSe8+m6eKTiC3eDj/+3fs72XTnb3aHY07gi93hmBPM1vQWCsqyochVshaHqrGIQBWTAaXfF0KCKH5xXG4sfFC1y/rCI9/vXlN1qxcuQDsRzwepNidVGyIGVWpanEOxOwTkWJscOBFK7clHh4gioH8+miTBcqKhKHnYu+5ocRG57ImILp8X0bqXadGvVoU5SKT/Jx9/TLX78VtXx+Xrt++oujKWeb0JZCQh1p58Swvipdjq6z5WqnLdSxAUM8g1z1wFzGhpoT0iK4nMd5nJvAWbCCgRM980EdzOt/KkPDaO62lnRfIpmWmO0aW/2R2OOYEvdodjTuCL3eGYE8xUZy/yAe1vXSciorSndfZuW9wh+7kmr6g2RU9aP3tuXF66oM04i2ui65cVQ9IYHW2iihOt7DQWRZeNjGKHKd0wi6sNOMoGMv440TpqjDo72+mHEyAZgdkT0DqlNQWhKQvdZbVuWUmQmFKPsd2Se9GLxcxVq+lxPHZe7kWloU1etbq4y751U+bj6jVNCNldEpKR9XVtisyABDJicc09taijEbNcTIeNWI+xXm1CWe5nfIg4BF1dp2Ea0cQ0bvjjmt6mYbJZ7nDq8cO455udmX+DmTeY+SX4bJ2Zv8HMr4/+r03rw+FwnDyOI8b/YyL6jPnsi0T0QgjhKSJ6YXTscDgeYdxTjA8h/H/M/KT5+LNE9Oyo/BUi+iYRfeFefTFHFEdDsWpxQfOILa+JuHX96o9VXYp53esitnaXtlW7xoKY3hYX3qfqykzMbQWYw9KBFveTipiXKsbLatATUbXIIG1Rol3okA+syE065yoKQVa1QNEdSS60OYmAMy4daPHtxo3rUob0WHc2tGq0vy/mq3SgVYEAaamqkNK62dQm0csXxZz51PtPq7rVhVPj8sJ7pHx+TYvxaVZCWddxJGPe60ikGwcdMVkCv3yaaq9HNJHWSOY+j7XakZE8c/X4ImmgOmfuhSJQmRz1Rip1tF1203jpj+7DEp+Ix+WD540/F0K4RUQ0+n/2Hu0dDscJ46HvxjPzc8x8hZmvbG8f3PsLDofjoeCd7sbfYeYLIYRbzHyBiDYmNQwhPE9EzxMRPf3RD4R6bbjDGjf0nt72HRDdCy2KLUJQS60pu+WdfeO1BRLtQlP3H9WAEANSE6U9LTrWG0JHbUkpCuCr67YlNVTTZHutVGQguSFrQJHc0kCzEgmlnQ2+yHIR1X7v9/4fVfftF38wLrc6Iu53+0b8LMNRRSLSlosqBK7EZqf7R6+8Mi5///tajP+5n33/uHzurFzXgLTqVamLOler64HsQkBUDwgrrBgcg0heMbyEmLKqn4nK1mycUu0CWCvKSAf8RIwqp92NxwyyqBLqa0FrwrTAJn2vJ9NWT6b1fvCBMF8nos+Nyp8joq+9w34cDseMcBzT2z8loj8kog8w83Vm/jwRfZmIPs3MrxPRp0fHDofjEcZxduN/dULVpx7wWBwOx0PETD3oojii+vIoZXOmPbqqELkUWXPVMqRbPiUb/zZdcQZKe79rCBmaQGzYFNNKvaG5ytGsVZZanycWc1upIq80aSWa3iqJ9tRi5SVnzETKCwo8Co2+/Qd/8PtS/tYVVbe3L3ojfi/LralGUJRGDwXPO25Lf3GkH5c6eMkVhn9/Z0fmvwbRa5cu672U935E7m2XdTRbqyNzkIAOXIm1PvzYaTGXRoZYc7e1My5XgZSjXtfPB3oUxqUxx7KMI2JtjiVG/nkUlG2kIkbO2Ui5o1Nk2/2BoDjxrVBeG7eaBPeNdzjmBL7YHY45wYwDYVLa236TiIjYSDLtbRHh4roe1gJkU63WQewO+rcqykWU3N95WdXFFRG1kwqK1tq8VhbSZ15or7OkIia2xVUJAkmq2hswlChuWZYE9P6y4pyI2t2OiJm//x9/T7X6w28LgcfevhZ90RsuTUXELI19LZQYMGNEPzjEKpswqddtQ9lwyi+LuF6CmnCwr8k8eqmoZZd+RnP9n1uRe1YOROVZWtDPxxoGL5H2rts/EOKMIpXnIx3sqHbVRMYRG/WQFU+hmQV4BlmZ6HQfOi2VJjBBAgw+9D2EPLeHufDumkWdg87hmHv4Ync45gS+2B2OOcGMCSdLGuRD09b2VW36iAvRbRdPaZfH5hK4sMZi+giFNiftt/5E2lX171gcoz4ouk+a6rxhBy05TjNtGju9JlF1MaT/jUrj9spghuJzug6m3KYNLkDXf/E73xqXv/Wtb6l2u7syd4UxqRVIqgh1pbG8obktWH1e6exgMjIECQH0w55xCyY4TipACNnXewxvvCJz9b4nf1nVffiDH4VxyFx1U/3sFGAqq5lIxbUVcfEtSzl3tWpTWEsfSaSvpZKIK3BMdg4wmq2majQwilGPPwTMrYeprnV8me5/dlFvDofjXQZf7A7HnGCmYnyel7S1NRSNt29qUeaJ918al9cunFF1CWZaAs+7KNYmjDgBcYi1OewuXz0RUaUi5rY40uIcRnxlufag22uJ6LS+LF5bZWlMgBGYtUpt4ilYRPV8oKP29vel7qUfSDrqjkmVHIGIXDFeVgnLcQzlNGixLwLxPDdiPJrpEhDdkylifBTMOEAFisC0lJn3y+amiPEv/eA1VffhD79XzgWeam/deFO1q9RAJcm0WtYbyJx+5Kk/PS4vNy+odmkmJrosM7z0MUQgmucKReugzHBkAFGGpQ31RhEfIu5YmyLD1LRf6bjVJPib3eGYE/hidzjmBDMV49N+Rld/OORIe2zZBI9A2qUy1iIhQwqfLBWejEpVk0ZgKqeopvvoQ90ekF5UqnoK1lcvj8uNhq7DwJsSgl02t/5EtUM1YbGh1ZU8l+91OlqMf/mPZYy3bgg5BnoGEhE9Dh5ki4n+ve71RdztgNNWN9LiXQ6WjNw48mWFtI3Ae6xqUkjFkAm2Emm5NYKmnMi96JmgmzupqCQ3b+r52NwS1WsRHCdvbGhRneFa6on2WEyAcKPflXaNmra04HuvUVudWHdoybCcL8vk2YyMepgXEkSVZ/qZqNeESCOOUYW13nQ4xyZIZvw8uhjvcMw9fLE7HHMCX+wOx5xgtuQVgaiWD3Wo2oI2m2Wl6KWbt7VO1u+JLvTYadGpmwvahFFh8bw76NxUdTu7V8flU+AJl5bai61SkaipfktHaC2CuQ1Vo85eR7VbXRXzzEGmTW99MAV19rVp77VXhfM9h3ZPrmhzz5NrMsYwMF6EQJzYAZNg3/yuI3dImVgPOlS4gcjiEDElED7YHFhQl1TAtGTScA1K0dn3dvV8/6cXfzgu/+LH5b4vJNrDkkFPv/zYe1Rd2hdTVgFEnb2u1tlL4EzlmiYciSJI52zOnWcw/0Hu2eFUznKdtaohNAG9X6eE1jp7UYBJ0EQq5qNrswGMCH+zOxxzAl/sDsecYLZifBTR0sJQDNpuay+l1QSydJ7S6XeSiog2vQMRlbodHbDQXJYgiJ0dLablhagNAxB9t3a1KpC1hQs9pFrkxOymCXCWLS3rgIV0IO129jVPegSsHW++ockxNm6JyH8KCDx+7pLmbauDKLy9aQKKwJMtgegX62mHhAylkc+DKsORcQtjDJKxPOlwnEA7m013rSZ1AxPUc+0tSV/1i78g3nTnVjXn++KCiMXLRgQvMBNvT+YqKzQ3PIGIT6e0SZcq4Mlmvpd1RPwvMjEdxjU9VwVkyo2a51Udg/l00BVPvkrTmjpFhcgHehzd7eFzVlg7KsDf7A7HnMAXu8MxJ/DF7nDMCWaqs8dRRIsLI1dSkzesAe6F/R3tNtkH4sRl4I2Pcq2zJ5HoQklP91+tihviQiR9tDpal2135VwDs6/Q6YvO1wadKWpo892pJdl/2DN9NJflOm9e06a3UIi+9cRZ0T0fP6N1yL0dcau1OlpZHE1KYQkqDEOFrsLvKRdNa9eBusia7zCqTsZUMSwadXS5NZFi3QOZu7An9/qDFy6rdlEi99oSmpQwP5WquDFzRZszaVH2dKKaduVG0tBsW6cTpxw45Qswifb1M5G2Za+J1/UzEZowfjCXFoned0ogfbblCtkeuRoXA0tEKThO+qdLzPzvmfkVZn6ZmX999Pk6M3+DmV8f/V+7V18Oh+PkcBwxPieivxlC+BARfZyIfo2ZP0xEXySiF0IITxHRC6Njh8PxiOI4ud5uEdGtUbnFzK8Q0eNE9FkienbU7CtE9E0i+sK0vpiZ6iORa3nZpNGpiHi7v6M9qYqeiDM7t8UzbnVVRyfd/rGYzQaGrGHlLJwvlssujAfamcvCN9Zb0pzyravi2YfSUi/VovQAvN96qfau2+qIKY6N+FyFULHzayKyVSL9mxwK5D2bLD6j2cx6VimJeZrblerfkFegJmB57JCsAcx+sUndVAV1rmJo1TIwYe5vilmyv6i54ZMGEEiY0ZdgUoug/6Sqn79oUcx5HOu6fE88G8NA3+sCPOgiUBnYmBhrNRlzbUGnt+aKjD+GcXFiVA1Qh3oHWgXMRg/koRwAgLe1QcfMTxLRzxPRt4no3OiH4O4PwtnJ33Q4HCeNYy92Zl4kot8mor8RQrC8OtO+9xwzX2HmK7sme4nD4ZgdjrXYeeip/9tE9JshhH8x+vgOM18Y1V8ggkgCQAjh+RDCMyGEZ9ZWFo9q4nA4ZoB76uw8JAv/R0T0SgjhH0DV14noc0T05dH/r92rryiKqNEc6sEra3rzfq8lpqxeR7sC1mqi01zfE32+bFiSQ2l3p631/oNIXFNPLYuJrm90e4aIpMcfe0qPEXTIsCftfvEDH1TtOhDpFplsyD9+S3LQxYbYsLMjun4dXIRzk946B7dSqytjJFoEun7EeiD4NcsHj3sJWgc0bDQ8sUodq/6NLtuoiV66ZNx2cXZSMKk1VzURo9Jlu31dB+eL6nLPokWtdUbgEhuMK2oJefci1kumAhF9UQxRarGekAo8w0lT7wkwpPVmyEdQZnoc6ZbsHbS3dDTllBRvct57N6FPENF/SUR/zMx3KU//Ng0X+VeZ+fNE9BYR/cox+nI4HCeE4+zG/0ea/LvxqQc7HIfD8bAwUw86jmOqLQ5FmJy1OLd5Q8xae3uaJ71TihjVSsTm9cRZLWavLT8xLh9c/QNVt7QilxpBaqjldR1BNYAUTFGixcX3v/9jcgB2nIWmITvgD0jZ/E6eOy/eX2+9+oaq27v6gnwPZOQs06rGAMX6Q0SPIMbD5/EhzncklSQN/CAAeYUV4xWrpN7+KUF8DmDqjBpahG00xLx5uqavM0tFPK83wQxqzsVVIH/om9RNEBGXnBLyEa5oEooApB9lT0cqKm2lps1hyJePo7IOiwwqBCfapMsRELlAf4MDvQ3W29uDZvoEY1PfYcL6I8fncDh+iuGL3eGYE8yWvIIjqjWGnkRXf/SqqtvfE9N9YkS9KAg/3coiiGyx3qW+vSXpg6pVHYjQrIq33ToG05zW3kyBRIS7fus7qq4KO/XNhlgT2ibYZVCK19zKghFbq+BJVdG/tUtN2LGF4A42HnSY5iquaJ50jiAwQ+3M2x136NNwuU9CYd4NPZC694yq0YGAlxg47lYizYH/vtOPj8vnGppzLd2XeTx/Tu4ZG274CLwvo0T3X1lEz0n4nvE0Kwfg6ZiYZVEHDjqT/ZVSOV8E99ru2mO2Xcw/YFH0RFQftDQxSZpDOq9C37O8cA46h8Mxgi92h2NO4Ivd4ZgTzFRnD6GkbBTBtrqmCQL64PlUv6C96y5dFPPY5raQEO7uGcJGyA3WCFpHrUHK36QietFPrn5Xt0OvPKMrnzoj+n0D9LjtfW0iKcD3q1b5GVXXbIhp6MwFvV+wBl6FS8vSf92Mo7Mp/d/pGN74juxjFBlExxm1PEI+eGMGxabIw7hrovu2+nJum4p5ETzGlkHPbRjiy7QvEY2PXX5S1VXWwGsO9nGihjZ1lhAVyTUdERcvQDRbInWlJf0oYX8j1ua1uIlRdVopjiEyjWtAjsFmX6EOx2a+UdEuwPTWY51boQdkpQNjfjwY5QMsXGd3OBy+2B2OOcFsPeiYqTYK8KgYAoINED+6N3T6p0ZdRN+Ljwt/+M6W9rQLS3I5seE6G0A6nqs/ERNdYTnRYhERG5EWxZogmg764M1UaJHw9Jrw3ldiPcYUgmSSmv6tffw9T47LEYkpaLelAyJeuSHqyvauJsdo9URdwfTQTZNueR3MXDXjdVWAKS4HETOzqhGYqJaNuWoJxNY6pMWuGLNZXMh4s442YS6tnRuXX7siqaAqH/tF1W7t8iXpz4wxqqMXJIjqiWkHQSw2MCiEyVzsymMNRGudxkmf21JslAFNavK9NNbcg/G68Cg2jVrWOD1cIxXj4YfwN7vDMSfwxe5wzAl8sTscc4KZ6uxlWVKvOzQR7G1os9kAbAalcd/kgdStLQnxRO9A67ILj4vutr91Q9X1e+LWOEhFT7/8p7QJsFbIlAx6mgihFosOubAgqYE5+YFql1REx9vYv6rHWJE9gVPLOmrvPR+Sa9t57Y/H5SjWrr/nFyRiqzYwvPfgZtsHMk0b2dYAPbqRGDdYmKsA5B4Vo8vmcJgY8yASSdYroLPXtM6eg9tnZ18TMixCau2QQo6/qzod9/r7PjwuR7HVlY9+nx0KDrMpp1VbSDlt/FFZfW8y0cdhKkxBDsQcGx1pd9uQv7W6QPCiHwmivDf63LB2AvzN7nDMCXyxOxxzgtmmf0oqtHB2KJrduK7Na1mJRAXaQ+qxD/zyuNxcElF9fVF7rvVBgrve1eYSzkV8rEA6n6Wgf+8akJ6pXNKefOungG8sEq+totAEGN22RPQ165rr7GBbRNXlup7+elVMLVXwzFq7oM0pb70uaX1LE21WgFjcByKHrmmHV73W1EQOOD8HXUjLbDjiUIHol8ZcBdM/yOVszVKL2cvISRdsZB48E2vibVgzkWdaeD7u++vtvOfQ23Aa2dsxiOCIqNPXkXm3tkSlRS7G9o7mho9gjZxq6HvWG6lbEU2OYPQ3u8MxJ/DF7nDMCWYqxmeDAd25PqTD3TOUvzmIQBefeI+qW1i/MC7vbQid7k+u/kS16xUS7J+aLK4HPfHOegyyot54TY8jK8U7bfUxzUHXyyW7bMKSzfNgR/9m5pmIX+vndTADxkDsbevxrxZCsNEsRQSv1rTIdv6CtKuZnfTdloiIPZDoeobsoAJECLnhM2vA7nk/FvF/qarF1AEI0DYwoxuAgw7KCdnsujI/tapWV/BsZV2CTMpD7R7Fd9a03Xd9LzDwprUvKlprV3PhEXh7hoF+rj70oQ8REVG9NnlJP4qz5HA4HgJ8sTsccwJf7A7HnGCmOntRlGNO+MJEP1XqorckhnjwzR9+e1zegJTNdzbuqHYV0Fc6PZPCB37WApiCEkNU0GqLzWj7hjaR9LrQ/4G4Nw262p3pzCWJ6LvxmiYNXDkjutb2gU5RhSmaVmB+8rbeV0Dzz0ZPmxg3wKOuC7/lSUXf6hqkl2oY4ssa6N/VRPpftl5mEDmGOjoRUQREmE24n6sLWtdcgEhCuzeBZJo5nLs45CU3LeX0o4eFup6DblfMuO0D2VtaXtDzsQCpqdtt7V7XaQ33icriPjzomLnOzN9h5u8z88vM/HdHn68z8zeY+fXR/7V79eVwOE4OxxHjUyL6ZAjho0T0NBF9hpk/TkRfJKIXQghPEdELo2OHw/GI4ji53gJJQs3K6C8Q0WeJ6NnR518hom8S0Rem9cVxTNXlodkoGWjxMwYx8/bGlqrb2pbjAXKHVUwqHiBQYEPWUML5bt4RwodTy9pbL0AqntQkBM03wYMOUvicPqeDaU6vCckAr+kpTjtCZlFkWhTLVyAtEASqcEcTYEQR8KRHuv/1JemjDplELZnHuQURkc+saiKREsxyra6YAOsmmiapiji9bLKzBiCDqEF6pqbhua9O48CH+1mCzbK2rE2iPCWI5eQwOd3WXkerh2/ekOe7ADE8Mp6CGdyX5SX93L72xptERNRPdd+I4+Znj0cZXDeI6BshhG8T0bkQwi0iotH/s9P6cDgcJ4tjLfYQQhFCeJqILhLRx5j5I8c9ATM/x8xXmPnK7n7r3l9wOBwPBW9L/gkh7NFQXP8MEd1h5gtERKP/GxO+83wI4ZkQwjNrK0tHNXE4HDPAPXV2Zj5DRFkIYY+ZG0T054no7yHrWK8AAB0ySURBVBPR14noc0T05dH/r92rryiKqLkw1A8XgeubiKgF7rPtba3LlgH01yl85zFczuqiTouLLqEQTEV9wyVYq0FqXWOSQjfHU2dFb2w0tc5bh4i1psn11rwk6ZyTqtY9KQeCjQ3JM1ep6nEsA9Hm5TNaF2+A7tyuQb64XLdrQp81YwpCS1ZlV+5TsAFVoCvbvQPcg6kqwkndLkJd3+yzBNB7M5j7yI43ehR1dg18/tpmMyiDPHMFhAvuHGiTLpKA5LnWzbd390afTza9HcfOfoGIvsLDlRUR0VdDCL/LzH9IRF9l5s8T0VtE9CvH6MvhcJwQjrMb/wMi+vkjPt8mok89jEE5HI4HjxnzxhNVRuab9RXNiY3eU6UxWwxANMH0NtZvanVF/Hqai7r/EvjJa00giTA820kCJqOmrstzMUOFQsq1uhbH63UR3StV7QWl0y8fIkKTcUDqn+i09lda3hYxPu1r2boAvaQCom/X8OnlQIRgUwYpzrgERUdzLiD+yE0fMYj4MYjnsYnSi+CYjWfcAMYYQ9Rb/dQZercBOfrOrulns14R1a5zQXj3um2Tsnkgz9wbP9E8fIMReci05NuPvrLjcDgeCHyxOxxzgpmK8ZVakx77U08TEVFvXweBrIPnECd2WOA9Bdxb6MVGRFRvCqlDbAJtAoiEUYz9H483bCaAMXNDONcCa4/CJoj1C/taPG8Dh1kPLBwcZapdBhleBwMtg9dhpx6pmdnI+zHMXWy82BSdHKouZuc8gFeezZDaG8iO8/pp8dmqL2rvsXcDcDqaiVZXmqvwHGOZHlPtilJUtCfee1nVtbpDJ9f//X/6HyeOwd/sDsecwBe7wzEn8MXucMwJZqqzR3FMtYWhmara1FzrmFUnTnS0j/WUg5p7HEPNIcKDRxGQUnjp8XE529P84fESmPYaeu8jqcjcYRRZZPZBKjBVC02994G5kdC8Vpr7kKIZ1PCpV0E3R/3d+ndhIF1u02xnYN4EkovI5rJ610EbyAKkE8fJyoPejykK8bSrVHT6tKWF4f5GHE9OL+1vdodjTuCL3eGYE8xUjCeKKYrveptZX59oQnk+EdVEVA/V86quzK9DO6PyAFEEAflBUtOmtz6Qyl/d1KHHNQhcGUCAS8vwm+0BIUjTBOvgESYWrRmOeqDdU6QZRERckbaLC6hqvNvFeD0HeZCUYL1UTKdFoe8Zw5q5vXPL1A3nJM9djHc45h6+2B2OOYEvdodjTjBjnZ1Ifl/8d2Y6RC+tLJxTNdmW5AMjY1IbgKlsL4NcbCbHGoOJrj3QHPtbB3IcgynowBAjKGoFk265n0LEWpDvLVeMzg4uuJHpfwWi71ZW3+1M5XKdedlWNSmY1IIyTmqdvQDT5FpTR1rmxZBkJJ5ilvQV53DMCXyxOxxzghMQ4x1vF7EhwMgqwlPfz66puj6IxUgCcpBqk0w+ECE8NsQTFeCFyzIRHauGG74Et0cOuhP00AN6eYqM2akP5raKMcstgqfg4pLh63vXQa6tKDW3XFkczauYVLRnY8LyHAxYe9Dt7A4jI8tyMn2Fv9kdjjmBL3aHY07gYvy7AnqHtbIsQTJF5U9UXQEBKJj1M2RadGS485WgiT56kJ6oDWJ2YoJdGpDFNa5oER/pr3NIQ1UYKbMEtSM2O/rrwDVXqWhPwUcfliFRjpNYq2VpLoFOvb4EvxSFvmeDVKwwg0zv6Hda/dF3XIx3OOYevtgdjjmBL3aHY07gOvu7EHFN0k2dfvJnVN3t26LXHbTEMyup6lu9ugDHhTbLYdrgErjKrTqYxEhMOZlIMgNdPDWklREc24i4ROm9WH5Uo95kgoL2LzQw1wlknbVI+mDWun1oS3Rc36TxLvK7aboegM4+Stv8R8z8u6PjdWb+BjO/Pvr/bvdndDh+qvF2xPhfJ6JX4PiLRPRCCOEpInphdOxwOB5RHEuMZ+aLRPSfE9HfI6L/ZvTxZ4no2VH5KzRM5fyFBzs8x9EQMbaxqoNk1s8Kt9/1W3fG5cwQQzTgZz6Yuh6I1h0QrTumXR2k0apJ8ZoAK0UHAjoywxsfBTHZNaqac+1gU7KA91sitsZ1Ld4OUuk/MiR36FB2MJD+Y8PdnsBxxdRVICDHBpqgKlMGEK1Zq0Yl8Ml1Up26KQXvxmZN7l850HOaQ46tdq+j6rr9obm0tLm8AMd9s/9DIvpbpBWCcyGEW0REo/9nj/qiw+F4NHDPxc7Mf4mINkII330nJ2Dm55j5CjNf2dzcvPcXHA7HQ8Fx3uyfIKK/zMxXiei3iOiTzPxPiOgOM18gIhr93zjqyyGE50MIz4QQnjlz5t2XfdPh+GnBcfKzf4mIvkRExMzPEtF/G0L4q8z8PxDR54joy6P/X3uI43RMQGTMUAvgtpqD/mZNXl3Q/7K+NhN1wdxWQn6xYEx0PdCPU6MsIxFFn8Udt4hMdFwJEV817ba7ee2tcfnl9Jvj8uWfeVq165Tyznr9lauq7lJD8v9d7YtOvWsiz+IY01Rrnf3UmkTf5ZkmlHjilOjYj18Env6aiTIcm8aIsoHem9htCff/zU0hksy6+lwRdHmwqwlHaEQQEh5S1NuXiejTzPw6EX16dOxwOB5RvC2nmhDCN2m4604hhG0i+tSDH5LD4XgYcA+6dzlKEA+JiAjSHC9B5NnunhYJez0RY9Ou7qPflz4yFOmNC10HiC1yS4ChUk9Bu8iY78B0Ffpa0GwfyHEPTG+tvR3Vbv38E+Py9vYdVbebiVi8XJNUz1vpvmpXYsppE923vSOmvnqlpupe/9Eb4/LTl0RlOP+zqplO5TQwfPADOXfn4GBcLky7hVg8JwMb7vlRVGMI9296czgc73L4Ync45gQuxp8grMgVYMc864HHVVsTFSwuADHE7R+pusG+iKdLsKlcNQESd9rSf5bqneleD8R42H1mE6jSRTHeBskg6UUi5WpV91EtZJBlqqpokBydeXfzjt7Nbh+IWJ8V+ju3unLuy5BSKze78Z2A1gQtxnf2Zb4vnNbZh/f2t8flb++ICvGJ5IJqt/Y+6T9tafF8efn0uBwSudftUr+LV1ZFjKdSe9Bt5EMVJUzMeOxvdodjbuCL3eGYE/hidzjmBCegs9/V2R5VAoIHC6uXd8HMtbe1p+qaYAF77boQSS4tac+yC3XRWfdu/FjV9bqg3wM3/Iq507ugw3eMV9ggE1ctjMgKJrJtAKa4Mky5nzAFK1WtU8a5KOqFTWWM5BjwWurnuo88BzNiqev2OzLGbSBzjI15rYeegmb4DJ/sG1KKGIg+bu2K2ez7L2oPt2fPgS3OkEUetMXTfG1NuOJXuK7adQZb43IZ63tWGzWN2E1vDsfcwxe7wzEncNPbA4BNuTMAz6eO8U576yfXx+XkQJtP9roi0r61e2Nc/jDr1Ee3NiRU+GB7W9VFQBSBHljVUgeqnAXvulDRIm0K5qoSvpcZDzrkKD8sPMonTei/UWrxM4BUnJkxMqgaFcV3p0X1Ajjx+8Zc1W2LeL4Zixh/KtGqUVYAwYYxU6IqFudaPF9bEI+6bkfUstfb2kPvie9fHJc/8st/Wo8xE97AdibPS4j1OPYhYGmrp5+rM6uXiIgoSiYvaX+zOxxzAl/sDsecwBe7wzEnOAGd/afD5JaCi+nOjjah9SBqrNXS/N5bm+JSeT7Tc3EHSAx6oP/tbGrdvuhIu35Xm3ESIIcoQZfFFM1ERFEuuuzZmtaBF9fE5LMJw9/v6T7SDFI2G60du2wS6OIm51wO+x1lofX5Mof9ByB9rFq9FFJJp4UxqQEBxIBE325UtVkrwLlTY76qASFIMPNIVTkOmfS/aebqO3/w++NyYqLZTp0X0tDmuuzPJMZeWoeceWXvZVWXJtuj69CkGQh/szsccwJf7A7HnMBNb28DyE9+46Z4PXW6WsyuVcWs0zNi9gD4vrOBFhdvH4hJrdcDvjQTUlam0kee6VCxBERQRs8yE9mGXGqFEf0qYGo6VZNHpG7E224qYiV63RERReBtxzD+3JgpA3igEet3Tx7jGGUcZUWbzRjc63paQqYemDML8PLbN+oEpprqmvlIwLzWXNCc9flATGAFlDs9HZl3tS8i/sqL/0HVnV6RdNSVmpRXzjym2q1fvjwun1mwCZiGF85T1GR/szsccwJf7A7HnMDF+GkwQSx7OxLosLsnHlLMRswG8Xl3T3u4leD51DPpfVog8ndA3D9ItWyaFNK/3cEeYLAK7GZbCmQkpchys4ML143BL4khr6hC2QqPBZJBwNest2GpAlJ0LyozLF6XCchBMT5NTSqrHorxMpBNI8afBaKMwszVLVDTWi29ZJbqcrx9IKJ7atQa5Oi7FvS5K0HUBNRQWvs6FcPO7avj8vn3vFfVXXz6Q8Pvx1rFQfib3eGYE/hidzjmBL7YHY45gevsU5D3te62vSuea13QqSMTJVWtgA5popPiFMgrujqCCvX0fh/MOIaooB5AHzT6ttKJQZ8vTbsCTF5ZZvIcq70KKBtdOYY647hGqN4r0gtDGqG6NH0EeBdhpmS7PxCBzp4Z77QBzDdaMHcirTevgMmrUuj52Ifjfl/vW2wS7m+oi9bjgHa3DSnm6ZrUrSxKHZv9mNaeeF/mP9Lm3rR1MPqvP0ccNz/7VSJqEVFBRHkI4RlmXieif0ZETxLRVSL6L0IIu5P6cDgcJ4u3I8b/uRDC0yGEZ0bHXySiF0IITxHRC6Njh8PxiOJ+xPjPEtGzo/JXaJgD7gv3OZ6TB0hf7V1NQLAPQS0ZpFmyvF8H+9Ku0z5QdUvgSXXQ1UEy/VTq0hSCadgEsTCImUbkLOEYy1QaMR6yrBa2D0sCP8JhnntUGXQfOpvoZPFWHbMV0KFuMq07EWSCzVLtUZgC7xzE7ZChqKd9MBXWzSswB9NnbudgQrqlw5/L8XZk0ku1QIxvCgedcShU96Xb1sFXt38yvE6bIRZx3Dd7IKJ/x8zfZebnRp+dCyHcIiIa/T97zL4cDscJ4Lhv9k+EEG4y81ki+gYz/+ie3xhh9OPwHBHRZfDtdTgcs8Wx3uwhhJuj/xtE9DtE9DEiusPMF4iIRv83Jnz3+RDCMyGEZ86cOfNgRu1wON427vlmZ+YFIopCCK1R+S8Q0X9PRF8nos8R0ZdH/7/2MAc6K6CJam/XklKITt3vSbnb0bp3D3Tx1ES9NYDYot0zEXGgb6LOTsa9sp5M1pVx/EpvNmSOqG/bVMyow6Mpr7T6KtjXSuvCCjqqMpuZPgp1bEx7Qd5FaKyyDqEBdPYiN6Y3IJvI4FqCUfw3YH4u16qqLgbX2q6N2lPbEUjmYcYI82F3RDZhz+csJOhbXtBXintDpSHuTPv56HNjRgUcR4w/R0S/w8PNk4SI/q8Qwr9h5heJ6KvM/HkieouIfuUYfTkcjhPCPRd7COFNIvroEZ9vE9GnHsagHA7Hg4d70BnutEFHPJB29rXpDb3a+n30dtOecCm0y/rag64A8bxt6vpQNwDTXpZrMX4B0h5XjfiszW3l0WV7bMR4hj4DiIWHTG9TxNYK8KUlGLxmzXpg8rKWN6SzR4E2KvQ4SkIxXpsYUR1ClcEaxnZAVD9taqvK21DfiwmWt0PAubIscRsg2J8/kCVptAlKYE4j67E4vk+e/snhmHv4Ync45gS+2B2OOcGc6uyguxlywYOtnXF535jN0NzWg2i21Ojs2K60daBDdvratRFdcNEMVxg9sQMmryg27C5I9Ih6+SE3VWh3yBgEuc0I25k+4FXBxrczAZaZBBTMgdGpA5iTKkYRxWjCGK/ZKvdwPDBzlcKcqkg83YNypd2L9LUgX3uwjD8TTG/2DEgEGUzdHuwJbB2I6W1lUS/PRg1MkeY1zaN5nLaF4G92h2NO4Ivd4ZgTzJEYD6I7eFllLR2Vtr0hXr8tI8b3gFwi7R3tTXfouK/jq7oguvcGum4A3O4DJIQ0hAxtkEcXTYgWHkVoGjOReWxtNwCURvHMwaYyBtE0inT/wN9IFeU9pttV4qM97YZjvnd5eCx9pJa8Ao6tByACazb17aRLTSGEjHLtoTbIJ3ismTEq1cMMow1RjFsduYOn29r2lsSSsqrU/BcURcN7M80U6G92h2NO4Ivd4ZgTnIAYf1cUfMi/M9azDNP0tCVQZe/Opmq3uweZVHuG5wsDYaCcGk+4ARAIJFZUh+O+rYOd5GxwtEhPRHQAJOQXqjVVh55rDKKjne14shRPBe7ig4hsd5FxJ52MmlCFHe0I1A6TMJaUvGtkUBw/bvZbUgfkZD8walMG/O1higcdwqbbOgUugFXjiYgee9P61KqH4eGDL26zjH+npa01C03wrjN3VPgA3YPO4Zh7+GJ3OOYEvtgdjjnBCejsxwwTekddi/5U9rW+PQATW3dfSCn2t3Uutr2OmNt6xqTWm2BuO6Szg/dbbaA9utDc1kutPi+6uTK9WZ0dItG6DX0LFytironht9yq6Mq7znrQgYIJ/BFUmlxvNM0cBtFsEdjU6kZpRx7MaSSNOI5g9gcGmYx/u2N0dvTYUx50Zv8Bv2OGsduTMQ/MXlAOpjfs014Jmt7svWhEMCcQgXjQ0c9OfyDnsh50d82gbnpzOBy+2B2OecEJiPEP8PclaPG27AP3myGe6ByAGA/87wf72oPuoItivFYF+uhB1z+a451Ic5cHY17rwrH19kJihAy9/AyvWgHmpFttLRSegRTCGM9hHNxUSibrWVZOSGN0yOmOJ8uMSICB6ZkSI38W0EdhSDRUlmYcn9E69nqQIrutzVWFErMnQ4WwmPnYgKCnyATJ5IrcAyosuQR8kBidZymRe8agKrW6+r73U7nv9Yoex70Nb/5mdzjmBr7YHY45gS92h2NO8C6MegNO81TztQ/ApNY90Lp4H0xqaVd0b8zfRkTUAr28Z4kkIf3vIO0fWSYiKkEvZ2M2ayE3vCFamGRus6a3HHT22y0ddfW+ZXGfrdSAptH6mPIU0xsSW4SjXWeJtLntkKlJtZsc9YbjCtbFGfRc3EcojNJ+bVfuWTvVc5pbc+ExYPcw2iXuP0wOzVNV5rQ4jNJ0sQVpoJdBf7eexe2ePAeLTb1047vjcNObw+Hwxe5wzAnedWJ8yICTfX9H1XXBS67f0WazDETwvhLjtbjf7k7mgx/0UXRHE5oW4yvIe2bSM7UmEFQQaXE9B8+v3BAkoLnnoKf7uL4n4185szwuW68zlPcsBx2DiF/y0WY4IqIyTI6qQ9NTRBNEXSLK4diKt0r0hYPOQM/HG1uQStvM1SSp9rCnWZhcB4M+VIfc9uAJ1zQmxhY8B5buAjkFcUHWjOrV7cszUVjawAfFQcfMq8z8z5n5R8z8CjP/EjOvM/M3mPn10f+14/TlcDhOBscV4/9nIvo3IYQP0jAV1CtE9EUieiGE8BQRvTA6djgcjyiOk8V1mYj+LBH9V0REIYQBEQ2Y+bNE9Oyo2VeI6JtE9IXpvQUKNBRxmWqmbgqbAgRV5G0R3Xst7SWHu+wDI4LnIFq39uR7na5ul0GAS2522bXojqma9A5wDXbLU0Od3MkwrZMR41F0hz5yQ3eNXmGFURNe3RK15PyCzPGZpsl9CvKozfxpd8XHsLxqUE7MayNWxBNHE2oQ6cyktg457zB109UdraJdh934Q154NAk2lRUc2EexxPHrKgxwOQPWD/sWTeFaOjbTKvTZgVu9EOv9+B54XGaFtWo8mECY9xLRJhH9n8z8R8z8f4xSN58LIdwaniDcIqKzx+jL4XCcEI6z2BMi+gUi+t9CCD9PRB16GyI7Mz/HzFeY+crm5ua9v+BwOB4KjrPYrxPR9RDCt0fH/5yGi/8OM18gIhr93zjqyyGE50MIz4QQnjlz5syDGLPD4XgHOE5+9tvMfI2ZPxBCeJWGOdl/OPr7HBF9efT/a/c+XUlDlZ+I2eSjnaKzhxwIH8Dc1uto77cemNsKE23W64gufnAg3yuMbr8M+jcbXfwATGxIHBlM1FsT1MaO6aM/zTMOdPgcdHFrekM9vTB1u6DXvXRb5uqXLp1S7apIShGMDjkhFXNk7hHqr9azTEXcqa6NrgzXEpk6JMXc7ct1ffetLdWuNwDSkmNyw0/T2e21qD4PRbNBGUxoy1W9tLqwHzMwWyIp9J/CnkPPmlyhzursPI1BdITj2tn/OhH9Jg9X6JtE9F/T8B5+lZk/T0RvEdGvHLMvh8NxAjjWYg8hfI+Injmi6lMPdjgOh+NhYcYedBExN0fle4sdd5F1xFTW3Qde95ZOzzQALrjcBJl0QeRvwff6Pc0f1wPT2L7xjEvBFJeD6L6QadMYTuqOMd8hYUWWTTapKTG+sGJ8PrGuBPHutU2Zt9WavtUfOrN05HiJjOjOk81OCoeyxKJpT8TPyX58dGgHqdWV6/wPb9welzHwhYgon5atdsK5rDoRx9HEOhTjrXkQTX3X2jKuxdVl1W4FAlz6NoUUiP8leC92rMkVhjWwAT6jLicYTYnIfeMdjrmBL3aHY07gi93hmBPMWGcPRHRXlzbum+pY6yNpG/T0triDpkbfzjE/mtGVe+AW2wGX2J5pt1eITt0tJhNCFmA2Y+MSO4Dht4zpDaPZrKsr6t/FhPLwGKLSDJEDmmcGUL5yTZurmmCqeXKtqeoqKmJNcMidFUkprPemyhcnvVidEvXjg1TP4wuv3hqXX7opz0BuXGKnmdsmwX4HiR5jQyoZphBnYD9oXrvW0Sbd9y0tjMtLiXaDTYH3vgfP/sCeC/YVepmuy0bjP8TtD/A3u8MxJ/DF7nDMCfhwyp2HeDLmTSL6CRGdJqKtezSfBXwcGj4OjUdhHG93DE+EEI70S5/pYh+flPlKCOEoJx0fh4/Dx/GQxuBivMMxJ/DF7nDMCU5qsT9/Que18HFo+Dg0HoVxPLAxnIjO7nA4Zg8X4x2OOcFMFzszf4aZX2XmN5h5Zmy0zPwbzLzBzC/BZzOnwmbmS8z870d03C8z86+fxFiYuc7M32Hm74/G8XdPYhwwnnjEb/i7JzUOZr7KzH/MzN9j5isnOI6HRts+s8XOzDER/a9E9J8R0YeJ6FeZ+cMzOv0/JqLPmM9Oggo7J6K/GUL4EBF9nIh+bTQHsx5LSkSfDCF8lIieJqLPMPPHT2Acd/HrNKQnv4uTGsefCyE8DaaukxjHw6NtDyHM5I+IfomI/i0cf4mIvjTD8z9JRC/B8atEdGFUvkBEr85qLDCGrxHRp09yLETUJKL/RER/5iTGQUQXRw/wJ4nod0/q3hDRVSI6bT6b6TiIaJmIfkyjvbQHPY5ZivGPE9E1OL4++uykcKJU2Mz8JBH9PBF9+yTGMhKdv0dDotBvhCGh6EnMyT8kor9FOkbmJMYRiOjfMfN3mfm5ExrHQ6Vtn+ViP4rnZC5NAcy8SES/TUR/I4RwcK/2DwMhhCKE8DQN36wfY+aPzHoMzPyXiGgjhPDdWZ/7CHwihPALNFQzf42Z/+wJjOG+aNvvhVku9utEdAmOLxLRzRme3+JYVNgPGsxcoeFC/80Qwr84ybEQEYUQ9miYzeczJzCOTxDRX2bmq0T0W0T0SWb+JycwDgoh3Bz93yCi3yGij53AOO6Ltv1emOVif5GInmLm94xYav8KEX19hue3+DoNKbCJjk2FfX/gYUD4PyKiV0II/+CkxsLMZ5h5dVRuENGfJ6IfzXocIYQvhRAuhhCepOHz8P+GEP7qrMfBzAvMvHS3TER/gYhemvU4Qgi3iegaM39g9NFd2vYHM46HvfFhNhr+IhG9RkR/QkR/Z4bn/adEdIuIMhr+en6eiE7RcGPo9dH/9RmM45dpqLr8gIi+N/r7i7MeCxH9HBH90WgcLxHRfzf6fOZzAmN6lmSDbtbz8V4i+v7o7+W7z+YJPSNPE9GV0b35l0S09qDG4R50DsecwD3oHI45gS92h2NO4Ivd4ZgT+GJ3OOYEvtgdjjmBL3aHY07gi93hmBP4Ync45gT/Px7IuskMqdNWAAAAAElFTkSuQmCC\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": 4,
   "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",
    "            tf.keras.Input(shape=(64 , 64 ,3)),\n",
    "            ## ZeroPadding2D with padding 3, input shape of 64 x 64 x 3\n",
    "            tfl.ZeroPadding2D(padding=3), # As import tensorflow.keras.layers as tfl\n",
    "            ## Conv2D with 32 7x7 filters and stride of 1\n",
    "            tfl.Conv2D(filters=32,kernel_size=7,strides=1),\n",
    "            ## BatchNormalization for axis 3\n",
    "            tfl.BatchNormalization(axis=3, momentum=0.99, epsilon=0.001),\n",
    "            ## ReLU\n",
    "            tfl.ReLU(),\n",
    "            ## Max Pooling 2D with default parameters\n",
    "            tfl.MaxPool2D(),\n",
    "            ## Flatten layer\n",
    "            tfl.Flatten(),\n",
    "            ## Dense layer with 1 unit for output & 'sigmoid' activation\n",
    "            tfl.Dense(1,activation='sigmoid')\n",
    "        ])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 6,
   "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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "zero_padding2d (ZeroPadding2 (None, 70, 70, 3)         0         \n",
      "_________________________________________________________________\n",
      "conv2d (Conv2D)              (None, 64, 64, 32)        4736      \n",
      "_________________________________________________________________\n",
      "batch_normalization (BatchNo (None, 64, 64, 32)        128       \n",
      "_________________________________________________________________\n",
      "re_lu (ReLU)                 (None, 64, 64, 32)        0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d (MaxPooling2D) (None, 32, 32, 32)        0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 32768)             0         \n",
      "_________________________________________________________________\n",
      "dense (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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "38/38 [==============================] - 4s 97ms/step - loss: 1.8665 - accuracy: 0.6350\n",
      "Epoch 2/10\n",
      "38/38 [==============================] - 3s 89ms/step - loss: 0.5409 - accuracy: 0.8083\n",
      "Epoch 3/10\n",
      "38/38 [==============================] - 3s 89ms/step - loss: 0.1726 - accuracy: 0.9417\n",
      "Epoch 4/10\n",
      "38/38 [==============================] - 3s 92ms/step - loss: 0.1213 - accuracy: 0.9533\n",
      "Epoch 5/10\n",
      "38/38 [==============================] - 3s 90ms/step - loss: 0.1006 - accuracy: 0.9650\n",
      "Epoch 6/10\n",
      "38/38 [==============================] - 3s 90ms/step - loss: 0.0833 - accuracy: 0.9750\n",
      "Epoch 7/10\n",
      "38/38 [==============================] - 3s 89ms/step - loss: 0.1594 - accuracy: 0.9517\n",
      "Epoch 8/10\n",
      "38/38 [==============================] - 3s 90ms/step - loss: 0.0758 - accuracy: 0.9783\n",
      "Epoch 9/10\n",
      "38/38 [==============================] - 3s 92ms/step - loss: 0.0729 - accuracy: 0.9750\n",
      "Epoch 10/10\n",
      "38/38 [==============================] - 3s 90ms/step - loss: 0.0660 - accuracy: 0.9767\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f0009173290>"
      ]
     },
     "execution_count": 8,
     "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": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 0s 25ms/step - loss: 0.2836 - accuracy: 0.8800\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.28363028168678284, 0.8799999952316284]"
      ]
     },
     "execution_count": 9,
     "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": 10,
   "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": 11,
   "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": 12,
   "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": 13,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f58643806aa8380c96225fc8b4c5e7aa",
     "grade": false,
     "grade_id": "cell-dac51744a9e03f51",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: convolutional_model\n",
    "\n",
    "def convolutional_model(input_shape):\n",
    "    \"\"\"\n",
    "    Implements the forward propagation for the model:\n",
    "    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> DENSE\n",
    "    \n",
    "    Note that for simplicity and grading purposes, you'll hard-code some values\n",
    "    such as the stride and kernel (filter) sizes. \n",
    "    Normally, functions should take these values as function parameters.\n",
    "    \n",
    "    Arguments:\n",
    "    input_img -- input dataset, of shape (input_shape)\n",
    "\n",
    "    Returns:\n",
    "    model -- TF Keras model (object containing the information for the entire training process) \n",
    "    \"\"\"\n",
    "\n",
    "    input_img = tf.keras.Input(shape=input_shape)\n",
    "    ## CONV2D: 8 filters 4x4, stride of 1, padding 'SAME'\n",
    "    Z1 = tfl.Conv2D(filters= 8. , kernel_size=4 , padding='same',strides=1)(input_img)\n",
    "    ## RELU\n",
    "    A1 = tfl.ReLU()(Z1)\n",
    "    ## MAXPOOL: window 8x8, stride 8, padding 'SAME'\n",
    "    P1 = tfl.MaxPool2D(pool_size=8, strides=8, padding='SAME')(A1)\n",
    "    ## CONV2D: 16 filters 2x2, stride 1, padding 'SAME'\n",
    "    Z2 = tfl.Conv2D(filters= 16. , kernel_size=2 , padding='same',strides=1)(P1)\n",
    "    ## RELU\n",
    "    A2 =  tfl.ReLU()(Z2)\n",
    "    ## MAXPOOL: window 4x4, stride 4, padding 'SAME'\n",
    "    P2 = tfl.MaxPool2D(pool_size=4, strides=4, padding='SAME')(A2)\n",
    "    ## FLATTEN\n",
    "    F = tfl.Flatten()(P2)\n",
    "    ## Dense layer\n",
    "    ## 6 neurons in output layer. Hint: one of the arguments should be \"activation='softmax'\" \n",
    "    outputs = tfl.Dense(units= 6 , activation='softmax')(F)\n",
    "    model = tf.keras.Model(inputs=input_img, outputs=outputs)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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_2 (InputLayer)         [(None, 64, 64, 3)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 64, 64, 8)         392       \n",
      "_________________________________________________________________\n",
      "re_lu_1 (ReLU)               (None, 64, 64, 8)         0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 8, 8, 8)           0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 8, 8, 16)          528       \n",
      "_________________________________________________________________\n",
      "re_lu_2 (ReLU)               (None, 8, 8, 16)          0         \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 2, 2, 16)          0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_1 (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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "17/17 [==============================] - 2s 106ms/step - loss: 1.8500 - accuracy: 0.1750 - val_loss: 1.8041 - val_accuracy: 0.2000\n",
      "Epoch 2/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7950 - accuracy: 0.1833 - val_loss: 1.7918 - val_accuracy: 0.0917\n",
      "Epoch 3/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 1.7856 - accuracy: 0.1889 - val_loss: 1.7851 - val_accuracy: 0.1667\n",
      "Epoch 4/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7788 - accuracy: 0.2083 - val_loss: 1.7784 - val_accuracy: 0.2000\n",
      "Epoch 5/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7720 - accuracy: 0.2602 - val_loss: 1.7757 - val_accuracy: 0.2000\n",
      "Epoch 6/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7658 - accuracy: 0.2778 - val_loss: 1.7698 - val_accuracy: 0.2833\n",
      "Epoch 7/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7582 - accuracy: 0.3083 - val_loss: 1.7644 - val_accuracy: 0.2750\n",
      "Epoch 8/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7504 - accuracy: 0.3324 - val_loss: 1.7571 - val_accuracy: 0.2833\n",
      "Epoch 9/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7405 - accuracy: 0.3491 - val_loss: 1.7483 - val_accuracy: 0.3083\n",
      "Epoch 10/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7293 - accuracy: 0.3750 - val_loss: 1.7378 - val_accuracy: 0.3417\n",
      "Epoch 11/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.7160 - accuracy: 0.3944 - val_loss: 1.7252 - val_accuracy: 0.3917\n",
      "Epoch 12/100\n",
      "17/17 [==============================] - 2s 94ms/step - loss: 1.6999 - accuracy: 0.4074 - val_loss: 1.7102 - val_accuracy: 0.3833\n",
      "Epoch 13/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 1.6807 - accuracy: 0.4148 - val_loss: 1.6925 - val_accuracy: 0.3917\n",
      "Epoch 14/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.6586 - accuracy: 0.4287 - val_loss: 1.6710 - val_accuracy: 0.4167\n",
      "Epoch 15/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.6322 - accuracy: 0.4407 - val_loss: 1.6454 - val_accuracy: 0.3917\n",
      "Epoch 16/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 1.6002 - accuracy: 0.4639 - val_loss: 1.6158 - val_accuracy: 0.4500\n",
      "Epoch 17/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.5643 - accuracy: 0.4880 - val_loss: 1.5819 - val_accuracy: 0.4333\n",
      "Epoch 18/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.5237 - accuracy: 0.5009 - val_loss: 1.5423 - val_accuracy: 0.4833\n",
      "Epoch 19/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.4794 - accuracy: 0.5250 - val_loss: 1.5008 - val_accuracy: 0.5083\n",
      "Epoch 20/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 1.4315 - accuracy: 0.5444 - val_loss: 1.4554 - val_accuracy: 0.5333\n",
      "Epoch 21/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.3813 - accuracy: 0.5565 - val_loss: 1.4075 - val_accuracy: 0.5583\n",
      "Epoch 22/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.3309 - accuracy: 0.5741 - val_loss: 1.3589 - val_accuracy: 0.5583\n",
      "Epoch 23/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 1.2823 - accuracy: 0.5861 - val_loss: 1.3120 - val_accuracy: 0.5667\n",
      "Epoch 24/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.2359 - accuracy: 0.6074 - val_loss: 1.2673 - val_accuracy: 0.5750\n",
      "Epoch 25/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.1908 - accuracy: 0.6241 - val_loss: 1.2248 - val_accuracy: 0.6000\n",
      "Epoch 26/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.1485 - accuracy: 0.6454 - val_loss: 1.1845 - val_accuracy: 0.6000\n",
      "Epoch 27/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 1.1099 - accuracy: 0.6528 - val_loss: 1.1474 - val_accuracy: 0.6250\n",
      "Epoch 28/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.0734 - accuracy: 0.6657 - val_loss: 1.1134 - val_accuracy: 0.6250\n",
      "Epoch 29/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.0389 - accuracy: 0.6741 - val_loss: 1.0801 - val_accuracy: 0.6417\n",
      "Epoch 30/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 1.0072 - accuracy: 0.6806 - val_loss: 1.0503 - val_accuracy: 0.6667\n",
      "Epoch 31/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.9784 - accuracy: 0.6917 - val_loss: 1.0227 - val_accuracy: 0.6667\n",
      "Epoch 32/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.9518 - accuracy: 0.7028 - val_loss: 0.9967 - val_accuracy: 0.6667\n",
      "Epoch 33/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.9263 - accuracy: 0.7120 - val_loss: 0.9718 - val_accuracy: 0.6750\n",
      "Epoch 34/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.9025 - accuracy: 0.7259 - val_loss: 0.9481 - val_accuracy: 0.6917\n",
      "Epoch 35/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.8795 - accuracy: 0.7269 - val_loss: 0.9254 - val_accuracy: 0.6917\n",
      "Epoch 36/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.8572 - accuracy: 0.7333 - val_loss: 0.9031 - val_accuracy: 0.7000\n",
      "Epoch 37/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.8359 - accuracy: 0.7454 - val_loss: 0.8813 - val_accuracy: 0.7167\n",
      "Epoch 38/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.8146 - accuracy: 0.7537 - val_loss: 0.8584 - val_accuracy: 0.7250\n",
      "Epoch 39/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.7935 - accuracy: 0.7648 - val_loss: 0.8370 - val_accuracy: 0.7250\n",
      "Epoch 40/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.7740 - accuracy: 0.7769 - val_loss: 0.8172 - val_accuracy: 0.7333\n",
      "Epoch 41/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.7562 - accuracy: 0.7843 - val_loss: 0.7996 - val_accuracy: 0.7500\n",
      "Epoch 42/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.7394 - accuracy: 0.7926 - val_loss: 0.7822 - val_accuracy: 0.7500\n",
      "Epoch 43/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.7231 - accuracy: 0.8000 - val_loss: 0.7656 - val_accuracy: 0.7417\n",
      "Epoch 44/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.7077 - accuracy: 0.8019 - val_loss: 0.7491 - val_accuracy: 0.7667\n",
      "Epoch 45/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.6933 - accuracy: 0.8046 - val_loss: 0.7338 - val_accuracy: 0.7667\n",
      "Epoch 46/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.6795 - accuracy: 0.8102 - val_loss: 0.7193 - val_accuracy: 0.7667\n",
      "Epoch 47/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.6663 - accuracy: 0.8148 - val_loss: 0.7055 - val_accuracy: 0.7750\n",
      "Epoch 48/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.6544 - accuracy: 0.8167 - val_loss: 0.6922 - val_accuracy: 0.7667\n",
      "Epoch 49/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.6426 - accuracy: 0.8157 - val_loss: 0.6799 - val_accuracy: 0.7750\n",
      "Epoch 50/100\n",
      "17/17 [==============================] - 2s 94ms/step - loss: 0.6317 - accuracy: 0.8204 - val_loss: 0.6685 - val_accuracy: 0.7750\n",
      "Epoch 51/100\n",
      "17/17 [==============================] - 2s 94ms/step - loss: 0.6211 - accuracy: 0.8241 - val_loss: 0.6575 - val_accuracy: 0.7833\n",
      "Epoch 52/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.6108 - accuracy: 0.8269 - val_loss: 0.6472 - val_accuracy: 0.7917\n",
      "Epoch 53/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.6010 - accuracy: 0.8287 - val_loss: 0.6369 - val_accuracy: 0.8000\n",
      "Epoch 54/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5915 - accuracy: 0.8315 - val_loss: 0.6269 - val_accuracy: 0.7917\n",
      "Epoch 55/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5823 - accuracy: 0.8324 - val_loss: 0.6174 - val_accuracy: 0.7917\n",
      "Epoch 56/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5734 - accuracy: 0.8343 - val_loss: 0.6083 - val_accuracy: 0.8083\n",
      "Epoch 57/100\n",
      "17/17 [==============================] - 2s 101ms/step - loss: 0.5648 - accuracy: 0.8352 - val_loss: 0.5993 - val_accuracy: 0.8083\n",
      "Epoch 58/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17/17 [==============================] - 2s 96ms/step - loss: 0.5566 - accuracy: 0.8380 - val_loss: 0.5908 - val_accuracy: 0.8083\n",
      "Epoch 59/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.5487 - accuracy: 0.8407 - val_loss: 0.5824 - val_accuracy: 0.8083\n",
      "Epoch 60/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.5410 - accuracy: 0.8407 - val_loss: 0.5743 - val_accuracy: 0.8083\n",
      "Epoch 61/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5336 - accuracy: 0.8417 - val_loss: 0.5664 - val_accuracy: 0.8083\n",
      "Epoch 62/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5265 - accuracy: 0.8426 - val_loss: 0.5591 - val_accuracy: 0.8083\n",
      "Epoch 63/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5198 - accuracy: 0.8463 - val_loss: 0.5515 - val_accuracy: 0.8083\n",
      "Epoch 64/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5132 - accuracy: 0.8463 - val_loss: 0.5449 - val_accuracy: 0.8083\n",
      "Epoch 65/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5066 - accuracy: 0.8472 - val_loss: 0.5378 - val_accuracy: 0.8083\n",
      "Epoch 66/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.5004 - accuracy: 0.8491 - val_loss: 0.5311 - val_accuracy: 0.8083\n",
      "Epoch 67/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4942 - accuracy: 0.8500 - val_loss: 0.5249 - val_accuracy: 0.8250\n",
      "Epoch 68/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4885 - accuracy: 0.8519 - val_loss: 0.5187 - val_accuracy: 0.8250\n",
      "Epoch 69/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4827 - accuracy: 0.8546 - val_loss: 0.5126 - val_accuracy: 0.8250\n",
      "Epoch 70/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4770 - accuracy: 0.8583 - val_loss: 0.5065 - val_accuracy: 0.8250\n",
      "Epoch 71/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4714 - accuracy: 0.8611 - val_loss: 0.5011 - val_accuracy: 0.8333\n",
      "Epoch 72/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4661 - accuracy: 0.8620 - val_loss: 0.4958 - val_accuracy: 0.8333\n",
      "Epoch 73/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4609 - accuracy: 0.8630 - val_loss: 0.4909 - val_accuracy: 0.8333\n",
      "Epoch 74/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4557 - accuracy: 0.8648 - val_loss: 0.4858 - val_accuracy: 0.8333\n",
      "Epoch 75/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4509 - accuracy: 0.8657 - val_loss: 0.4809 - val_accuracy: 0.8333\n",
      "Epoch 76/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4459 - accuracy: 0.8657 - val_loss: 0.4763 - val_accuracy: 0.8417\n",
      "Epoch 77/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4411 - accuracy: 0.8667 - val_loss: 0.4716 - val_accuracy: 0.8417\n",
      "Epoch 78/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4366 - accuracy: 0.8694 - val_loss: 0.4671 - val_accuracy: 0.8417\n",
      "Epoch 79/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4320 - accuracy: 0.8713 - val_loss: 0.4630 - val_accuracy: 0.8417\n",
      "Epoch 80/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4275 - accuracy: 0.8722 - val_loss: 0.4590 - val_accuracy: 0.8417\n",
      "Epoch 81/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4235 - accuracy: 0.8750 - val_loss: 0.4550 - val_accuracy: 0.8417\n",
      "Epoch 82/100\n",
      "17/17 [==============================] - 2s 94ms/step - loss: 0.4194 - accuracy: 0.8750 - val_loss: 0.4509 - val_accuracy: 0.8417\n",
      "Epoch 83/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4153 - accuracy: 0.8759 - val_loss: 0.4477 - val_accuracy: 0.8417\n",
      "Epoch 84/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4115 - accuracy: 0.8778 - val_loss: 0.4439 - val_accuracy: 0.8417\n",
      "Epoch 85/100\n",
      "17/17 [==============================] - 2s 94ms/step - loss: 0.4075 - accuracy: 0.8806 - val_loss: 0.4393 - val_accuracy: 0.8417\n",
      "Epoch 86/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.4038 - accuracy: 0.8806 - val_loss: 0.4359 - val_accuracy: 0.8417\n",
      "Epoch 87/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.4001 - accuracy: 0.8824 - val_loss: 0.4316 - val_accuracy: 0.8417\n",
      "Epoch 88/100\n",
      "17/17 [==============================] - 2s 101ms/step - loss: 0.3964 - accuracy: 0.8833 - val_loss: 0.4280 - val_accuracy: 0.8417\n",
      "Epoch 89/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3929 - accuracy: 0.8843 - val_loss: 0.4242 - val_accuracy: 0.8417\n",
      "Epoch 90/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3893 - accuracy: 0.8833 - val_loss: 0.4208 - val_accuracy: 0.8417\n",
      "Epoch 91/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3858 - accuracy: 0.8833 - val_loss: 0.4178 - val_accuracy: 0.8417\n",
      "Epoch 92/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3823 - accuracy: 0.8833 - val_loss: 0.4147 - val_accuracy: 0.8417\n",
      "Epoch 93/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3788 - accuracy: 0.8833 - val_loss: 0.4113 - val_accuracy: 0.8417\n",
      "Epoch 94/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.3756 - accuracy: 0.8843 - val_loss: 0.4085 - val_accuracy: 0.8417\n",
      "Epoch 95/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.3723 - accuracy: 0.8861 - val_loss: 0.4055 - val_accuracy: 0.8417\n",
      "Epoch 96/100\n",
      "17/17 [==============================] - 2s 95ms/step - loss: 0.3692 - accuracy: 0.8870 - val_loss: 0.4028 - val_accuracy: 0.8417\n",
      "Epoch 97/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3662 - accuracy: 0.8870 - val_loss: 0.4001 - val_accuracy: 0.8500\n",
      "Epoch 98/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3629 - accuracy: 0.8889 - val_loss: 0.3970 - val_accuracy: 0.8500\n",
      "Epoch 99/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3599 - accuracy: 0.8898 - val_loss: 0.3942 - val_accuracy: 0.8500\n",
      "Epoch 100/100\n",
      "17/17 [==============================] - 2s 100ms/step - loss: 0.3568 - accuracy: 0.8907 - val_loss: 0.3919 - val_accuracy: 0.8500\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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.849987268447876,\n",
       "  1.7949864864349365,\n",
       "  1.7856290340423584,\n",
       "  1.7787929773330688,\n",
       "  1.7720376253128052,\n",
       "  1.765804409980774,\n",
       "  1.7582045793533325,\n",
       "  1.7504322528839111,\n",
       "  1.7405381202697754,\n",
       "  1.729302167892456,\n",
       "  1.716004490852356,\n",
       "  1.6998562812805176,\n",
       "  1.6806929111480713,\n",
       "  1.6585853099822998,\n",
       "  1.6321953535079956,\n",
       "  1.6002265214920044,\n",
       "  1.5642940998077393,\n",
       "  1.5237151384353638,\n",
       "  1.4793531894683838,\n",
       "  1.4314864873886108,\n",
       "  1.3813401460647583,\n",
       "  1.3308688402175903,\n",
       "  1.2823097705841064,\n",
       "  1.2359447479248047,\n",
       "  1.1908009052276611,\n",
       "  1.1485068798065186,\n",
       "  1.1098839044570923,\n",
       "  1.0733731985092163,\n",
       "  1.0388779640197754,\n",
       "  1.007176160812378,\n",
       "  0.9784454107284546,\n",
       "  0.9517880082130432,\n",
       "  0.9262830018997192,\n",
       "  0.9024526476860046,\n",
       "  0.8794969320297241,\n",
       "  0.8571652770042419,\n",
       "  0.8358853459358215,\n",
       "  0.8145968317985535,\n",
       "  0.793536365032196,\n",
       "  0.7740085124969482,\n",
       "  0.7561525106430054,\n",
       "  0.7394397258758545,\n",
       "  0.723076581954956,\n",
       "  0.7076658010482788,\n",
       "  0.6932724714279175,\n",
       "  0.6794527769088745,\n",
       "  0.6663057208061218,\n",
       "  0.6544396281242371,\n",
       "  0.6425568461418152,\n",
       "  0.6316661238670349,\n",
       "  0.6210779547691345,\n",
       "  0.6107935309410095,\n",
       "  0.6010372042655945,\n",
       "  0.5914822816848755,\n",
       "  0.5822650194168091,\n",
       "  0.5733824968338013,\n",
       "  0.5647547245025635,\n",
       "  0.5565662384033203,\n",
       "  0.548717200756073,\n",
       "  0.5410350561141968,\n",
       "  0.5336402654647827,\n",
       "  0.5264644026756287,\n",
       "  0.5197781324386597,\n",
       "  0.5131890773773193,\n",
       "  0.5065944194793701,\n",
       "  0.50039142370224,\n",
       "  0.4942099153995514,\n",
       "  0.48853275179862976,\n",
       "  0.48268651962280273,\n",
       "  0.47702234983444214,\n",
       "  0.47143059968948364,\n",
       "  0.4660923182964325,\n",
       "  0.4608578085899353,\n",
       "  0.4556984305381775,\n",
       "  0.45089462399482727,\n",
       "  0.4458761513233185,\n",
       "  0.44108641147613525,\n",
       "  0.4366171360015869,\n",
       "  0.4320395290851593,\n",
       "  0.42752745747566223,\n",
       "  0.4234742820262909,\n",
       "  0.41942110657691956,\n",
       "  0.41534513235092163,\n",
       "  0.41152307391166687,\n",
       "  0.40751075744628906,\n",
       "  0.4038268029689789,\n",
       "  0.40010571479797363,\n",
       "  0.39643949270248413,\n",
       "  0.39285802841186523,\n",
       "  0.38931551575660706,\n",
       "  0.3858296573162079,\n",
       "  0.38231897354125977,\n",
       "  0.3788106143474579,\n",
       "  0.3756343126296997,\n",
       "  0.3722948431968689,\n",
       "  0.36922216415405273,\n",
       "  0.36620086431503296,\n",
       "  0.36289817094802856,\n",
       "  0.35990196466445923,\n",
       "  0.3567601144313812],\n",
       " 'accuracy': [0.17499999701976776,\n",
       "  0.18333333730697632,\n",
       "  0.18888889253139496,\n",
       "  0.2083333283662796,\n",
       "  0.260185182094574,\n",
       "  0.2777777910232544,\n",
       "  0.3083333373069763,\n",
       "  0.3324074149131775,\n",
       "  0.3490740656852722,\n",
       "  0.375,\n",
       "  0.39444443583488464,\n",
       "  0.40740740299224854,\n",
       "  0.4148148000240326,\n",
       "  0.4287036955356598,\n",
       "  0.4407407343387604,\n",
       "  0.46388888359069824,\n",
       "  0.4879629611968994,\n",
       "  0.5009258985519409,\n",
       "  0.5249999761581421,\n",
       "  0.5444444417953491,\n",
       "  0.5564814805984497,\n",
       "  0.5740740895271301,\n",
       "  0.5861111283302307,\n",
       "  0.6074073910713196,\n",
       "  0.6240741014480591,\n",
       "  0.645370364189148,\n",
       "  0.6527777910232544,\n",
       "  0.6657407283782959,\n",
       "  0.6740740537643433,\n",
       "  0.6805555820465088,\n",
       "  0.6916666626930237,\n",
       "  0.7027778029441833,\n",
       "  0.7120370268821716,\n",
       "  0.7259259223937988,\n",
       "  0.7268518805503845,\n",
       "  0.7333333492279053,\n",
       "  0.7453703880310059,\n",
       "  0.7537037134170532,\n",
       "  0.7648147940635681,\n",
       "  0.7768518328666687,\n",
       "  0.7842592597007751,\n",
       "  0.7925925850868225,\n",
       "  0.800000011920929,\n",
       "  0.8018518686294556,\n",
       "  0.8046296238899231,\n",
       "  0.8101851940155029,\n",
       "  0.8148148059844971,\n",
       "  0.8166666626930237,\n",
       "  0.8157407641410828,\n",
       "  0.8203703761100769,\n",
       "  0.8240740895271301,\n",
       "  0.8268518447875977,\n",
       "  0.8287037014961243,\n",
       "  0.8314814567565918,\n",
       "  0.8324074149131775,\n",
       "  0.8342592716217041,\n",
       "  0.835185170173645,\n",
       "  0.8379629850387573,\n",
       "  0.8407407402992249,\n",
       "  0.8407407402992249,\n",
       "  0.8416666388511658,\n",
       "  0.8425925970077515,\n",
       "  0.8462963104248047,\n",
       "  0.8462963104248047,\n",
       "  0.8472222089767456,\n",
       "  0.8490740656852722,\n",
       "  0.8500000238418579,\n",
       "  0.8518518805503845,\n",
       "  0.854629635810852,\n",
       "  0.8583333492279053,\n",
       "  0.8611111044883728,\n",
       "  0.8620370626449585,\n",
       "  0.8629629611968994,\n",
       "  0.864814817905426,\n",
       "  0.8657407164573669,\n",
       "  0.8657407164573669,\n",
       "  0.8666666746139526,\n",
       "  0.8694444298744202,\n",
       "  0.8712962865829468,\n",
       "  0.8722222447395325,\n",
       "  0.875,\n",
       "  0.875,\n",
       "  0.8759258985519409,\n",
       "  0.8777777552604675,\n",
       "  0.8805555701255798,\n",
       "  0.8805555701255798,\n",
       "  0.8824074268341064,\n",
       "  0.8833333253860474,\n",
       "  0.8842592835426331,\n",
       "  0.8833333253860474,\n",
       "  0.8833333253860474,\n",
       "  0.8833333253860474,\n",
       "  0.8833333253860474,\n",
       "  0.8842592835426331,\n",
       "  0.8861111402511597,\n",
       "  0.8870370388031006,\n",
       "  0.8870370388031006,\n",
       "  0.8888888955116272,\n",
       "  0.8898147940635681,\n",
       "  0.8907407522201538],\n",
       " 'val_loss': [1.804083228111267,\n",
       "  1.7917944192886353,\n",
       "  1.7850602865219116,\n",
       "  1.7783777713775635,\n",
       "  1.775740385055542,\n",
       "  1.769832968711853,\n",
       "  1.7644238471984863,\n",
       "  1.7570737600326538,\n",
       "  1.748292088508606,\n",
       "  1.7378169298171997,\n",
       "  1.7251583337783813,\n",
       "  1.710222840309143,\n",
       "  1.6925462484359741,\n",
       "  1.6710247993469238,\n",
       "  1.6453971862792969,\n",
       "  1.6158281564712524,\n",
       "  1.581863522529602,\n",
       "  1.542336106300354,\n",
       "  1.5007983446121216,\n",
       "  1.4553847312927246,\n",
       "  1.407475233078003,\n",
       "  1.3589348793029785,\n",
       "  1.3120170831680298,\n",
       "  1.2672572135925293,\n",
       "  1.224815845489502,\n",
       "  1.1845240592956543,\n",
       "  1.1474498510360718,\n",
       "  1.1134446859359741,\n",
       "  1.0801440477371216,\n",
       "  1.0503278970718384,\n",
       "  1.0226521492004395,\n",
       "  0.9966689348220825,\n",
       "  0.9718493223190308,\n",
       "  0.9480880498886108,\n",
       "  0.9254127740859985,\n",
       "  0.9030501246452332,\n",
       "  0.8812732696533203,\n",
       "  0.8584400415420532,\n",
       "  0.8369730114936829,\n",
       "  0.8172313570976257,\n",
       "  0.799575924873352,\n",
       "  0.7822080850601196,\n",
       "  0.7656044363975525,\n",
       "  0.7490721344947815,\n",
       "  0.7338330745697021,\n",
       "  0.7192934155464172,\n",
       "  0.7054542303085327,\n",
       "  0.6921920776367188,\n",
       "  0.6798759698867798,\n",
       "  0.6684601306915283,\n",
       "  0.6574611663818359,\n",
       "  0.6471512317657471,\n",
       "  0.6368777751922607,\n",
       "  0.626870334148407,\n",
       "  0.6174496412277222,\n",
       "  0.6082749962806702,\n",
       "  0.5992889404296875,\n",
       "  0.5908156037330627,\n",
       "  0.5823964476585388,\n",
       "  0.5743101835250854,\n",
       "  0.566351592540741,\n",
       "  0.5591393709182739,\n",
       "  0.5515310764312744,\n",
       "  0.5449287295341492,\n",
       "  0.5378201603889465,\n",
       "  0.5310679078102112,\n",
       "  0.5249351263046265,\n",
       "  0.5187358260154724,\n",
       "  0.5126311182975769,\n",
       "  0.5065131783485413,\n",
       "  0.5010789036750793,\n",
       "  0.4957960546016693,\n",
       "  0.4909020662307739,\n",
       "  0.4858386218547821,\n",
       "  0.4808921217918396,\n",
       "  0.4763074219226837,\n",
       "  0.47160446643829346,\n",
       "  0.4671270251274109,\n",
       "  0.4630276560783386,\n",
       "  0.4590393602848053,\n",
       "  0.45503151416778564,\n",
       "  0.4508741497993469,\n",
       "  0.44766589999198914,\n",
       "  0.4438987672328949,\n",
       "  0.4392799437046051,\n",
       "  0.4359198212623596,\n",
       "  0.43162447214126587,\n",
       "  0.42799705266952515,\n",
       "  0.42424994707107544,\n",
       "  0.4208294451236725,\n",
       "  0.41779905557632446,\n",
       "  0.4146507978439331,\n",
       "  0.4113177955150604,\n",
       "  0.4084583818912506,\n",
       "  0.4054824113845825,\n",
       "  0.4027934968471527,\n",
       "  0.4001171290874481,\n",
       "  0.3970135748386383,\n",
       "  0.394199401140213,\n",
       "  0.3918572664260864],\n",
       " 'val_accuracy': [0.20000000298023224,\n",
       "  0.09166666865348816,\n",
       "  0.1666666716337204,\n",
       "  0.20000000298023224,\n",
       "  0.20000000298023224,\n",
       "  0.28333333134651184,\n",
       "  0.2750000059604645,\n",
       "  0.28333333134651184,\n",
       "  0.3083333373069763,\n",
       "  0.34166666865348816,\n",
       "  0.3916666805744171,\n",
       "  0.38333332538604736,\n",
       "  0.3916666805744171,\n",
       "  0.4166666567325592,\n",
       "  0.3916666805744171,\n",
       "  0.44999998807907104,\n",
       "  0.4333333373069763,\n",
       "  0.4833333194255829,\n",
       "  0.5083333253860474,\n",
       "  0.5333333611488342,\n",
       "  0.5583333373069763,\n",
       "  0.5583333373069763,\n",
       "  0.5666666626930237,\n",
       "  0.574999988079071,\n",
       "  0.6000000238418579,\n",
       "  0.6000000238418579,\n",
       "  0.625,\n",
       "  0.625,\n",
       "  0.6416666507720947,\n",
       "  0.6666666865348816,\n",
       "  0.6666666865348816,\n",
       "  0.6666666865348816,\n",
       "  0.675000011920929,\n",
       "  0.6916666626930237,\n",
       "  0.6916666626930237,\n",
       "  0.699999988079071,\n",
       "  0.7166666388511658,\n",
       "  0.7250000238418579,\n",
       "  0.7250000238418579,\n",
       "  0.7333333492279053,\n",
       "  0.75,\n",
       "  0.75,\n",
       "  0.7416666746139526,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7666666507720947,\n",
       "  0.7749999761581421,\n",
       "  0.7666666507720947,\n",
       "  0.7749999761581421,\n",
       "  0.7749999761581421,\n",
       "  0.7833333611488342,\n",
       "  0.7916666865348816,\n",
       "  0.800000011920929,\n",
       "  0.7916666865348816,\n",
       "  0.7916666865348816,\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,\n",
       "  0.8083333373069763,\n",
       "  0.8083333373069763,\n",
       "  0.824999988079071,\n",
       "  0.824999988079071,\n",
       "  0.824999988079071,\n",
       "  0.824999988079071,\n",
       "  0.8333333134651184,\n",
       "  0.8333333134651184,\n",
       "  0.8333333134651184,\n",
       "  0.8333333134651184,\n",
       "  0.8333333134651184,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8416666388511658,\n",
       "  0.8500000238418579,\n",
       "  0.8500000238418579,\n",
       "  0.8500000238418579,\n",
       "  0.8500000238418579]}"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Accuracy'), Text(0.5, 0, 'Epoch')]"
      ]
     },
     "execution_count": 17,
     "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
}