utf-8''Exercise_2_Cats_vs_Dogs_using_augmentation_Question-course 2.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": 3,
   "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": 4,
   "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": 22,
   "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",
    "    #YOUR CODE GOES HERE\n",
    "    os.mkdir('/tmp/cats-v-dogs')\n",
    "    os.mkdir('/tmp/cats-v-dogs/training')\n",
    "    os.mkdir('/tmp/cats-v-dogs/testing')\n",
    "    os.mkdir('/tmp/cats-v-dogs/training/cats')\n",
    "    os.mkdir('/tmp/cats-v-dogs/training/dogs')\n",
    "    os.mkdir('/tmp/cats-v-dogs/testing/cats')\n",
    "    os.mkdir('/tmp/cats-v-dogs/testing/dogs')\n",
    "except OSError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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",
    "# YOUR CODE STARTS HERE\n",
    "    dataset = []\n",
    "    \n",
    "    for unitData in os.listdir(SOURCE):\n",
    "        data = SOURCE + unitData\n",
    "        if(os.path.getsize(data) > 0):\n",
    "            dataset.append(unitData)\n",
    "        else:\n",
    "            print('Skipped ' + unitData)\n",
    "    \n",
    "    train_set_length = int(len(dataset) * SPLIT_SIZE)\n",
    "    test_set_length = int(len(dataset) - train_set_length)\n",
    "    shuffled_set = random.sample(dataset, len(dataset))\n",
    "    train_set = dataset[0:train_set_length]\n",
    "    test_set = dataset[-test_set_length:]\n",
    "       \n",
    "    for unitData in train_set:\n",
    "        temp_train_set = SOURCE + unitData\n",
    "        final_train_set = TRAINING + unitData\n",
    "        copyfile(temp_train_set, final_train_set)\n",
    "    \n",
    "    for unitData in test_set:\n",
    "        temp_test_set = SOURCE + unitData\n",
    "        final_test_set = TESTING + unitData\n",
    "        copyfile(temp_test_set, final_test_set)\n",
    "    \n",
    "# YOUR CODE ENDS HERE\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": 24,
   "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": 26,
   "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",
    "    tf.keras.layers.Conv2D(16,(3,3),activation='relu',input_shape=(300,300,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.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": 27,
   "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' #YOUR CODE HERE\n",
    "train_datagen = ImageDataGenerator(\n",
    "    rescale=1.0/255.0,\n",
    "    rotation_range=40,\n",
    "    horizontal_flip=True,\n",
    "    width_shift_range=0.2,\n",
    "    height_shift_range=0.2,\n",
    "    zoom_range=0.2,\n",
    "    shear_range=0.2,\n",
    "    fill_mode='nearest'\n",
    ")#YOUR CODE HERE\n",
    "\n",
    "# NOTE: YOU MUST USE A BATCH SIZE OF 10 (batch_size=10) FOR THE \n",
    "# TRAIN GENERATOR.\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "    TRAINING_DIR,\n",
    "    batch_size=10,\n",
    "    target_size=(300,300),\n",
    "    class_mode='binary')\n",
    "#YOUR CODE HERE\n",
    "\n",
    "VALIDATION_DIR ='/tmp/cats-v-dogs/testing' #YOUR CODE HERE\n",
    "validation_datagen =ImageDataGenerator(rescale=1/255) #YOUR CODE HERE\n",
    "\n",
    "# NOTE: YOU MUST USE A BACTH SIZE OF 10 (batch_size=10) FOR THE \n",
    "# VALIDATION GENERATOR.\n",
    "validation_generator = validation_datagen.flow_from_directory(\n",
    "    \n",
    "    VALIDATION_DIR,\n",
    "     batch_size=10,\n",
    "    target_size=(300,300),\n",
    "    class_mode='binary'\n",
    ")#YOUR CODE HERE\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": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KyS4n53w7DxC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "270/270 [==============================] - 149s 551ms/step - loss: 0.7092 - acc: 0.5530 - val_loss: 0.6802 - val_acc: 0.5867\n",
      "Epoch 2/2\n",
      "270/270 [==============================] - 147s 546ms/step - loss: 0.6748 - acc: 0.6052 - val_loss: 0.6377 - val_acc: 0.6200\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": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MWZrJN4-65RC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Training and validation loss')"
      ]
     },
     "execution_count": 29,
     "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": "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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
}