Lab6_Convolutional_cats_and_dogs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lab6-Cats-v-Dogs.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/vidyesh95/tensorFlowTutorial/blob/main/Lab6-Cats-v-Dogs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7v55rWlQehzL"
      },
      "source": [
        "## Training with a Larger Dataset - Cats and Dogs\n",
        "\n",
        "In the previous lab you trained a classifier with a horses-v-humans dataset. You saw that despite getting great training results, when you tried to do classification with real images, there were many errors, due primarily to overfitting -- where the network  does very well with data that it has previously seen, but poorly with data it hasn't!\n",
        "\n",
        "In this lab you'll look at a real, and very large dataset, and see the impact this has to avoid overfitting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dn-6c02VmqiN"
      },
      "source": [
        "import os\n",
        "import zipfile\n",
        "import random\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"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3sd9dQWa23aj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fbc5f40f-7196-4c1b-8a0e-8e6ea0fc3e98"
      },
      "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 time to download\n",
        "\n",
        "!wget --no-check-certificate \\\n",
        "    \"https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.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()\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2021-10-06 16:36:03--  https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip\n",
            "Resolving download.microsoft.com (download.microsoft.com)... 23.32.132.110, 2600:1407:3c00:108c::e59, 2600:1407:3c00:10a2::e59\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|23.32.132.110|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 824894548 (787M) [application/octet-stream]\n",
            "Saving to: ‘/tmp/cats-and-dogs.zip’\n",
            "\n",
            "/tmp/cats-and-dogs. 100%[===================>] 786.68M  88.0MB/s    in 11s     \n",
            "\n",
            "2021-10-06 16:36:15 (71.0 MB/s) - ‘/tmp/cats-and-dogs.zip’ saved [824894548/824894548]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DM851ZmN28J3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e8a921b-bf6c-4d3f-88bb-7ad8385b1a53"
      },
      "source": [
        "print(len(os.listdir('/tmp/PetImages/Cat/')))\n",
        "print(len(os.listdir('/tmp/PetImages/Dog/')))\n",
        "\n",
        "# Expected Output:\n",
        "# 12501\n",
        "# 12501"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12501\n",
            "12501\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-QkLjxpmyK2"
      },
      "source": [
        "try:\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"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zvSODo0f9LaU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "86809717-ff78-4793-dca3-ae6892d2c140"
      },
      "source": [
        "def split_data(SOURCE, TRAINING, TESTING, SPLIT_SIZE):\n",
        "    files = []\n",
        "    for filename in os.listdir(SOURCE):\n",
        "        file = SOURCE + filename\n",
        "        if os.path.getsize(file) > 0:\n",
        "            files.append(filename)\n",
        "        else:\n",
        "            print(filename + \" is zero length, so ignoring.\")\n",
        "\n",
        "    training_length = int(len(files) * SPLIT_SIZE)\n",
        "    testing_length = int(len(files) - training_length)\n",
        "    shuffled_set = random.sample(files, len(files))\n",
        "    training_set = shuffled_set[0:training_length]\n",
        "    testing_set = shuffled_set[-testing_length:]\n",
        "\n",
        "    for filename in training_set:\n",
        "        this_file = SOURCE + filename\n",
        "        destination = TRAINING + filename\n",
        "        copyfile(this_file, destination)\n",
        "\n",
        "    for filename in testing_set:\n",
        "        this_file = SOURCE + filename\n",
        "        destination = TESTING + filename\n",
        "        copyfile(this_file, destination)\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)\n",
        "\n",
        "# Expected output\n",
        "# 666.jpg is zero length, so ignoring\n",
        "# 11702.jpg is zero length, so ignoring"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "666.jpg is zero length, so ignoring.\n",
            "11702.jpg is zero length, so ignoring.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hwHXFhVG3786",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "679cde37-b1e2-4dca-c056-3e6ffdc3a26e"
      },
      "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",
        "# 11250\n",
        "# 11250\n",
        "# 1250\n",
        "# 1250"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11250\n",
            "11250\n",
            "1250\n",
            "1250\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-BQrav4anTmj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab60aee5-3aeb-4e9b-d32f-e4958d1b2a5b"
      },
      "source": [
        "model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(150, 150, 3)),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['acc'])\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  \"The `lr` argument is deprecated, use `learning_rate` instead.\")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fQrZfVgz4j2g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "faedb048-b5a7-4f32-8132-e7b8c72981b6"
      },
      "source": [
        "\n",
        "TRAINING_DIR = \"/tmp/cats-v-dogs/training/\"\n",
        "train_datagen = ImageDataGenerator(rescale=1.0/255.)\n",
        "train_generator = train_datagen.flow_from_directory(TRAINING_DIR,\n",
        "                                                    batch_size=250,\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",
        "validation_generator = validation_datagen.flow_from_directory(VALIDATION_DIR,\n",
        "                                                              batch_size=250,\n",
        "                                                              class_mode='binary',\n",
        "                                                              target_size=(150, 150))\n",
        "\n",
        "# Expected Output:\n",
        "# Found 22498 images belonging to 2 classes.\n",
        "# Found 2500 images belonging to 2 classes."
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 22498 images belonging to 2 classes.\n",
            "Found 2500 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5qE1G6JB4fMn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2161bcc5-063f-4800-99d2-55590313e5c0"
      },
      "source": [
        "# Note that this may take some time.\n",
        "history = model.fit(train_generator, epochs=15, steps_per_epoch=90,\n",
        "                    validation_data=validation_generator, validation_steps=6)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "49/90 [===============>..............] - ETA: 36s - loss: 0.8829 - acc: 0.5559"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 32 bytes but only got 0. Skipping tag 270\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 5 bytes but only got 0. Skipping tag 271\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 272\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 282\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 283\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 20 bytes but only got 0. Skipping tag 306\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:770: UserWarning: Possibly corrupt EXIF data.  Expecting to read 48 bytes but only got 0. Skipping tag 532\n",
            "  \" Skipping tag %s\" % (size, len(data), tag)\n",
            "/usr/local/lib/python3.7/dist-packages/PIL/TiffImagePlugin.py:788: UserWarning: Corrupt EXIF data.  Expecting to read 2 bytes but only got 0. \n",
            "  warnings.warn(str(msg))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "90/90 [==============================] - 117s 940ms/step - loss: 0.7905 - acc: 0.5878 - val_loss: 0.6377 - val_acc: 0.6100\n",
            "Epoch 2/15\n",
            "90/90 [==============================] - 79s 882ms/step - loss: 0.6008 - acc: 0.6795 - val_loss: 0.6456 - val_acc: 0.6713\n",
            "Epoch 3/15\n",
            "90/90 [==============================] - 79s 880ms/step - loss: 0.5159 - acc: 0.7436 - val_loss: 0.4525 - val_acc: 0.7947\n",
            "Epoch 4/15\n",
            "90/90 [==============================] - 79s 876ms/step - loss: 0.4542 - acc: 0.7830 - val_loss: 0.4667 - val_acc: 0.7867\n",
            "Epoch 5/15\n",
            "90/90 [==============================] - 80s 888ms/step - loss: 0.4117 - acc: 0.8078 - val_loss: 0.4290 - val_acc: 0.8120\n",
            "Epoch 6/15\n",
            "90/90 [==============================] - 80s 889ms/step - loss: 0.3717 - acc: 0.8319 - val_loss: 0.5565 - val_acc: 0.7107\n",
            "Epoch 7/15\n",
            "90/90 [==============================] - 79s 881ms/step - loss: 0.3313 - acc: 0.8518 - val_loss: 0.4216 - val_acc: 0.8240\n",
            "Epoch 8/15\n",
            "90/90 [==============================] - 80s 884ms/step - loss: 0.2806 - acc: 0.8797 - val_loss: 0.6002 - val_acc: 0.7013\n",
            "Epoch 9/15\n",
            "90/90 [==============================] - 79s 876ms/step - loss: 0.2400 - acc: 0.8983 - val_loss: 0.4235 - val_acc: 0.8227\n",
            "Epoch 10/15\n",
            "90/90 [==============================] - 82s 906ms/step - loss: 0.1850 - acc: 0.9264 - val_loss: 0.6406 - val_acc: 0.7853\n",
            "Epoch 11/15\n",
            "90/90 [==============================] - 82s 909ms/step - loss: 0.1495 - acc: 0.9434 - val_loss: 0.5645 - val_acc: 0.8220\n",
            "Epoch 12/15\n",
            "90/90 [==============================] - 81s 901ms/step - loss: 0.1201 - acc: 0.9570 - val_loss: 0.6875 - val_acc: 0.8027\n",
            "Epoch 13/15\n",
            "90/90 [==============================] - 81s 899ms/step - loss: 0.0991 - acc: 0.9670 - val_loss: 0.5998 - val_acc: 0.8153\n",
            "Epoch 14/15\n",
            "90/90 [==============================] - 80s 882ms/step - loss: 0.0885 - acc: 0.9728 - val_loss: 0.7719 - val_acc: 0.8073\n",
            "Epoch 15/15\n",
            "90/90 [==============================] - 80s 885ms/step - loss: 0.0771 - acc: 0.9788 - val_loss: 0.8938 - val_acc: 0.8220\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "outputId": "f31b1002-d24b-4712-bd72-4f18b232fe58"
      },
      "source": [
        "%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",
        "plt.figure()\n",
        "\n",
        "\n",
        "# Desired output. Charts with training and validation metrics. No crash :)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {},
          "execution_count": 10
        },
        {
          "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",
          "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": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LqL6FYUrtXpf",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 442
        },
        "outputId": "39ece165-8eec-4b93-bd33-19c9718d2d3e"
      },
      "source": [
        "# Here's a codeblock just for fun. You should be able to upload an image here \n",
        "# and have it classified without crashing\n",
        "import numpy as np\n",
        "from google.colab import files\n",
        "from keras.preprocessing import image\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        " \n",
        "  # predicting images\n",
        "  path = '/content/' + fn\n",
        "  img = image.load_img(path, target_size=(150, 150))\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "\n",
        "  images = np.vstack([x])\n",
        "  classes = model.predict(images, batch_size=10)\n",
        "  print(classes[0])\n",
        "  if classes[0]>0.5:\n",
        "    print(fn + \" is a dog\")\n",
        "  else:\n",
        "    print(fn + \" is a cat\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f592b0a1-721b-460f-9958-f11b220b7b21\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f592b0a1-721b-460f-9958-f11b220b7b21\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving a1.jpg to a1.jpg\n",
            "Saving a2.jpg to a2.jpg\n",
            "Saving a3.jpg to a3.jpg\n",
            "Saving a4.jpg to a4.jpg\n",
            "Saving a5.jpg to a5.jpg\n",
            "Saving a6.jpg to a6.jpg\n",
            "[0.]\n",
            "a1.jpg is a cat\n",
            "[0.]\n",
            "a2.jpg is a cat\n",
            "[0.]\n",
            "a3.jpg is a cat\n",
            "[1.]\n",
            "a4.jpg is a dog\n",
            "[0.]\n",
            "a5.jpg is a cat\n",
            "[0.]\n",
            "a6.jpg is a cat\n"
          ]
        }
      ]
    }
  ]
}