Course2Week2ProgrammingAssignment1.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 shutil\n",
    "import tensorflow as tf\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": [
    "# This code block unzips the full Cats-v-Dogs dataset to /tmp\n",
    "# which will create a tmp/PetImages directory containing subdirectories\n",
    "# called 'Cat' and 'Dog' (that's how the original researchers structured it)\n",
    "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()"
   ]
  },
  {
   "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": 6,
   "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",
    "\n",
    "try:\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": 7,
   "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",
    "\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",
    "\n",
    "TRAINING_CATS_DIR = \"/tmp/cats-v-dogs/training/cats/\"\n",
    "\n",
    "TESTING_CATS_DIR = \"/tmp/cats-v-dogs/testing/cats/\"\n",
    "\n",
    "DOG_SOURCE_DIR = \"/tmp/PetImages/Dog/\"\n",
    "\n",
    "TRAINING_DOGS_DIR = \"/tmp/cats-v-dogs/training/dogs/\"\n",
    "\n",
    "TESTING_DOGS_DIR = \"/tmp/cats-v-dogs/testing/dogs/\"\n",
    "\n",
    "\n",
    "split_size = .9\n",
    "\n",
    "split_data(CAT_SOURCE_DIR, TRAINING_CATS_DIR, TESTING_CATS_DIR, split_size)\n",
    "\n",
    "split_data(DOG_SOURCE_DIR, TRAINING_DOGS_DIR, TESTING_DOGS_DIR, split_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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",
    "model = tf.keras.models.Sequential([\n",
    "# YOUR CODE HERE\n",
    "    \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",
    "\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": 10,
   "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./255,\n",
    "                                  rotation_range=40,\n",
    "                                  width_shift_range=0.2,\n",
    "                                  height_shift_range=0.2,\n",
    "                                  shear_range=0.2,\n",
    "                                  zoom_range=0.2,\n",
    "                                  horizontal_flip=True,\n",
    "                                  fill_mode='nearest')\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",
    "# NOTE: YOU MUST USE A BATCH SIZE OF 10 (batch_size=10) FOR THE \n",
    "# TRAIN GENERATOR.\n",
    "\n",
    "\n",
    "VALIDATION_DIR = \"/tmp/cats-v-dogs/testing/\"\n",
    "\n",
    "validation_datagen = ImageDataGenerator(rescale=1./255,\n",
    "                                          rotation_range=40,\n",
    "                                          width_shift_range=0.2,\n",
    "                                          height_shift_range=0.2,\n",
    "                                          shear_range=0.2,\n",
    "                                          zoom_range=0.2,\n",
    "                                          horizontal_flip=True,\n",
    "                                          fill_mode='nearest')\n",
    "\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",
    "\n",
    "# Expected Output:\n",
    "# Found 2700 images belonging to 2 classes.\n",
    "# Found 300 images belonging to 2 classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KyS4n53w7DxC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "27/27 [==============================] - 54s 2s/step - loss: 0.9686 - acc: 0.5133 - val_loss: 0.6819 - val_acc: 0.5667\n",
      "Epoch 2/2\n",
      "27/27 [==============================] - 45s 2s/step - loss: 0.6867 - acc: 0.5541 - val_loss: 0.6629 - val_acc: 0.6500\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": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MWZrJN4-65RC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Training and validation loss')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAccAAAEICAYAAAAqQj/TAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAalUlEQVR4nO3deZglVZ3m8e9LFcVWxVrsWpQsirQiao3tRreOjCIyoiMi4IYtarvTto6OS0vbaOujYz+t7aC0o7gDLiij7S6KoqgFAoJbu6CigrIXu1T95o+IhMshl5tVuVRmfj/Pc5+KG3Ei4pzIqnzrnDj3RqoKSZJ0h01muwKSJG1sDEdJkhqGoyRJDcNRkqSG4ShJUsNwlCSpYThKQ0iyKMn1SVZMZdnZlGTvJFP+Wa4kByW5ZOD9T5McOEzZ9TjXe5O8en33l8ayeLYrIE2HJNcPvN0SuAVY279/XlV9ZDLHq6q1wNKpLrsQVNW9puI4SY4FnlZVjxg49rFTcWypZThqXqqq28Op75kcW1VfGat8ksVVddtM1E2aiH8fZ5/DqlqQkpyQ5NQkH0uyBnhakockOSfJNUn+kOQdSTbtyy9OUklW9u8/3G//fJI1Sb6T5B6TLdtvf2ySnyW5Nsk7k5yd5Jgx6j1MHZ+X5OdJrk7yjoF9FyX5lyRXJvklcPA41+c1SU5p1r0rydv75WOT/Lhvzy/6Xt1Yx7o0ySP65S2TfKiv28XAA5uyr03yy/64Fyd5fL/+vsC/AQf2Q9ZXDFzb4wf2/9u+7Vcm+XSSXYe5NpO5ziP1SfKVJFcluSzJ/xw4z+v6a3JdktVJdhttCDvJt0Z+zv31PKs/z1XAa5Psk+TM/hxX9Ndtm4H99+jb+Kd++78m2byv870Hyu2a5MYkO4zVXt2V4aiF7InAR4FtgFOB24CXAsuBh9GFx/PG2f9o4HXA9sBvgH+abNkkOwGnAa/oz/sr4EHjHGeYOh5CFzr3pwv9g/r1zwceDdwP+C/AEeOc52PAoUm26uu5GHgy3fUCuBx4HLA18BzgnUn2H+d4I94A3B3Ys6/nM5vtP+vbtQ3wRuCjSXauqh8CLwK+WVVLq2p5e+Akj+6PfziwO/B7oB0+H+vatMa8zn1AfQX4f8CuwD2Br/f7vaI//8HAtsCxwM3jXZABDwV+DOwIvAUIcAKwC7Af3TV7XV+HxcDngJ8DK+mu6WlVdTPd36enDRz3aOCLVXXlkPUQQFX58jWvX8AlwEHNuhOAr02w38uBj/fLi4ECVvbvPwy8e6Ds44GL1qPs39D9wh/ZFuAPwDFDtm20Oj54YPungJf3y2fRDS+PbDuk+xUw5rHPAY7ulx8L/HScsp8FXtgvHwRcMrDtUuAR/fJvBn8WwAsGy45y3IuAx/XLxwJfb7Z/GDi+X/4A8KaBbVvT3We+20TXZpLX+enA98co94uR+jbr926vNfCtkZ9z37ZfTlCHw0fOCxwIXAYsGqXcw+j+k5X+/fnA/5jqf1fz/WXPUQvZbwffJNk3yef6YbLr6Hohd+mhDLhsYPlGxp+EM1bZ3QbrUd1vs0vHOsiQdRzqXMCvx6kvdL3Eo/rlo7mj10iSQ5N8tx/yu4auRzretRqx63h1SHJMkgv6ocFrgH2HPC507bv9eFV1HXA1XS9yxFA/swmu893pQnA0422bSPv3cZckpyX5XV+Hk5s6XFLd5K87qaqz6Xq+D09yH2AFXS9Tk2A4aiFrP8bwHrqeyt5VtTXwD3Q9uen0B7qeDQBJwp1/mbc2pI5/oPulOmKij5qcBhyUZHfgMPpwTLIF8Angn4Gdq2pb4EtD1uOyseqQZE/gRLrh3x364/5k4LgTfezk98AeA8dbBmwH/G6IerXGu86/BfYaY7+xtt3Q12nLgXW7NGXa9r2Fbpb1ffs6HNPUYY8ki8aoxwfphlafTjfcessY5TQGw1G6wzLgWuCGfkLDePcbp8pngQck+e/9faSX0t1zmo46ngYcl2T3fnLGK8crXFWX0Q39nUw3pPqf/abNgCXAn4C1SQ4FHjWJOrw6ybbpPgf6ooFtS+kC4k90/094Dl3PccTlwN0GJ8Y0PgY8O8n+STajC+9vVtWYPfFxjHedzwBWJHlRks2SbJ1k5D7xe4ETkuyVzgFJtqf7T8FldPc5FyV5LgNBPk4dbgCuTXJ3uqHdEd8BrgTelG6S0xZJHjaw/UN0w7BH0wWlJslwlO7w93QTRNbQ9RxOne4TVtXlwFOAt9P9stsL+AFdj2Gq63gi8FXgh8D36Xp/E/ko3T3E24dUq+oa4O+A04Gr6H4Jf3bIOryergd7CfB5Bn5xV9WFwDuB7/Vl7gV8d2DfLwP/CVyeZHB4dGT/L9ANf57e778CeOqQ9WqNeZ2r6lrgvwFPogvsnwF/3W9+K/Bpuut8HXASsHk/XP4c4NXAFXT3IAfbNprX003OupYukD85UIfbgEOBe9P1In9D93MY2X4J3c/5lqr69iTbLu64YStpI9APk/0eOLyqvjnb9dHcleSDdJN8jp/tusxFfgmANMuSHEw3M/Qm4H8Bf6brPUnrpb9/exhw39muy1zlsKo0+x4O/JLuXttjgCc6gULrK8k/AxfQfazlN7Ndn7nKYVVJkhr2HCVJanjPcZ5Yvnx5rVy5crarIUlzxrnnnntFVY360SnDcZ5YuXIlq1evnu1qSNKckWTMb4lyWFWSpIbhKElSw3CUJKlhOEqS1DAcJUlqjBuOSc5M8phm3XFJTpxgv+v7P3dLMuqXGyf5epJVExznuMFHvCT5jyTbjrfPZCQ5P8kpU3U8SdL8MFHP8WPAkc26I/v1E6qq31fV4ROXHNNxwO3hWFWH9E8E2GD9Y2gWAQcm2WoqjjnGefy4jCTNMROF4yeAxyVZApBkJd3Ttr+ZZGmSryY5L8kPkxzW7pxkZZKL+uUtkpyS5MdJTge2GCh3YpLVSS5O8o/9upf05zozyZn9ukuSLO+XX5bkov513MD5fpzk3/tjfal/MOtojqJ75tmX6L6gd6Queyf5Sv808vOS7NWvf2XfzguSvLlfd3vvN8nyJJf0y8ckOSPJ14CvjnetkjwjyYX9cT+UZFmSX408s65/Vtzt7yVJ02/cXk1VXZXke8Bjgc/Q9RpPq6pKcjPdFyRf1wfWOUnOqLG/rPX5wI1Vde8k+wPnDWx7TX+uRXRhsn9VvSPJy4BHVtUVgwdK8kDgWcBf0j0Z+7tJvgFcDewDHFVVz0lyGt0z1z48Sn2eQvdMtn2BF3PH8+o+Ary5qk5PsjmwSZLH0gXoX1bVjf3DSyfyAGD/vl2LR7tWwH7Aa4GHVtUVSbavqjVJvg48ju65cEcCn6qqP7cn6B+Y+lyAFSsmeqi7JGlYw0zIGRxaHRxSDd1TqC8EvgLsDuw8znH+ij6k+oeaXjiw7Ygk59E95PUv6EJjPA8HTq+qG6rqeuBTwIH9tl9V1fn98rnAynbnvrd3Rf+N9V8F7p9k+yTLgN2r6vS+njdX1Y10D3t9f79MVV01Qf0AvjxQbqxr9V+Bj4+E/0D599KFP/2f7x/tBFV1UlWtqqpVO+443sPjJUmTMUw4fgZ4VJIHAFtW1bn9+qcCOwIPrKoD6J6IvflkK5DkHsDLgUdV1f7A59bnOAMGH/WzltF7x0cB+/bDoL8AtqbrYU7WbdxxDds63zCwPKlrVVVnAyuTPAJYVFUXrUfdJEnracJw7HtmZwLv484TcbYB/lhVf07ySGCPCQ51FnA0QJL7APv367emC5Jrk+xMN4Q7Yg2wbJRjfRN4QpIt+8k0T+zXTSjJJsARwH2ramVVraQbMj2qqtYAlyZ5Ql92s3627JeBZ43MnB0YVr0EeGC/PN7Eo7Gu1deAJyfZoTkuwAfphnpH7TVKkqbPsJ9z/BhwP+4cjh8BViX5IfAM4CcTHONEYGmSHwNvoBvypKouoBtO/QldGJw9sM9JwBdGJuSMqKrzgJPpnpb+XeC9VfWDIdtyIPC7qvr9wLqzgP2S7Ao8HXhJPwT6bWCXqvoCcAawOsn5dD1dgLcBz0/yA2D5OOcc9VpV1cXAG4FvJLkAeHuzz3YMOTNYkjR1fNjxRirJ4cBhVfX0YcqvWrWqfCqHJA0vyblVNern7f0M3kYoyTvphpcPme26SNJCZDhuhKrqxbNdB0layPxuVUmSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSw3CUJKlhOEqS1DAcJUlqGI6SJDUMR0mSGoajJEkNw1GSpIbhKElSY/FsV0CSpIn8+c+wZg1cd92dX+vWwaGHTv35DEdJ0rSoghtvvHOYjRZww2y7+ebRz7HTTnD55VNfd8NRknQnI7209Q2ywW3r1k18viVLYOut7/zabTfYd19Ytuyu20Zey5bBNttMzzUwHCVpHqiCm26afJiNtv6mm4Y7Zxtcy5bBrruOHWRjrd9ss+m9NuvDcJSkWXTbbXcOqPF6ZBNtH6aXtummXW9rMKx22QXuec+Jg2xw29KlsMk8ntJpOErSJA320tZn6HFw/Y03DnfOpUvvGlS77DJckA2+NsZe2sbIcJS0YKxdO7nhxfG2rV078fkWL+56aYPhtPPOsM8+kxt6nO+9tI2R4Shpo1bVzVScihmPk+2lDYbVTjsNF2SD2zbbDJLpvT6aHoajpGkx0kubihmPt9028fkWL75rSO20E+y99+SGHpcuhUWLpv/6aONmOEq6XRXccsvUDDvecMNw59xqq7uG1V57TW7Y0V6apprhKM0Da9fC9ddv+LDjmjXdZ9wmsmjRXWc8Ll8Oe+45uWHHZcvspWnjZDhKs2Swl7ahMx6vv364c2655V2Das89Jz/jcfPN7aVpfjMcpUlat+7OvbQNGXoctpfWhtUOO8A97jG5YcelS7v7cpIm5j8VLRjtvbT1HXqcbC9tMLBWrpzcsOPWW8MWW9hLk2aa4aiN2kgvbSpmPN5668Tn22STuwbV9tt3oTaZocdly+ylSXOZ/3w1LW69dWqGHdesGe58W2xx13DaY4/Jz3i0lyYJDEcNWLeum34/FTMeb7ll4vON9NIGw2rbbWHFisnPeNx00+m/PpIWDsNxgTvgALjyyjtCrWrifTbf/K5BtWLF5Gc8brmlvTRJGyfDcYE74IDRZ0OOF3L20iTNd4bjAnfyybNdA0miG7a69dbunszIa5j3ixfD4YdPeXUMR0laSKq6D9gOEz7DBtRk9xlt3TAf+h3NTjsZjpI0Z1R13+s3HUGyoftMpcWLuy+2HXwtWXLX90uXTlxmvPdjldlii6ltz0izpuWokjSTBkNopno6w5QZZobbsBYtGi5Itttuw8JmMvssWTJvHzRpOEoa3rp1G1f4jLwf5snDw0omDpHNNutmpy1fvmHhM5kyfkP7jDIcpY3R4OSE2bwP1L4f5sGKkzFMSGy1Vfc1RdMdPiPLfrWRMBy10FV1v/A3hvtAg+uG+a67yViyZOKQ2GKL7jlU0x0+I+833dQPumqjZThq5gyG0Ez1dCba59Zbp/a+0ODkhPFCYmRywnTcBxrtvpAhJE2K4bjQfe5zcNNNMxNQ69ZNXb0XLRouJNqe0FT1hsbaZ55OTpAWGsNxoXvyk7twHEs7OWGskBicnDCdQ3Ejy05OkDSNDMeF7uyz7xgKHC2gFi1ySE7SgmM4LnT3v/9s10CSNjreIJEkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVLDcJQkqWE4SpLUMBwlSWoYjpIkNQxHSZIahqMkSQ3DUZKkhuEoSVJjg8MxyQ5Jzu9flyX53cD7JUMe4/1J7jVBmRcmeeqG1nfgeDsnuS3JsVN1TEnS/LB4Qw9QVVcCBwAkOR64vqreNlgmSYBU1boxjvGsIc7zrg2ta+MI4DvAUcB7p/jYt0uyuKpum67jS5Km3rQNqybZO8mPknwEuBjYNclJSVYnuTjJPwyU/VaSA5IsTnJNkjcnuSDJd5Ls1Jc5IclxA+XfnOR7SX6a5KH9+q2SfLI/7yf6cx0wRhWPAo4D9kyy60BdHpfkvP78X+rXLUvygSQX9q8njNR1YL8jk7y3X/5wkhOTfA94U5IH9235QZKzk+zTl1uc5F+SXNQf9wVJHp3kEwPHfWySj0/Fz0SSNJwN7jlOYF/gGVW1GiDJq6rqqiSLgTOTfKKqftTssw3wjap6VZK3A38DvHmUY6eqHpTk8cA/AAcDLwYuq6onJbkfcN5olUqyEti+qs7tg+cI4F+T7AKcCBxYVb9Osn2/y/HAn6pq/74XvO0Qbd8VeHBVrUuyTX/M25IcDJwAPAV4PrAbcL+qWtuf7xrg35Ls0PfKnwW8b4x2PBd4LsCKFSuGqJIkaRjTPSHnFyPB2DsqyXl0oXVvYL9R9rmpqj7fL58LrBzj2J8apczDgVMAquoCuh7raI4ETu2XT6HrRQI8BDizqn7dH+Oqfv1BwLv6dVVVV49x3EEfHxhG3hb4ZJKLgLcBfzFw3HdX1dqR8/X7fAQ4ug/LBwJfGu0EVXVSVa2qqlU77rjjEFWSJA1junuON4ws9EOJLwUeVFXXJPkwsPko+9w6sLyWset4yxBlxnIUsDzJM/v3uyXZc5LHWAdk4H3blhsGlt8IfLGq/k+SvYEvTHDs9wGf7JdPHQlPSdLMmMmPcmwNrAGu6+/xPWYaznE23RApSe7LKD3TJPsBi6tq96paWVUrgbfS9Sa/DTwyyR592ZFh1S8DL+zXJcl2fQ/v6iT7JNkEeOI49doG+F2/fMzA+i8Df5tk0eD5quq3wBXAq4CTJ3MBJEkbbibD8TzgR8BPgA/SBdlUeyewe5IfAa/vz3dtU+Yo4PRm3SeBo6rqcrr7gJ9JcgHd8CbAPwI798Oi5wMH9utfCXyRLlQvHadebwHe2g8pD/Y23wNcBlzYn++IgW0fBX5VVT8bv8mSpKmWqprtOkyZfqLP4qq6uR/G/RKwz1z8KEWSdwPfqaoPDFN+1apVtXr16okLSpIASHJuVa0abdt033OcaUuBr/YhGeB5czQYzweuBl4y23WRpIVoXoVjVV1DN7tzTquqsT6bKUmaAX63qiRJDcNRkqTGvJqQs5Al+RPw6/XcfTndR0cWEts8/y209oJtnqw9qmrUb1AxHEWS1WPN2JqvbPP8t9DaC7Z5KjmsKklSw3CUJKlhOArgpNmuwCywzfPfQmsv2OYp4z1HSZIa9hwlSWoYjpIkNQzHBSTJwUl+muTnSV41yvbNkpzab/9ukpUzX8upM0R7X5bkR0kuTPLVkUeVzWUTtXmg3JOSVJI5P+1/mDYnOaL/WV+c5KMzXcepNsTf7RVJzkzyg/7v9yGzUc+pkuR9Sf7YPxlptO1J8o7+elyY5AEbfNKq8rUAXsAi4BfAnsAS4AJgv6bMC4B398tH0j1oedbrPo3tfSSwZb/8/Lnc3mHb3JdbBpwFnAOsmu16z8DPeR/gB8B2/fudZrveM9Dmk4Dn98v7AZfMdr03sM1/BTwAuGiM7YcAn6d74MSDge9u6DntOS4cDwJ+XlW/rKpbgVOAw5oyhwEjj8j6BPCoJGFumrC9VXVmVd3Yvz0HuNsM13GqDfMzBvgnumeM3jyTlZsmw7T5OcC7qupqgKr64wzXcaoN0+aie8A8dA9b//0M1m/KVdVZwFXjFDkM+GB1zgG2TbLrhpzTcFw4dgd+O/D+0n7dqGWqe9TXtcAOM1K7qTdMewc9m+5/nnPZhG3uh5vuXlWfm8mKTaNhfs73BO6Z5Owk5yQ5eMZqNz2GafPxwNOSXAr8B/DimanarJnsv/cJzatHVknrI8nTgFXAX892XaZTkk2AtwPHzHJVZtpiuqHVR9CNDpyV5L7VPeJuvjoKOLmq/neShwAfSnKfqlo32xWbK+w5Lhy/A+4+8P5u/bpRy/QPjN4GuHJGajf1hmkvSQ4CXgM8vqpumaG6TZeJ2rwMuA/w9SSX0N2bOWOOT8oZ5ud8KXBGVf25qn4F/IwuLOeqYdr8bOA0gKr6DrA53Rd0z1dD/XufDMNx4fg+sE+SeyRZQjfh5oymzBnAM/vlw4GvVX+3ew6asL1J7g+8hy4Y5/p9KJigzVV1bVUtr6qVVbWS7j7r46tq9exUd0oM8/f603S9RpIspxtm/eVMVnKKDdPm3wCPAkhyb7pw/NOM1nJmnQE8o5+1+mDg2qr6w4Yc0GHVBaKqbkvyIuCLdLPd3ldVFyd5A7C6qs4A/i/d8MvP6W5+Hzl7Nd4wQ7b3rcBS4OP9vKPfVNXjZ63SG2jINs8rQ7b5i8Cjk/wIWAu8oqrm6ojIsG3+e+Dfk/wd3eScY+bwf3RJ8jG6/+As7++jvh7YFKCq3k13X/UQ4OfAjcCzNvicc/h6SZI0LRxWlSSpYThKktQwHCVJahiOkiQ1DEdJkhqGoyRJDcNRkqTG/weoqY8zn1es4QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "# 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 6 - Question.ipynb",
   "provenance": []
  },
  "coursera": {
   "course_slug": "convolutional-neural-networks-tensorflow",
   "graded_item_id": "uAPOR",
   "launcher_item_id": "e9lTb"
  },
  "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
}