Cats_vs_Dogs_Image_Classifier.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/TechWithRamaa/ConvNets-in-Tensorflow/blob/main/Cats_vs_Dogs_Image_Classifier.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a10bc2ee",
      "metadata": {
        "id": "a10bc2ee"
      },
      "source": [
        "# Week 1: Using CNN's with the Cats vs Dogs Dataset\n",
        "\n",
        "Welcome to the 1st assignment of the course! This week, you will be using the famous `Cats vs Dogs` dataset to train a model that can classify images of dogs from images of cats. For this, you will create your own Convolutional Neural Network in Tensorflow and leverage Keras' image preprocessing utilities.\n",
        "\n",
        "You will also create some helper functions to move the images around the filesystem so if you are not familiar with the `os` module be sure to take a look a the [docs](https://docs.python.org/3/library/os.html).\n",
        "\n",
        "Let's get started!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7dd65c4f",
      "metadata": {
        "id": "7dd65c4f"
      },
      "source": [
        "_**NOTE:** To prevent errors from the autograder, please avoid editing or deleting non-graded cells in this notebook . Please only put your solutions in between the `### START CODE HERE` and `### END CODE HERE` code comments, and refrain from adding any new cells._"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "id": "d43abc49",
      "metadata": {
        "id": "d43abc49"
      },
      "outputs": [],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "import os\n",
        "import zipfile\n",
        "import random\n",
        "import shutil\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from shutil import copyfile\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0000eebe",
      "metadata": {
        "id": "0000eebe"
      },
      "source": [
        "Download the dataset from its original source by running the cell below.\n",
        "\n",
        "Note that the `zip` file that contains the images is unzipped under the `/tmp` directory."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "id": "dfe8528d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dfe8528d",
        "outputId": "ccf8aa25-bcc5-440b-e46b-6d7b0f1fcc8a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-08-07 18:44:14--  https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip\n",
            "Resolving download.microsoft.com (download.microsoft.com)... 23.63.210.18, 2600:1406:4c00:299::317f, 2600:1406:4c00:2a6::317f\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|23.63.210.18|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 824887076 (787M) [application/octet-stream]\n",
            "Saving to: ‘/tmp/cats-and-dogs.zip’\n",
            "\n",
            "/tmp/cats-and-dogs. 100%[===================>] 786.67M   137MB/s    in 5.9s    \n",
            "\n",
            "2024-08-07 18:44:20 (134 MB/s) - ‘/tmp/cats-and-dogs.zip’ saved [824887076/824887076]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# If the URL doesn't work, visit https://www.microsoft.com/en-us/download/confirmation.aspx?id=54765\n",
        "# And right click on the 'Download Manually' link to get a new URL to the dataset\n",
        "\n",
        "# Note: This is a very large dataset and will take some time to download\n",
        "\n",
        "!wget --no-check-certificate \\\n",
        "    \"https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip\" \\\n",
        "    -O \"/tmp/cats-and-dogs.zip\"\n",
        "\n",
        "local_zip = '/tmp/cats-and-dogs.zip'\n",
        "zip_ref   = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp')\n",
        "zip_ref.close()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4dd9f52b",
      "metadata": {
        "id": "4dd9f52b"
      },
      "source": [
        "Now the images are stored within the `/tmp/PetImages` directory. There is a subdirectory for each class, so one for dogs and one for cats."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "76034c9d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "76034c9d",
        "outputId": "34014b1f-4f9a-402e-d3af-a8ac57d06fee"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 12500 images of dogs.\n",
            "There are 12500 images of cats.\n"
          ]
        }
      ],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "source_path = '/tmp/PetImages'\n",
        "\n",
        "source_path_dogs = os.path.join(source_path, 'Dog')\n",
        "source_path_cats = os.path.join(source_path, 'Cat')\n",
        "\n",
        "# Deletes all non-image files (there are two .db files bundled into the dataset)\n",
        "!find /tmp/PetImages/ -type f ! -name \"*.jpg\" -exec rm {} +\n",
        "\n",
        "# os.listdir returns a list containing all files under the given path\n",
        "print(f\"There are {len(os.listdir(source_path_dogs))} images of dogs.\")\n",
        "print(f\"There are {len(os.listdir(source_path_cats))} images of cats.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1b32b528",
      "metadata": {
        "id": "1b32b528"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "There are 12500 images of dogs.\n",
        "There are 12500 images of cats.\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6753b45c",
      "metadata": {
        "id": "6753b45c"
      },
      "source": [
        "You will need a directory for cats-v-dogs, and subdirectories for training\n",
        "and validation. These in turn will need subdirectories for 'cats' and 'dogs'. To accomplish this, complete the `create_train_val_dirs` below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "id": "1e6c840a",
      "metadata": {
        "cellView": "code",
        "id": "1e6c840a"
      },
      "outputs": [],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# Define root directory\n",
        "root_dir = '/tmp/cats-v-dogs'\n",
        "\n",
        "# Empty directory to prevent FileExistsError is the function is run several times\n",
        "if os.path.exists(root_dir):\n",
        "  shutil.rmtree(root_dir)\n",
        "\n",
        "# GRADED FUNCTION: create_train_val_dirs\n",
        "def create_train_val_dirs(root_path):\n",
        "  \"\"\"\n",
        "  Creates directories for the train and test sets\n",
        "\n",
        "  Args:\n",
        "    root_path (string) - the base directory path to create subdirectories from\n",
        "\n",
        "  Returns:\n",
        "    None\n",
        "  \"\"\"\n",
        "  ### START CODE HERE\n",
        "\n",
        "  # HINT:\n",
        "  # Use os.makedirs to create your directories with intermediate subdirectories\n",
        "  # Don't hardcode the paths. Use os.path.join to append the new directories to the root_path parameter\n",
        "\n",
        "  pass\n",
        "\n",
        "  # Paths for training and validation directories\n",
        "  train_dir = os.path.join(root_path, 'training')\n",
        "  val_dir = os.path.join(root_path, 'validation')\n",
        "\n",
        "  # Paths for cats and dogs subdirectories in training and validation directories\n",
        "  train_cats_dir = os.path.join(train_dir, 'cats')\n",
        "  train_dogs_dir = os.path.join(train_dir, 'dogs')\n",
        "  val_cats_dir = os.path.join(val_dir, 'cats')\n",
        "  val_dogs_dir = os.path.join(val_dir, 'dogs')\n",
        "\n",
        "  # Create the directories\n",
        "  os.makedirs(train_cats_dir)\n",
        "  os.makedirs(train_dogs_dir)\n",
        "  os.makedirs(val_cats_dir)\n",
        "  os.makedirs(val_dogs_dir)\n",
        "\n",
        "\n",
        "  ### END CODE HERE\n",
        "\n",
        "\n",
        "try:\n",
        "  create_train_val_dirs(root_path=root_dir)\n",
        "except FileExistsError:\n",
        "  print(\"You should not be seeing this since the upper directory is removed beforehand\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "08f735fe",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "08f735fe",
        "outputId": "23c748eb-4334-49d3-d0d3-be82f13429a8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/tmp/cats-v-dogs/validation\n",
            "/tmp/cats-v-dogs/training\n",
            "/tmp/cats-v-dogs/validation/dogs\n",
            "/tmp/cats-v-dogs/validation/cats\n",
            "/tmp/cats-v-dogs/training/dogs\n",
            "/tmp/cats-v-dogs/training/cats\n"
          ]
        }
      ],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# Test your create_train_val_dirs function\n",
        "\n",
        "for rootdir, dirs, files in os.walk(root_dir):\n",
        "    for subdir in dirs:\n",
        "        print(os.path.join(rootdir, subdir))"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "09e13d4e",
      "metadata": {
        "id": "09e13d4e"
      },
      "source": [
        "**Expected Output (directory order might vary):**\n",
        "\n",
        "``` txt\n",
        "/tmp/cats-v-dogs/training\n",
        "/tmp/cats-v-dogs/validation\n",
        "/tmp/cats-v-dogs/training/cats\n",
        "/tmp/cats-v-dogs/training/dogs\n",
        "/tmp/cats-v-dogs/validation/cats\n",
        "/tmp/cats-v-dogs/validation/dogs\n",
        "\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9413f4e5",
      "metadata": {
        "id": "9413f4e5"
      },
      "source": [
        "Code the `split_data` function which takes in the following arguments:\n",
        "- SOURCE_DIR: directory containing the files\n",
        "\n",
        "- TRAINING_DIR: directory that a portion of the files will be copied to (will be used for training)\n",
        "- VALIDATION_DIR: directory that a portion of the files will be copied to (will be used for validation)\n",
        "- SPLIT_SIZE: determines the portion of images used for training.\n",
        "\n",
        "The files should be randomized, so that the training set is a random sample of the files, and the validation set is made up of the remaining files.\n",
        "\n",
        "For example, if `SOURCE_DIR` is `PetImages/Cat`, and `SPLIT_SIZE` is .9 then 90% of the images in `PetImages/Cat` will be copied to the `TRAINING_DIR` directory\n",
        "and 10% of the images will be copied to the `VALIDATION_DIR` directory.\n",
        "\n",
        "All images should be checked before the copy, so if they have a zero file length, they will be omitted from the copying process. If this is the case then your function should print out a message such as `\"filename is zero length, so ignoring.\"`. **You should perform this check before the split so that only non-zero images are considered when doing the actual split.**\n",
        "\n",
        "\n",
        "Hints:\n",
        "\n",
        "- `os.listdir(DIRECTORY)` returns a list with the contents of that directory.\n",
        "\n",
        "- `os.path.getsize(PATH)` returns the size of the file\n",
        "\n",
        "- `copyfile(source, destination)` copies a file from source to destination\n",
        "\n",
        "- `random.sample(list, len(list))` shuffles a list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "e1c123a7",
      "metadata": {
        "cellView": "code",
        "id": "e1c123a7"
      },
      "outputs": [],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# GRADED FUNCTION: split_data\n",
        "def split_data(SOURCE_DIR, TRAINING_DIR, VALIDATION_DIR, SPLIT_SIZE):\n",
        "  \"\"\"\n",
        "  Splits the data into train and test sets\n",
        "\n",
        "  Args:\n",
        "    SOURCE_DIR (string): directory path containing the images\n",
        "    TRAINING_DIR (string): directory path to be used for training\n",
        "    VALIDATION_DIR (string): directory path to be used for validation\n",
        "    SPLIT_SIZE (float): proportion of the dataset to be used for training\n",
        "\n",
        "  Returns:\n",
        "    None\n",
        "  \"\"\"\n",
        "\n",
        "  ### START CODE HERE\n",
        "  pass\n",
        "  # Get list of all files in the source directory\n",
        "  files = os.listdir(SOURCE_DIR)\n",
        "\n",
        "  # Filter out zero-length files\n",
        "  all_files = [f for f in files if os.path.getsize(os.path.join(SOURCE_DIR, f)) > 0]\n",
        "  if len(all_files) != len(files):\n",
        "    for f in files:\n",
        "      if os.path.getsize(os.path.join(SOURCE_DIR, f)) == 0:\n",
        "        print(f\"{f} is zero length, so ignoring.\")\n",
        "\n",
        "  # Shuffle the list of files\n",
        "  random.shuffle(all_files)\n",
        "\n",
        "  # Calculate the split index\n",
        "  split_index = int(len(all_files) * SPLIT_SIZE)\n",
        "\n",
        "  # Split the files into training and validation sets\n",
        "  train_files = all_files[:split_index]\n",
        "  val_files = all_files[split_index:]\n",
        "\n",
        "  # Copy the files to the respective directories\n",
        "  for f in train_files:\n",
        "    copyfile(os.path.join(SOURCE_DIR, f), os.path.join(TRAINING_DIR, f))\n",
        "\n",
        "  for f in val_files:\n",
        "    copyfile(os.path.join(SOURCE_DIR, f), os.path.join(VALIDATION_DIR, f))\n",
        "\n",
        "\n",
        "  ### END CODE HERE"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "7f488106",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7f488106",
        "outputId": "5de895c4-a8e4-4c63-e2bb-9db3643b648e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "666.jpg is zero length, so ignoring.\n",
            "11702.jpg is zero length, so ignoring.\n",
            "\n",
            "\n",
            "Original cat's directory has 12500 images\n",
            "Original dog's directory has 12500 images\n",
            "\n",
            "There are 11249 images of cats for training\n",
            "There are 11249 images of dogs for training\n",
            "There are 1250 images of cats for validation\n",
            "There are 1250 images of dogs for validation\n"
          ]
        }
      ],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# Test your split_data function\n",
        "\n",
        "# Define paths\n",
        "CAT_SOURCE_DIR = \"/tmp/PetImages/Cat/\"\n",
        "DOG_SOURCE_DIR = \"/tmp/PetImages/Dog/\"\n",
        "\n",
        "TRAINING_DIR = \"/tmp/cats-v-dogs/training/\"\n",
        "VALIDATION_DIR = \"/tmp/cats-v-dogs/validation/\"\n",
        "\n",
        "TRAINING_CATS_DIR = os.path.join(TRAINING_DIR, \"cats/\")\n",
        "VALIDATION_CATS_DIR = os.path.join(VALIDATION_DIR, \"cats/\")\n",
        "\n",
        "TRAINING_DOGS_DIR = os.path.join(TRAINING_DIR, \"dogs/\")\n",
        "VALIDATION_DOGS_DIR = os.path.join(VALIDATION_DIR, \"dogs/\")\n",
        "\n",
        "# Empty directories in case you run this cell multiple times\n",
        "if len(os.listdir(TRAINING_CATS_DIR)) > 0:\n",
        "  for file in os.scandir(TRAINING_CATS_DIR):\n",
        "    os.remove(file.path)\n",
        "if len(os.listdir(TRAINING_DOGS_DIR)) > 0:\n",
        "  for file in os.scandir(TRAINING_DOGS_DIR):\n",
        "    os.remove(file.path)\n",
        "if len(os.listdir(VALIDATION_CATS_DIR)) > 0:\n",
        "  for file in os.scandir(VALIDATION_CATS_DIR):\n",
        "    os.remove(file.path)\n",
        "if len(os.listdir(VALIDATION_DOGS_DIR)) > 0:\n",
        "  for file in os.scandir(VALIDATION_DOGS_DIR):\n",
        "    os.remove(file.path)\n",
        "\n",
        "# Define proportion of images used for training\n",
        "split_size = .9\n",
        "\n",
        "# Run the function\n",
        "# NOTE: Messages about zero length images should be printed out\n",
        "split_data(CAT_SOURCE_DIR, TRAINING_CATS_DIR, VALIDATION_CATS_DIR, split_size)\n",
        "split_data(DOG_SOURCE_DIR, TRAINING_DOGS_DIR, VALIDATION_DOGS_DIR, split_size)\n",
        "\n",
        "# Check that the number of images matches the expected output\n",
        "\n",
        "# Your function should perform copies rather than moving images so original directories should contain unchanged images\n",
        "print(f\"\\n\\nOriginal cat's directory has {len(os.listdir(CAT_SOURCE_DIR))} images\")\n",
        "print(f\"Original dog's directory has {len(os.listdir(DOG_SOURCE_DIR))} images\\n\")\n",
        "\n",
        "# Training and validation splits\n",
        "print(f\"There are {len(os.listdir(TRAINING_CATS_DIR))} images of cats for training\")\n",
        "print(f\"There are {len(os.listdir(TRAINING_DOGS_DIR))} images of dogs for training\")\n",
        "print(f\"There are {len(os.listdir(VALIDATION_CATS_DIR))} images of cats for validation\")\n",
        "print(f\"There are {len(os.listdir(VALIDATION_DOGS_DIR))} images of dogs for validation\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "dbb2aedc",
      "metadata": {
        "id": "dbb2aedc"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "666.jpg is zero length, so ignoring.\n",
        "11702.jpg is zero length, so ignoring.\n",
        "\n",
        "\n",
        "Original cat's directory has 12500 images\n",
        "Original dog's directory has 12500 images\n",
        "\n",
        "There are 11249 images of cats for training\n",
        "There are 11249 images of dogs for training\n",
        "There are 1250 images of cats for validation\n",
        "There are 1250 images of dogs for validation\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "32a30ba6",
      "metadata": {
        "id": "32a30ba6"
      },
      "source": [
        "Now that you have successfully organized the data in a way that can be easily fed to Keras' `ImageDataGenerator`, it is time for you to code the generators that will yield batches of images, both for training and validation. For this, complete the `train_val_generators` function below.\n",
        "\n",
        "Something important to note is that the images in this dataset come in a variety of resolutions. Luckily, the `flow_from_directory` method allows you to standarize this by defining a tuple called `target_size` that will be used to convert each image to this target resolution. **For this exercise, use a `target_size` of (150, 150)**.\n",
        "\n",
        "**Hint:**\n",
        "\n",
        "Don't use data augmentation by setting extra parameters when you instantiate the `ImageDataGenerator` class. This will make the training of your model to take longer to reach the necessary accuracy threshold to pass this assignment and this topic will be covered in the next week."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "24714cb2",
      "metadata": {
        "cellView": "code",
        "id": "24714cb2"
      },
      "outputs": [],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# GRADED FUNCTION: train_val_generators\n",
        "def train_val_generators(TRAINING_DIR, VALIDATION_DIR):\n",
        "    \"\"\"\n",
        "    Creates the training and validation data generators\n",
        "\n",
        "    Args:\n",
        "      TRAINING_DIR (string): directory path containing the training images\n",
        "      VALIDATION_DIR (string): directory path containing the testing/validation images\n",
        "\n",
        "    Returns:\n",
        "      train_generator, validation_generator - tuple containing the generators\n",
        "    \"\"\"\n",
        "    ### START CODE HERE\n",
        "\n",
        "    # Instantiate the ImageDataGenerator class (don't forget to set the rescale argument)\n",
        "    train_datagen = ImageDataGenerator(rescale=1.0/255.0)\n",
        "\n",
        "    # Pass in the appropriate arguments to the flow_from_directory method\n",
        "    train_generator = train_datagen.flow_from_directory(directory=TRAINING_DIR,\n",
        "                                                        batch_size=20,\n",
        "                                                        class_mode='binary',\n",
        "                                                        target_size=(150, 150))\n",
        "\n",
        "    # Instantiate the ImageDataGenerator class (don't forget to set the rescale argument)\n",
        "    validation_datagen = ImageDataGenerator(rescale=1.0/255.0)\n",
        "\n",
        "    # Pass in the appropriate arguments to the flow_from_directory method\n",
        "    validation_generator = validation_datagen.flow_from_directory(directory=VALIDATION_DIR,\n",
        "                                                                  batch_size=20,\n",
        "                                                                  class_mode='binary',\n",
        "                                                                  target_size=(150, 150))\n",
        "    ### END CODE HERE\n",
        "    return train_generator, validation_generator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "0a13c894",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0a13c894",
        "outputId": "fa414fc4-f940-41d2-b3be-b2dc30cc5ffe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 22498 images belonging to 2 classes.\n",
            "Found 2500 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# Test your generators\n",
        "train_generator, validation_generator = train_val_generators(TRAINING_DIR, VALIDATION_DIR)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2992173c",
      "metadata": {
        "id": "2992173c"
      },
      "source": [
        "**Expected Output:**\n",
        "\n",
        "```\n",
        "Found 22498 images belonging to 2 classes.\n",
        "Found 2500 images belonging to 2 classes.\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4b01ac22",
      "metadata": {
        "id": "4b01ac22"
      },
      "source": [
        "One last step before training is to define the architecture of the model that will be trained.\n",
        "\n",
        "Complete the `create_model` function below which should return a Keras' `Sequential` model.\n",
        "\n",
        "Aside from defining the architecture of the model, you should also compile it so make sure to use a `loss` function that is compatible with the `class_mode` you defined in the previous exercise, which should also be compatible with the output of your network. You can tell if they aren't compatible if you get an error during training.\n",
        "\n",
        "**Note that you should use at least 3 convolution layers to achieve the desired performance.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "2141d195",
      "metadata": {
        "cellView": "code",
        "id": "2141d195"
      },
      "outputs": [],
      "source": [
        "# grader-required-cell\n",
        "\n",
        "# GRADED FUNCTION: create_model\n",
        "def create_model():\n",
        "    # DEFINE A KERAS MODEL TO CLASSIFY CATS V DOGS\n",
        "    # USE AT LEAST 3 CONVOLUTION LAYERS\n",
        "\n",
        "    ### START CODE HERE\n",
        "\n",
        "    model = tf.keras.models.Sequential([\n",
        "        # First convolutional layer\n",
        "        tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),\n",
        "        tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),\n",
        "\n",
        "        # Second convolutional layer\n",
        "        tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n",
        "        tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),\n",
        "\n",
        "        # Third convolutional layer\n",
        "        tf.keras.layers.Conv2D(128, (3, 3), activation='relu'),\n",
        "        tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),\n",
        "\n",
        "        # Flatten the output\n",
        "        tf.keras.layers.Flatten(),\n",
        "\n",
        "        # Fully connected layer\n",
        "        tf.keras.layers.Dense(512, activation='relu'),\n",
        "\n",
        "        # Output layer with 1 unit for binary classification\n",
        "        tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "    ])\n",
        "\n",
        "    model.compile(optimizer='adam',\n",
        "                  loss='binary_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "\n",
        "    ### END CODE HERE\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5fe2ed9f",
      "metadata": {
        "id": "5fe2ed9f"
      },
      "source": [
        "Now it is time to train your model!\n",
        "\n",
        "**Note:** You can ignore the `UserWarning: Possibly corrupt EXIF data.` warnings."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "id": "87cbef80",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "87cbef80",
        "outputId": "87fbb9f6-beca-494b-d3d5-9b0aaba1438f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n",
            "/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
            "  self._warn_if_super_not_called()\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 43ms/step - accuracy: 0.5867 - loss: 0.6744"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/PIL/TiffImagePlugin.py:858: UserWarning: Truncated File Read\n",
            "  warnings.warn(str(msg))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m59s\u001b[0m 47ms/step - accuracy: 0.5867 - loss: 0.6744 - val_accuracy: 0.7692 - val_loss: 0.4814\n",
            "Epoch 2/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 43ms/step - accuracy: 0.7865 - loss: 0.4531 - val_accuracy: 0.8108 - val_loss: 0.3993\n",
            "Epoch 3/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 44ms/step - accuracy: 0.8439 - loss: 0.3532 - val_accuracy: 0.8204 - val_loss: 0.4111\n",
            "Epoch 4/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 42ms/step - accuracy: 0.8997 - loss: 0.2411 - val_accuracy: 0.8328 - val_loss: 0.4139\n",
            "Epoch 5/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 44ms/step - accuracy: 0.9466 - loss: 0.1356 - val_accuracy: 0.8388 - val_loss: 0.5181\n",
            "Epoch 6/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 43ms/step - accuracy: 0.9777 - loss: 0.0589 - val_accuracy: 0.8468 - val_loss: 0.6368\n",
            "Epoch 7/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 43ms/step - accuracy: 0.9883 - loss: 0.0352 - val_accuracy: 0.8228 - val_loss: 0.6935\n",
            "Epoch 8/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m50s\u001b[0m 44ms/step - accuracy: 0.9924 - loss: 0.0266 - val_accuracy: 0.8348 - val_loss: 0.7588\n",
            "Epoch 9/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m49s\u001b[0m 43ms/step - accuracy: 0.9938 - loss: 0.0190 - val_accuracy: 0.8268 - val_loss: 0.8630\n",
            "Epoch 10/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m48s\u001b[0m 42ms/step - accuracy: 0.9937 - loss: 0.0306 - val_accuracy: 0.8376 - val_loss: 0.9965\n",
            "Epoch 11/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m104s\u001b[0m 62ms/step - accuracy: 0.9913 - loss: 0.0266 - val_accuracy: 0.8192 - val_loss: 0.8873\n",
            "Epoch 12/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m61s\u001b[0m 43ms/step - accuracy: 0.9965 - loss: 0.0154 - val_accuracy: 0.8276 - val_loss: 1.0409\n",
            "Epoch 13/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 43ms/step - accuracy: 0.9925 - loss: 0.0268 - val_accuracy: 0.8044 - val_loss: 1.0137\n",
            "Epoch 14/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 45ms/step - accuracy: 0.9936 - loss: 0.0255 - val_accuracy: 0.8272 - val_loss: 1.1703\n",
            "Epoch 15/15\n",
            "\u001b[1m1125/1125\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m90s\u001b[0m 52ms/step - accuracy: 0.9968 - loss: 0.0125 - val_accuracy: 0.8224 - val_loss: 1.2904\n"
          ]
        }
      ],
      "source": [
        "# Get the untrained model\n",
        "model = create_model()\n",
        "\n",
        "# Train the model\n",
        "# Note that this may take some time.\n",
        "history = model.fit(train_generator,\n",
        "                    epochs=15,\n",
        "                    verbose=1,\n",
        "                    validation_data=validation_generator)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "80ccc14c",
      "metadata": {
        "id": "80ccc14c"
      },
      "source": [
        "Once training has finished, you can run the following cell to check the training and validation accuracy achieved at the end of each epoch.\n",
        "\n",
        "**To pass this assignment, your model should achieve a training accuracy of at least 95% and a validation accuracy of at least 80%**. If your model didn't achieve these thresholds, try training again with a different model architecture and remember to use at least 3 convolutional layers."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "id": "32146607",
      "metadata": {
        "id": "32146607",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 882
        },
        "outputId": "2f613ea6-cb11-40e2-b719-1dcb5bb142e8"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#-----------------------------------------------------------\n",
        "# Retrieve a list of list results on training and test data\n",
        "# sets for each training epoch\n",
        "#-----------------------------------------------------------\n",
        "acc=history.history['accuracy']\n",
        "val_acc=history.history['val_accuracy']\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.show()\n",
        "print(\"\")\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",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3288957c",
      "metadata": {
        "id": "3288957c"
      },
      "source": [
        "You will probably encounter that the model is overfitting, which means that it is doing a great job at classifying the images in the training set but struggles with new data. This is perfectly fine and you will learn how to mitigate this issue in the upcoming week.\n",
        "\n",
        "Before downloading this notebook and closing the assignment, be sure to also download the `history.pkl` file which contains the information of the training history of your model. You can download this file by running the cell below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "id": "a724b784",
      "metadata": {
        "id": "a724b784",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "6ed62dd6-30f7-44aa-e97c-9e76f8507fd3"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_95ac81e6-108e-442e-94af-f19129cfc282\", \"history.pkl\", 616)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "def download_history():\n",
        "  import pickle\n",
        "  from google.colab import files\n",
        "\n",
        "  with open('history.pkl', 'wb') as f:\n",
        "    pickle.dump(history.history, f)\n",
        "\n",
        "  files.download('history.pkl')\n",
        "\n",
        "download_history()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f5cc8c73",
      "metadata": {
        "id": "f5cc8c73"
      },
      "source": [
        "## Download your notebook for grading\n",
        "\n",
        "Along with the `history.pkl` file, you will also need to submit your solution notebook for grading. The following code cells will check if this notebook's grader metadata (i.e. hidden data in the notebook needed for grading) is not modified by your workspace. This will ensure that the autograder can evaluate your code properly. Depending on its output, you will either:\n",
        "\n",
        "* *if the metadata is intact*: Download the current notebook. Click on the File tab on the upper left corner of the screen then click on `Download -> Download .ipynb.` You can name it anything you want as long as it is a valid `.ipynb` (jupyter notebook) file.\n",
        "<br>\n",
        "\n",
        "* *if the metadata is missing*: A new notebook with your solutions will be created on this Colab workspace. It should be downloaded automatically and you can submit that to the grader."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "id": "b0b94f9f",
      "metadata": {
        "id": "b0b94f9f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ebd8a8e7-bba5-4f30-b46c-1a2158d47fd5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-08-07 19:07:14--  https://storage.googleapis.com/tensorflow-1-public/colab_metadata_checker.py\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 142.251.2.207, 74.125.137.207, 142.250.101.207, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|142.251.2.207|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 1997 (2.0K) [text/x-python-script]\n",
            "Saving to: ‘colab_metadata_checker.py’\n",
            "\n",
            "\r          colab_met   0%[                    ]       0  --.-KB/s               \rcolab_metadata_chec 100%[===================>]   1.95K  --.-KB/s    in 0s      \n",
            "\n",
            "2024-08-07 19:07:14 (35.5 MB/s) - ‘colab_metadata_checker.py’ saved [1997/1997]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Download metadata checker\n",
        "!wget -nc https://storage.googleapis.com/tensorflow-1-public/colab_metadata_checker.py"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "id": "e90ed34a",
      "metadata": {
        "id": "e90ed34a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "0f9a88d5-b23e-4833-c88e-cb737cec7e68"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_48c4a82e-bed4-4624-af4b-1ca43db676cf\", \"C2W1_Assignment_fixed.ipynb\", 88995)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "**IMPORTANT: Missing grader metadata detected! It has now been added and saved to `C2W1_Assignment_fixed.ipynb`. \n",
            "The notebook is being downloaded. Please submit C2W1_Assignment_fixed.ipynb to the grader.\n"
          ]
        }
      ],
      "source": [
        "import colab_metadata_checker\n",
        "\n",
        "# Please see the output of this cell to see which file you need to submit to the grader\n",
        "colab_metadata_checker.run('C2W1_Assignment_fixed.ipynb')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "24c4d4df",
      "metadata": {
        "id": "24c4d4df"
      },
      "source": [
        "**Please disregard the following note if the notebook metadata is detected**\n",
        "\n",
        "_Note: Just in case the download fails for the second point above, you can also do these steps:_\n",
        "* _Click the Folder icon on the left side of this screen to open the File Manager._\n",
        "* _Click the Folder Refresh icon in the File Manager to see the latest files in the workspace. You should see a file ending with a `_fixed.ipynb`._\n",
        "* _Right-click on that file to save locally and submit it to the grader._"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e8787d3a",
      "metadata": {
        "id": "e8787d3a"
      },
      "source": [
        "**Congratulations on finishing this week's assignment!**\n",
        "\n",
        "You have successfully implemented a convolutional neural network that classifies images of cats and dogs, along with the helper functions needed to pre-process the images!\n",
        "\n",
        "**Keep it up!**"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "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.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}