Course2Week1ProgrammingAssignment1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dn-6c02VmqiN"
   },
   "outputs": [],
   "source": [
    "# ATTENTION: Please do not alter any of the provided code in the exercise. Only add your own code where indicated\n",
    "# ATTENTION: Please do not add or remove any cells in the exercise. The grader will check specific cells based on the cell position.\n",
    "# ATTENTION: Please use the provided epoch values when training.\n",
    "\n",
    "# In this exercise you will train a CNN on the FULL Cats-v-dogs dataset\n",
    "# This will require you doing a lot of data preprocessing because\n",
    "# the dataset isn't split into training and validation for you\n",
    "# This code block has all the required inputs\n",
    "import os\n",
    "import zipfile\n",
    "import random\n",
    "import tensorflow as tf\n",
    "import shutil\n",
    "from tensorflow.keras.optimizers import RMSprop\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from shutil import copyfile\n",
    "from os import getcwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3sd9dQWa23aj"
   },
   "outputs": [],
   "source": [
    "path_cats_and_dogs = f\"{getcwd()}/../tmp2/cats-and-dogs.zip\"\n",
    "shutil.rmtree('/tmp')\n",
    "\n",
    "local_zip = path_cats_and_dogs\n",
    "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
    "zip_ref.extractall('/tmp')\n",
    "zip_ref.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gi3yD62a6X3S"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1500\n",
      "1500\n"
     ]
    }
   ],
   "source": [
    "print(len(os.listdir('/tmp/PetImages/Cat/')))\n",
    "print(len(os.listdir('/tmp/PetImages/Dog/')))\n",
    "\n",
    "# Expected Output:\n",
    "# 1500\n",
    "# 1500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "F-QkLjxpmyK2"
   },
   "outputs": [],
   "source": [
    "# Use os.mkdir to create your directories\n",
    "# You will need a directory for cats-v-dogs, and subdirectories for training\n",
    "# and testing. These in turn will need subdirectories for 'cats' and 'dogs'\n",
    "try:\n",
    "   \n",
    "    os.mkdir('/tmp/cats-v-dogs')\n",
    "    \n",
    "    os.mkdir('/tmp/cats-v-dogs/training')\n",
    "    \n",
    "    os.mkdir('/tmp/cats-v-dogs/testing')\n",
    "    \n",
    "    os.mkdir('/tmp/cats-v-dogs/training/cats')\n",
    "    \n",
    "    os.mkdir('/tmp/cats-v-dogs/training/dogs')\n",
    "    \n",
    "    os.mkdir('/tmp/cats-v-dogs/testing/cats')\n",
    "    \n",
    "    os.mkdir('/tmp/cats-v-dogs/testing/dogs')\n",
    "    \n",
    "except OSError:\n",
    "    \n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zvSODo0f9LaU"
   },
   "outputs": [],
   "source": [
    "# Write a python function called split_data which takes\n",
    "# a SOURCE directory containing the files\n",
    "# a TRAINING directory that a portion of the files will be copied to\n",
    "# a TESTING directory that a portion of the files will be copie to\n",
    "# a SPLIT SIZE to determine the portion\n",
    "# The files should also be randomized, so that the training set is a random\n",
    "# X% of the files, and the test set is the remaining files\n",
    "# SO, for example, if SOURCE is PetImages/Cat, and SPLIT SIZE is .9\n",
    "# Then 90% of the images in PetImages/Cat will be copied to the TRAINING dir\n",
    "# and 10% of the images will be copied to the TESTING dir\n",
    "# Also -- All images should be checked, and if they have a zero file length,\n",
    "# they will not be copied over\n",
    "#\n",
    "# os.listdir(DIRECTORY) gives you a listing of the contents of that directory\n",
    "# os.path.getsize(PATH) gives you the size of the file\n",
    "# copyfile(source, destination) copies a file from source to destination\n",
    "# random.sample(list, len(list)) shuffles a list\n",
    "def split_data(SOURCE, TRAINING, TESTING, SPLIT_SIZE):\n",
    "    \n",
    "# YOUR CODE STARTS HERE\n",
    "\n",
    "    files = []\n",
    "    \n",
    "    for filename in os.listdir(SOURCE):\n",
    "        \n",
    "        file = SOURCE + filename\n",
    "        \n",
    "        if os.path.getsize(file) > 0:\n",
    "            \n",
    "            files.append(filename)\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            print(filename + \" is zero length, so ignoring.\")\n",
    "\n",
    "    training_length = int(len(files) * SPLIT_SIZE)\n",
    "    \n",
    "    testing_length = int(len(files) - training_length)\n",
    "    \n",
    "    shuffled_set = random.sample(files, len(files))\n",
    "    \n",
    "    training_set = shuffled_set[0:training_length]\n",
    "    \n",
    "    testing_set = shuffled_set[-testing_length:]\n",
    "\n",
    "    for filename in training_set:\n",
    "        \n",
    "        this_file = SOURCE + filename\n",
    "        \n",
    "        destination = TRAINING + filename\n",
    "        \n",
    "        copyfile(this_file, destination)\n",
    "\n",
    "    for filename in testing_set:\n",
    "        \n",
    "        this_file = SOURCE + filename\n",
    "        \n",
    "        destination = TESTING + filename\n",
    "        \n",
    "        copyfile(this_file, destination)\n",
    "        \n",
    "# YOUR CODE ENDS HERE\n",
    "\n",
    "\n",
    "CAT_SOURCE_DIR = \"/tmp/PetImages/Cat/\"\n",
    "TRAINING_CATS_DIR = \"/tmp/cats-v-dogs/training/cats/\"\n",
    "TESTING_CATS_DIR = \"/tmp/cats-v-dogs/testing/cats/\"\n",
    "DOG_SOURCE_DIR = \"/tmp/PetImages/Dog/\"\n",
    "TRAINING_DOGS_DIR = \"/tmp/cats-v-dogs/training/dogs/\"\n",
    "TESTING_DOGS_DIR = \"/tmp/cats-v-dogs/testing/dogs/\"\n",
    "\n",
    "split_size = .9\n",
    "split_data(CAT_SOURCE_DIR, TRAINING_CATS_DIR, TESTING_CATS_DIR, split_size)\n",
    "split_data(DOG_SOURCE_DIR, TRAINING_DOGS_DIR, TESTING_DOGS_DIR, split_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "luthalB76ufC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1350\n",
      "1350\n",
      "150\n",
      "150\n"
     ]
    }
   ],
   "source": [
    "print(len(os.listdir('/tmp/cats-v-dogs/training/cats/')))\n",
    "print(len(os.listdir('/tmp/cats-v-dogs/training/dogs/')))\n",
    "print(len(os.listdir('/tmp/cats-v-dogs/testing/cats/')))\n",
    "print(len(os.listdir('/tmp/cats-v-dogs/testing/dogs/')))\n",
    "\n",
    "# Expected output:\n",
    "# 1350\n",
    "# 1350\n",
    "# 150\n",
    "# 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-BQrav4anTmj"
   },
   "outputs": [],
   "source": [
    "# DEFINE A KERAS MODEL TO CLASSIFY CATS V DOGS\n",
    "# USE AT LEAST 3 CONVOLUTION LAYERS\n",
    "\n",
    "model = tf.keras.models.Sequential([\n",
    "# YOUR CODE HERE\n",
    "    tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(150, 150, 3)),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2, 2),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(512, activation='relu'),\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "\n",
    "model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['acc'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NOTE:\n",
    "\n",
    "In the cell below you **MUST** use a batch size of 10 (`batch_size=10`) for the `train_generator` and the `validation_generator`. Using a batch size greater than 10 will exceed memory limits on the Coursera platform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mlNjoJ5D61N6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2700 images belonging to 2 classes.\n",
      "Found 300 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "TRAINING_DIR = \"/tmp/cats-v-dogs/training/\"\n",
    "\n",
    "train_datagen = ImageDataGenerator(rescale=1.0/255.)\n",
    "\n",
    "# NOTE: YOU MUST USE A BATCH SIZE OF 10 (batch_size=10) FOR THE \n",
    "# TRAIN GENERATOR.\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(TRAINING_DIR,\n",
    "                                                    batch_size=100,\n",
    "                                                    class_mode='binary',\n",
    "                                                    target_size=(150, 150))\n",
    "\n",
    "VALIDATION_DIR = \"/tmp/cats-v-dogs/testing/\"\n",
    "\n",
    "validation_datagen = ImageDataGenerator(rescale=1.0/255.)\n",
    "\n",
    "# NOTE: YOU MUST USE A BACTH SIZE OF 10 (batch_size=10) FOR THE \n",
    "# VALIDATION GENERATOR.\n",
    "\n",
    "validation_generator = validation_datagen.flow_from_directory(VALIDATION_DIR,\n",
    "                                                              batch_size=100,\n",
    "                                                              class_mode='binary',\n",
    "                                                              target_size=(150, 150))\n",
    "\n",
    "\n",
    "# Expected Output:\n",
    "# Found 2700 images belonging to 2 classes.\n",
    "# Found 300 images belonging to 2 classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KyS4n53w7DxC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "27/27 [==============================] - 27s 1s/step - loss: 1.1377 - acc: 0.5296 - val_loss: 0.6686 - val_acc: 0.6333\n",
      "Epoch 2/2\n",
      "27/27 [==============================] - 20s 755ms/step - loss: 0.6740 - acc: 0.6004 - val_loss: 0.6621 - val_acc: 0.6300\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(train_generator,\n",
    "                              epochs=2,\n",
    "                              verbose=1,\n",
    "                              validation_data=validation_generator)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MWZrJN4-65RC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Training and validation loss')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa8AAAEICAYAAADocntXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAbI0lEQVR4nO3deZgldX3v8fcHRhaFoAKKgjCiiIAC6qjgxjKdaHC7JjzGNdFo4ppEicnl0dxoEp9orkZz9SpKokHF9aJE3MMMIGAEHAZlFSRkUGTfBlBk/d4/qo590vRyZqa7q6v7/Xqe80ydOnV+9avTM/Pp36/qeypVhSRJfbJZ1x2QJGlDGV6SpN4xvCRJvWN4SZJ6x/CSJPWO4SVJ6h3DSwKSbJ7ktiS7zua2XUry6CSzXguTZCzJuqHnFyd55ijbbsS+/iXJ2zf2/dO0++4kx8x2u5o/y7rugLQxktw29PT+wB3APe3z11XVZzekvaq6B9hmtrddCqpqz9loJ8lrgVdU1cFDbb92NtrW4mN4qZeq6tfh0f5m/9qqWjXV9kmWVdXd89E3SXPPaUMtSu200BeTfD7JrcArkhyY5IwkNye5KsmHktyv3X5ZkkqyvH1+bPv6t5LcmuT7SR65odu2r/92kkuSrE/y4STfS/KqKfo9Sh9fl+TSJDcl+dDQezdP8sEkNyS5DHjONJ/PO5J8YcK6jyT5QLv82iQXtcfzn+2oaKq2rkhycLt8/ySfaft2AfCkCdv+VZLL2nYvSPKCdv3jgf8LPLOdkr1+6LN919D7X98e+w1J/i3Jw0b5bGaS5EVtf25OclKSPYdee3uSK5PckuTHQ8d6QJK17fprkrxv1P1pFlSVDx+9fgDrgLEJ694N3Ak8n+aXtK2BJwNPpZlx2B24BHhzu/0yoIDl7fNjgeuBFcD9gC8Cx27Etg8BbgVe2L52BHAX8KopjmWUPn4V2A5YDtw4OHbgzcAFwC7A9sCpzT/xSfezO3Ab8IChtq8FVrTPn99uE+BQ4HZg3/a1MWDdUFtXAAe3y+8HTgEeBOwGXDhh2xcDD2t/Ji9r+/DQ9rXXAqdM6OexwLva5d9q+7g/sBXwUeCkUT6bSY7/3cAx7fJebT8ObX9Gbwcubpf3AS4Hdmq3fSSwe7v8A+Cl7fK2wFO7/rewlB6OvLSYnV5VX6uqe6vq9qr6QVWdWVV3V9VlwNHAQdO8/7iqWlNVdwGfpflPc0O3fR7ww6r6avvaB2mCblIj9vE9VbW+qtbRBMVgXy8GPlhVV1TVDcB7p9nPZcD5NKEK8JvATVW1pn39a1V1WTVOAlYDk16UMcGLgXdX1U1VdTnNaGp4v1+qqqvan8nnaH7xWDFCuwAvB/6lqn5YVb8CjgQOSrLL0DZTfTbTeQlwQlWd1P6M3ksTgE8F7qYJyn3aqef/aj87aH4J2SPJ9lV1a1WdOeJxaBYYXlrMfjb8JMljk3wjydVJbgH+FthhmvdfPbT8S6a/SGOqbR8+3I+qKpqRyqRG7ONI+6IZMUznc8BL2+WXtc8H/XhekjOT3JjkZppRz3Sf1cDDputDklcl+VE7PXcz8NgR24Xm+H7dXlXdAtwE7Dy0zYb8zKZq916an9HOVXUx8Oc0P4dr22nondpNXw3sDVyc5Kwkh414HJoFhpcWs4mXiX+cZrTx6Kr6DeCvaabF5tJVNNN4ACQJ//0/24k2pY9XAY8Yej7TpfxfAsaS7EwzAvtc28etgeOA99BM6T0Q+PcR+3H1VH1IsjtwFPAGYPu23R8PtTvTZf1X0kxFDtrblmZ68ucj9GtD2t2M5mf2c4CqOraqnk4zZbg5zedCVV1cVS+hmRr+R+DLSbbaxL5oRIaXlpJtgfXAL5LsBbxuHvb5deCJSZ6fZBnwZ8COc9THLwFvSbJzku2B/zndxlV1NXA6cAxwcVX9pH1pS2AL4DrgniTPA1ZuQB/enuSBaerg3jz02jY0AXUdTY7/Ec3Ia+AaYJfBBSqT+DzwmiT7JtmSJkROq6opR7Ib0OcXJDm43fdf0JynPDPJXkkOafd3e/u4l+YAXplkh3aktr49tns3sS8akeGlpeTPgT+g+Y/p4zQXVsypqroG+D3gA8ANwKOAc2jq0ma7j0fRnJs6j+ZiguNGeM/naC7A+PWUYVXdDLwVOJ7moofDaUJ4FO+kGQGuA74FfHqo3XOBDwNntdvsCQyfJzoR+AlwTZLh6b/B+79NM313fPv+XWnOg22SqrqA5jM/iiZYnwO8oD3/tSXwv2nOU15NM9J7R/vWw4CL0lzN+n7g96rqzk3tj0aTZgpe0nxIsjnNNNXhVXVa1/2R+sqRlzTHkjynnUbbEvhfNFepndVxt6ReM7ykufcM4DKaKalnAy+qqqmmDSWNwGlDSVLvOPKSJPWOX8w7T3bYYYdavnx5192QpF45++yzr6+q+5SXGF7zZPny5axZs6brbkhSrySZ9JtinDaUJPWO4SVJ6h3DS5LUO4aXJKl3DC9JUu8YXpKk3jG8JEm9Y53XQvfhD8M228DKlbDrTPcWlKSlwfBa6D7+cbjggmb5MY9pQmxsDA45BB70oG77JkkdMbwWuvPOa8Jr1arm8elPw1FHwWabwZOeNB5mT386bOUdyCUtDX6r/DxZsWJFzcrXQ911F5x11niYnXEG3H13E1zPeEYTZCtXwhOeAJtvvun7k6QOJTm7qlbcZ73hNT9mLbwmuvVWOPVUWL26CbPzzmvWP+hBcOih42H26EdDMvv7l6Q5ZHh1bM7Ca6Krr4aTTmrC7MQT4Wc/a9bvumsTZGNjTag99KFz3xdJ2kSGV8fmLbyGVcGllzYjstWrm1C76abmtcc/fjzMnvWs5opGSVpgDK+OdRJeE91zD5xzzvj5stNPhzvugGXL4IADxsPsKU+B+92v275KEoZX5xZEeE10++3wH/8xHmZnn92M1rbZBg46aDzM9tnH82WSOmF4dWxBhtdEN94Ip5wyHmY/+Umz/qEPHb8k32JpSfPI8OpYL8Jrop/+dPwqxlWr4Nprm/UWS0uaJ4ZXx3oZXsOq4Pzzx8PslFPgF7+wWFrSnDK8Otb78JrozjubYulBmFksLWkOGF4dW3ThNdGgWHpwWb7F0pJmgeHVsUUfXhMNiqUH58sslpa0EQyvji258Bo2XCy9alUTajff3LxmsbSkaRheHVvS4TWRxdKSRmR4dczwmobF0pKmYHh1zPDaANMVSw8u/Bgbg0c8otNuSpp7hlfHDK9NMF2x9CDMLJaWFiXDq2OG1yyZqVh6EGYWS0uLguHVMcNrjoxSLD02Bvvvb7G01ENThddmM7zp5CTPnrDuLUmOmuF9t7V/PjzJcVNsc0qS+3Rokn3df+j5N5M8cLr3jCLJu5K8bVPb0QKwxRZNSL3znXDaac35sq9/HV7/erjmGjjySFixAnbcEQ4/HD72seayfX9pk3pt2Qyvfx54CfCdoXUvAf5ylMar6krg8I3rGgBvAY4Fftm2d9gmtKWlYNtt4bnPbR5w32LpL3+5WW+xtNRr0468gOOA5ybZAiDJcuDhwGlJtkmyOsnaJOcleeHENydZnuT8dnnrJF9IclGS44Gth7Y7KsmaJBck+Zt23Z+2+zo5ycntunVJdmiXj0hyfvt4y9D+Lkryz21b/55ka0Y0RZsPSPKNJD9q1/9eu/69SS5Mcm6S94+6D82znXaCl70MPvlJuPxyuOQS+OhHm9HYV77SvLbTTrDffnDEEfDNb8Jtt3Xda0kzmHbkVVU3JjkL+G3gqzSjri9VVSX5FfCiqrqlDZQzkpxQU59EewPwy6raK8m+wNqh197R7mtzYHWSfavqQ0mOAA6pquuHG0ryJODVwFOBAGcm+S5wE7AH8NKq+qMkXwJ+l2b0Nq1p2twduLKqnttut12S7YEXAY9tP4tJpzKT/DHwxwC7eg+s7iWwxx7N4w1vuG+x9Ec/Ch/8YFMsfeCB45fkWywtLTgzjbxgfOqQ9s/Pt8sB/j7JucAqYGdgurmXZ9GGSFWdC5w79NqLk6wFzgH2AfaeoU/PAI6vql9U1W3AV4Bntq/9V1X9sF0+G1g+Q1sztXke8JtJ/iHJM6tqPbAe+BXwiSS/QzutOVFVHV1VK6pqxY477jhiNzRvNt+8GYEdeWQTXjfd1Pz5trc1hdN/8zfN+bQHPxie/3z4p39qrnT0fJnUuVHC66vAyiRPBO5fVWe3618O7Ag8qar2B64BNvja5CSPBN4GrKyqfYFvbEw7Q+4YWr6Hmc/rTauqLgGeSBNi707y11V1N/AUmmnV5wHf3pR9aIHYeutmtPWe98APfgDXX9+cI3vlK+Hii+Gtb22+i/HhD4dXvAKOOWb8C4clzasZw6sdhZwMfJLxURfAdsC1VXVXkkOA3WZo6lTgZQBJHgfs267/DeAXwPokD6WZohy4Fdh2krZOA/5HkvsneQDNFN5pMx3LDCZtM8nDaaY7jwXeBzwxyTbAdlX1TeCtwH6buG8tRA9+MPzO7zTTiZdcAuvWwSc+0VzgceKJ8OpXNxd+7LknvOlNcPzxzehN0pwbdVTyeeB4xqcPAT4LfC3JecAa4McztHEU8K9JLgIuopnSo6p+lOSc9v0/A7439J6jgW8nubKqDhmsrKq1SY4BzmpX/UtVndNeUDKqvxpclNG2ucsUbT4beF+Se4G7aM7dbQt8NclWNNOnR2zAftVXu+0Gf/iHzWNQLD24f9mnPtWE3HCx9NgYPO1pFktLc8Ai5XlikfIiNyiWHlz8ceaZFktLs8Bv2OiY4bXEDN9ZetWqZpQGzVTkIYeMh9mjHuU35UvTMLw6ZngtcVPdWXq33cYvybdYWroPw6tjhpd+bbo7S++77/iXC3tnacnw6prhpSndcw+sXTv+5cLDd5Y+8MDxMLNYWkuQ4dUxw0sju/12+N73xsNs+M7SBx88HmbeWVpLgOHVMcNLG+3GG+Hkk8cvyx/cWXqnncbPl61c6Z2ltSgZXh0zvDRrLr98fFS2evV97yw9NtaM0LyztBYBw6tjhpfmxHCx9KpV8N3v3vfO0hZLq8cMr44ZXpoXE4ulzzijuSBkq63gmc8cn2a0WFo9YXh1zPBSJ6Yrlj700PEws1haC5Th1THDSwvCdMXSgws/LJbWAmJ4dczw0oJjsbR6wPDqmOGlBc9iaS1AhlfHDC/1jsXSWgAMr44ZXuo9i6XVAcOrY4aXFh2LpTUPDK+OGV5a1CyW1hwxvDpmeGlJsVhas8Tw6pjhpSXNYmltJMOrY4aXNGSUYumVK+EhD+m2n+qc4dUxw0uaQlVz5eLgwo/JiqXHxprpRoullxzDq2OGlzSiQbH0IMwmK5YeG4MnP9li6SXA8OqY4SVtpEGx9CDMJiuWHhuDvff2fNkiNFV4LeuiM5I0sq23Hg8o+O/F0qtWwde/3qy3WHpJceQ1Txx5SXNkqmLpPfccDzOLpXvLacOOGV7SPJiuWHrFivEws1i6NwyvjhleUgfuvBPOPHN8ZDaxWHowxWix9IJleHXM8JIWgFtuaYqlB2E2sVh6EGYWSy8YhlfHDC9pAbrqqqaubPVqOPFEuOKKZv2gWHpsrAk1i6U7Y3h1zPCSFrjhYulVq5orGi2W7pzh1THDS+qZ4WLpVauaWrM77mgKow84wGLpeWJ4dczwknpuuFh61aom2Kpg223hoIMslp4jFilL0qbYkGLpwYUfY2Owyy7d9XkRc+Q1Txx5SYvcdMXSgzA75BB44AO77WfPOG3YMcNLWkJmKpYejOAOPNBi6RkYXh0zvKQlbJRi6cGdpTfbrOveLiiGV8cML0m/Nkqx9NgY7L77kr/4w/DqmOElaUoWS0/J8OqY4SVpJNMVS++33/hVjEukWNrw6pjhJWmjTFcsfeCB42G2SIulDa+OGV6SZsV0xdKDO0uvXLloiqUtUpakxWCmYumvfa1ZPyiWHoTZIiuWduQ1Txx5SZoXw8XSq1bBddc163taLO20YccML0nz7t57m8vwB2HWw2Jpw6tjhpekzg2KpQdfYdWDYmnDq2OGl6QFZ1AsPQizBVgsbXh1zPCStOANiqUH58sWQLG04dUxw0tSr0wslj7pJFi/vnltHoulDa+OGV6Sem1isfTppzfn0Oa4WNrw6pjhJWlRmadiaYuUJUmzZ2Kx9A03NMXSg8vyh4ulzz0XdtxxVndveC1w++wDF17YLCcb/tjY99lON+0sxD7ZTr/amdjWvNl+ezj88OYBsG5dE2Rr18IOO8z67gyvBe6Nb2zuJl614Q/YuPct9HZm6zGb/eniM5JG1U2gLid5DclruPgDsOWWs3tMhtcC96Y3dd0DLWQLKUxtZ2G0tRDbmYt6Z8NL6rF5nxqSFoiF8f0fkiRtAMNLktQ7hpckqXcML0lS7xhekqTeMbwkSb1jeEmSesfwkiT1juElSeodw0uS1DuGlySpdwwvSVLvGF6SpN4xvCRJvWN4SZJ6x/CSJPWO4SVJ6h3DS5LUO4aXJKl3DC9JUu8YXpKk3jG8JEm9Y3hJknrH8JIk9Y7hJUnqHcNLktQ7hpckqXcML0lS7xhekqTeMbwkSb1jeEmSesfwkiT1juElSeodw0uS1DuGlySpdwwvSVLvGF6SpN4xvCRJvWN4SZJ6x/CSJPWO4SVJ6h3DS5LUO4aXJKl3DC9JUu8YXpKk3jG8JEm9Y3hJknrH8JIk9Y7hJUnqHcNLktQ7hpckqXcML0lS7xhekqTeMbwkSb1jeEmSesfwkiT1juElSeodw0uS1DuGlySpdwwvSVLvGF6SpN4xvCRJvWN4SZJ6x/CSJPWO4SVJ6h3DS5LUO4aXJKl3DC9JUu8YXpKk3jG8JEm9Y3hJknrH8JIk9Y7hJUnqHcNLktQ7hpckqXcML0lS7xhekqTeMbwkSb1jeEmSesfwkiT1juElSeodw0uS1DuGlySpdwwvSVLvGF6SpN4xvCRJvWN4SZJ6x/CSJPWO4SVJ6h3DS5LUO4aXJKl3DC9JUu8YXpKk3jG8JEm9Y3hJknrH8JIk9Y7hJUnqHcNLktQ7hpckqXcML0lS7xhekqTeMbwkSb1jeEmSesfwkiT1juElSeodw0uS1DuGlySpdwwvSVLvGF6SpN4xvCRJvbPJ4ZVk+yQ/bB9XJ/n50PMtRmzjX5PsOcM2b0ry8k3tb9vW6Un2n422JEnzb9mmNlBVNwD7AyR5F3BbVb1/eJskAVJV907RxqtH2M9HNrWvkqTFYc6mDZM8OsmFST4LXAA8LMnRSdYkuSDJXw9te3qS/ZMsS3Jzkvcm+VGS7yd5SLvNu5O8ZWj79yY5K8nFSZ7Wrn9Aki+3+z2u3ddII6wkWyf5VJLzkqxN8qx2/eOT/KAdSZ6bZPck2yb5VtvH85McPtufnyRpanN9zuuxwAerau+q+jlwZFWtAPYDfjPJ3pO8Zzvgu1W1H/B94A+naDtV9RTgL4BBEP4JcHVV7Q38HfCEDejrnwJ3VNXjgVcCn2mnPd8IvL+q9geeDFwJHAasq6r9qupxwImTdjD54zZA11x33XUb0BVJ0nTmOrz+s6rWDD1/aZK1wFpgL2Cy8Lq9qr7VLp8NLJ+i7a9Mss0zgC8AVNWPaEZ8o3oGcGz73gtoQurRwH8Af5XkL4FHVNWvgHOB57Sjv6dX1frJGqyqo6tqRVWt2HHHHTegK5Kk6cx1eP1isJBkD+DPgEOral/g28BWk7znzqHle5j6vNwdI2yzyarqM8CL2v19O8mzquoiYAVNOL43ydvnav+SpPuaz0vlfwO4FbglycOAZ8/BPr4HvBiac1VMPrKbymnAy9v37gU8DLg0ye5VdWlV/R/g68C+SXamuTDlM8A/Ak+cxWOQJM1gzkYsk1gLXAj8GLicJmhm24eBTye5sN3XhcCkU3rAd5Lc1S6fRnNu7eNJzgPuAn6/qu5M8rIkL23XXQm8C3gazYjrXpqR4uvn4FgkSVNIVXXdh1mTZBmwrKp+1U5T/juwR1Xd3XHXWLFiRa1Zs2bmDSVJv5bk7PZCv/9mPkde82EbYHUbYgFetxCCS5I0uxZVeFXVzcCTuu6HJGlu+d2GkqTeMbwkSb2zqC7YWMiSXEdzleXG2AG4fha70wce89Kw1I55qR0vbPox71ZV9/mWB8OrB5Ksmexqm8XMY14altoxL7Xjhbk7ZqcNJUm9Y3hJknrH8OqHo7vuQAc85qVhqR3zUjtemKNj9pyXJKl3HHlJknrH8JIk9Y7htYAkeU6Si5NcmuTISV7fMskX29fPTLJ8/ns5e0Y43iOSXJjk3CSrk+zWRT9n00zHPLTd7yapJL2/rHqUY07y4vZnfUGSz813H2fbCH+3d01ycpJz2r/fh3XRz9mS5JNJrk1y/hSvJ8mH2s/j3CSbfhupqvKxAB7A5sB/ArsDWwA/AvaesM0bgY+1yy8Bvth1v+f4eA8B7t8uv6HPxzvqMbfbbQucCpwBrOi63/Pwc94DOAd4UPv8IV33ex6O+WjgDe3y3sC6rvu9icf8LJr7Gp4/xeuHAd+i+cL0A4AzN3WfjrwWjqcAl1bVZVV1J/AF4IUTtnkh8Kl2+ThgZZLMYx9n04zHW1UnV9Uv26dnALvMcx9n2yg/Y4C/A/4B+NV8dm6OjHLMfwR8pKpuAqiqa+e5j7NtlGMumhv0AmxHc6/A3qqqU4Ebp9nkhcCnq3EG8MD2psQbzfBaOHYGfjb0/Ip23aTbVHOrl/XA9vPSu9k3yvEOew3Nb259NuMxt9Mpj6iqb8xnx+bQKD/nxwCPSfK9JGckec689W5ujHLM7wJekeQK4JvAn8xP1zqzof/eZ7SobomixSnJK4AVwEFd92UuJdkM+ADwqo67Mt+W0UwdHkwzuj41yeOrucXRYvVS4Jiq+sckBwKfSfK4qrq36471hSOvhePnwCOGnu/Srpt0m/aGm9sBN8xL72bfKMdLkjHgHcALquqOeerbXJnpmLcFHgeckmQdzbmBE3p+0cYoP+crgBOq6q6q+i/gEpow66tRjvk1wJcAqur7wFY0X2C7WI30731DGF4Lxw+APZI8MskWNBdknDBhmxOAP2iXDwdOqvZsaA/NeLxJngB8nCa4+n4eBGY45qpaX1U7VNXyqlpOc57vBVW1ppvuzopR/l7/G82oiyQ70EwjXjafnZxloxzzT4GVAEn2ogmv6+a1l/PrBOD326sODwDWV9VVm9Kg04YLRFXdneTNwHdorlb6ZFVdkORvgTVVdQLwCZrphUtpTo6+pLseb5oRj/d9wDbA/2uvS/lpVb2gs05vohGPeVEZ8Zi/A/xWkguBe4C/qKq+ziiMesx/DvxzkrfSXLzxqh7/IkqSz9P8ArJDex7vncD9AKrqYzTn9Q4DLgV+Cbx6k/fZ489LkrREOW0oSeodw0uS1DuGlySpdwwvSVLvGF6SpN4xvCRJvWN4SZJ65/8DRdjNuhA43eEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PLOT LOSS AND ACCURACY\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.image  as mpimg\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#-----------------------------------------------------------\n",
    "# Retrieve a list of list results on training and test data\n",
    "# sets for each training epoch\n",
    "#-----------------------------------------------------------\n",
    "acc=history.history['acc']\n",
    "val_acc=history.history['val_acc']\n",
    "loss=history.history['loss']\n",
    "val_loss=history.history['val_loss']\n",
    "\n",
    "epochs=range(len(acc)) # Get number of epochs\n",
    "\n",
    "#------------------------------------------------\n",
    "# Plot training and validation accuracy per epoch\n",
    "#------------------------------------------------\n",
    "plt.plot(epochs, acc, 'r', \"Training Accuracy\")\n",
    "plt.plot(epochs, val_acc, 'b', \"Validation Accuracy\")\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.figure()\n",
    "\n",
    "#------------------------------------------------\n",
    "# Plot training and validation loss per epoch\n",
    "#------------------------------------------------\n",
    "plt.plot(epochs, loss, 'r', \"Training Loss\")\n",
    "plt.plot(epochs, val_loss, 'b', \"Validation Loss\")\n",
    "\n",
    "\n",
    "plt.title('Training and validation loss')\n",
    "\n",
    "# Desired output. Charts with training and validation metrics. No crash :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Submission Instructions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now click the 'Submit Assignment' button above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# When you're done or would like to take a break, please run the two cells below to save your work and close the Notebook. This will free up resources for your fellow learners. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "<!-- Save the notebook -->\n",
    "IPython.notebook.save_checkpoint();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "IPython.notebook.session.delete();\n",
    "window.onbeforeunload = null\n",
    "setTimeout(function() { window.close(); }, 1000);"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Exercise 5 - Question.ipynb",
   "provenance": []
  },
  "coursera": {
   "course_slug": "convolutional-neural-networks-tensorflow",
   "graded_item_id": "laIUG",
   "launcher_item_id": "jjQWM"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}