Cats_vs_Dogs_CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dn-6c02VmqiN"
   },
   "outputs": [],
   "source": [
    "# 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",
    "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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/cats-v-dogs created\n",
      "/tmp/cats-v-dogs/training created\n",
      "/tmp/cats-v-dogs/testing created\n",
      "/tmp/cats-v-dogs/training/cats created\n",
      "/tmp/cats-v-dogs/training/dogs created\n",
      "/tmp/cats-v-dogs/testing/cats created\n",
      "/tmp/cats-v-dogs/testing/dogs created\n"
     ]
    }
   ],
   "source": [
    "to_create = [\n",
    "    '/tmp/cats-v-dogs',\n",
    "    '/tmp/cats-v-dogs/training',\n",
    "    '/tmp/cats-v-dogs/testing',\n",
    "    '/tmp/cats-v-dogs/training/cats',\n",
    "    '/tmp/cats-v-dogs/training/dogs',\n",
    "    '/tmp/cats-v-dogs/testing/cats',\n",
    "    '/tmp/cats-v-dogs/testing/dogs'\n",
    "]\n",
    "\n",
    "for directory in to_create:\n",
    "    try:\n",
    "        os.mkdir(directory)\n",
    "        print(directory, 'created')\n",
    "    except OSError:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zvSODo0f9LaU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1500\n",
      "1500\n"
     ]
    }
   ],
   "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",
    "    files = []\n",
    "    for fname in os.listdir(SOURCE):\n",
    "        fpath = SOURCE + fname\n",
    "        if os.path.getsize(fpath) > 0:\n",
    "            files.append(fname)\n",
    "        else:\n",
    "            print(fname + \" is zero length, so ignoring.\")\n",
    "    \n",
    "    xfiles = len(files)\n",
    "    print(xfiles)\n",
    "    splitdata = int(xfiles *  SPLIT_SIZE)\n",
    "    shuffle = random.sample(files, xfiles) #chose random xfile from all files shuffled list\n",
    "    trainf = shuffle[:splitdata] #splited data from decided splite oran, first %90 for training rest test\n",
    "    testf = shuffle[splitdata:]\n",
    "    for fname in trainf:\n",
    "        copyfile(SOURCE + fname, TRAINING + fname)\n",
    "    for fname in testf:\n",
    "        copyfile(SOURCE + fname, TESTING + fname) \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/')))"
   ]
  },
  {
   "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",
    "model = tf.keras.models.Sequential([\n",
    "    # Note the input shape is the desired size of the image 150x150 with 3 bytes color\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",
    "    # Flatten the results to feed into a DNN\n",
    "    tf.keras.layers.Flatten(), \n",
    "    # 512 neuron hidden layer\n",
    "    tf.keras.layers.Dense(512, activation='relu'), \n",
    "    # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('cats') and 1 for the other ('dogs')\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": 8,
   "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",
    "train_datagen = ImageDataGenerator(rescale=1.0/255.) \n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(TRAINING_DIR,\n",
    "                                                    batch_size=10,\n",
    "                                                    class_mode='binary',\n",
    "                                                    target_size=(150, 150)) \n",
    "\n",
    "VALIDATION_DIR = '/tmp/cats-v-dogs/testing'\n",
    "validation_datagen = ImageDataGenerator(rescale = 1.0/255.) \n",
    "\n",
    "\n",
    "validation_generator = validation_datagen.flow_from_directory(VALIDATION_DIR,\n",
    "                                                         batch_size=10,\n",
    "                                                         class_mode  = 'binary',\n",
    "                                                         target_size = (150, 150)) #YOUR CODE HERE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KyS4n53w7DxC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "270/270 [==============================] - 35s 130ms/step - loss: 2.0130 - acc: 0.5552 - val_loss: 0.7042 - val_acc: 0.5800\n",
      "Epoch 2/2\n",
      "270/270 [==============================] - 31s 116ms/step - loss: 0.6225 - acc: 0.6800 - val_loss: 0.6842 - val_acc: 0.6367\n"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(train_generator,\n",
    "                              epochs=2, #at 2 we reach very good accurcy so we dont need to train mare epoch\n",
    "                              validation_data=validation_generator)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MWZrJN4-65RC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Training and validation loss')"
      ]
     },
     "execution_count": 10,
     "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": 11,
   "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
}