cat_vs_dog_classification_[simple_cnn_architecture].ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/HasibAlMuzdadid/Cat-vs-Dog-Classification/blob/main/cat_vs_dog_classification_%5Bsimple_cnn_architecture%5D.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AuW-xg_bTsaF"
      },
      "source": [
        "### **Cat vs Dog Classification [Simple CNN Architecture]** \n",
        "\n",
        "We will use the famous `Cats vs Dogs` dataset to train a model that can classify images of dogs from images of cats. \n",
        "\n"
      ],
      "id": "AuW-xg_bTsaF"
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "dn-6c02VmqiN"
      },
      "outputs": [],
      "source": [
        "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"
      ],
      "id": "dn-6c02VmqiN"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bLTQd84RUs1j"
      },
      "source": [
        "Downloading the dataset from its original source. \n",
        "The `zip` file that contains the images is unzipped under the `/tmp` directory."
      ],
      "id": "bLTQd84RUs1j"
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3sd9dQWa23aj",
        "outputId": "282a0dfc-856c-4aa7-f6dc-eb3013602a70"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-06-29 18:41:55--  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.72.44.106, 2600:1413:b000:382::e59, 2600:1413:b000:39b::e59\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|23.72.44.106|: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   257MB/s    in 3.1s    \n",
            "\n",
            "2022-06-29 18:41:58 (257 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",
        "!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()"
      ],
      "id": "3sd9dQWa23aj"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e_HsUV9WVJHL"
      },
      "source": [
        "The images are stored within the `/tmp/PetImages` directory. There is a subdirectory for each class, one for dogs and one for cats."
      ],
      "id": "e_HsUV9WVJHL"
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DM851ZmN28J3",
        "outputId": "f0d27f7f-2836-433f-da8d-a4e73f2b0cf9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 12501 images of dogs.\n",
            "There are 12501 images of cats.\n"
          ]
        }
      ],
      "source": [
        "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",
        "\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.\")"
      ],
      "id": "DM851ZmN28J3"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iFbMliudNIjW"
      },
      "source": [
        "So, we 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'. "
      ],
      "id": "iFbMliudNIjW"
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "cellView": "code",
        "id": "F-QkLjxpmyK2"
      },
      "outputs": [],
      "source": [
        "# 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",
        "\n",
        "def create_train_val_dirs(root_path):\n",
        "  \n",
        "  # os.makedirs() will create directories with intermediate subdirectories\n",
        "  # os.path.join() will append the new directories to the root_path parameter\n",
        "\n",
        "  os.makedirs(os.path.join(root_dir,\"training\"))\n",
        "  os.makedirs(os.path.join(f\"{root_dir}/training\", \"dogs\"))\n",
        "  os.makedirs(os.path.join(f\"{root_dir}/training\", \"cats\"))\n",
        "  os.makedirs(os.path.join(root_dir,\"validation\"))\n",
        "  os.makedirs(os.path.join(f\"{root_dir}/validation\", \"dogs\"))\n",
        "  os.makedirs(os.path.join(f\"{root_dir}/validation\", \"cats\"))\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\")"
      ],
      "id": "F-QkLjxpmyK2"
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5dhtL344OK00",
        "outputId": "224eabd8-e262-4d40-ce25-40f142dcaf97"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/tmp/cats-v-dogs/validation\n",
            "/tmp/cats-v-dogs/training\n",
            "/tmp/cats-v-dogs/validation/cats\n",
            "/tmp/cats-v-dogs/validation/dogs\n",
            "/tmp/cats-v-dogs/training/cats\n",
            "/tmp/cats-v-dogs/training/dogs\n"
          ]
        }
      ],
      "source": [
        "# Testing 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))"
      ],
      "id": "5dhtL344OK00"
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "cellView": "code",
        "id": "zvSODo0f9LaU"
      },
      "outputs": [],
      "source": [
        "#  Spliting the whole data into train and test set\n",
        "def split_data(SOURCE_DIR, TRAINING_DIR, VALIDATION_DIR, SPLIT_SIZE):\n",
        "\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",
        "\n",
        "  processed_data = []\n",
        "  \n",
        "  for filename in os.listdir(SOURCE_DIR) :\n",
        "    file = SOURCE_DIR + filename\n",
        "    if os.path.getsize(file) > 0 :\n",
        "      processed_data.append(filename)\n",
        "    else :\n",
        "      print(f\"{filename} is zero length, so ignoring.\")\n",
        "\n",
        "  randomized_data = random.sample(processed_data, len(processed_data))\n",
        "\n",
        "  training_length = int(len(randomized_data)*SPLIT_SIZE)\n",
        "  validation_length = int(len(randomized_data) - training_length)\n",
        "\n",
        "  training_data = randomized_data[:training_length]\n",
        "  validation_data = randomized_data[-validation_length:]\n",
        "\n",
        "\n",
        "  for filename in training_data :\n",
        "    present_file = SOURCE_DIR + filename\n",
        "    destination = TRAINING_DIR + filename\n",
        "    copyfile(present_file, destination)\n",
        "\n",
        "\n",
        "  for filename in validation_data :\n",
        "    present_file = SOURCE_DIR + filename\n",
        "    destination = VALIDATION_DIR + filename\n",
        "    copyfile(present_file, destination)\n"
      ],
      "id": "zvSODo0f9LaU"
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FlIdoUeX9S-9",
        "outputId": "6a210f74-1997-422d-ee7a-63f74c4a663f"
      },
      "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",
            "There are 11250 images of cats for training\n",
            "There are 11250 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": [
        "# Testing split_data function\n",
        "\n",
        "# Defining 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 running 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",
        "# proportion of images used for training\n",
        "split_size = .9\n",
        "\n",
        "# Messages about zero length images will 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",
        "print(f\"\\n\\nThere 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\")"
      ],
      "id": "FlIdoUeX9S-9"
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "cellView": "code",
        "id": "fQrZfVgz4j2g"
      },
      "outputs": [],
      "source": [
        "#  Creating the training and validation data generators\n",
        "def train_val_generators(TRAINING_DIR, VALIDATION_DIR):\n",
        "\n",
        "\n",
        "  # Instantiating the ImageDataGenerator class also normalization\n",
        "  train_datagen = ImageDataGenerator(rescale=1.0/255)\n",
        "\n",
        "  # Passing in the appropiate arguments to the flow_from_directory method\n",
        "  train_generator = train_datagen.flow_from_directory(directory=TRAINING_DIR,\n",
        "                                                      batch_size=100,\n",
        "                                                      class_mode=\"binary\",\n",
        "                                                      target_size=(150, 150))\n",
        "\n",
        "  \n",
        "  validation_datagen = ImageDataGenerator(rescale=1.0/255)\n",
        "\n",
        "  \n",
        "  validation_generator = validation_datagen.flow_from_directory(directory=VALIDATION_DIR,\n",
        "                                                                batch_size=100,\n",
        "                                                                class_mode=\"binary\",\n",
        "                                                                target_size=(150, 150))\n",
        "\n",
        "\n",
        "  return train_generator, validation_generator"
      ],
      "id": "fQrZfVgz4j2g"
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qM7FxrjGiobD",
        "outputId": "ef8fc542-0532-43e4-9f0b-fb1d2567da03"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 22498 images belonging to 2 classes.\n",
            "Found 2500 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "# Testing the generators\n",
        "train_generator, validation_generator = train_val_generators(TRAINING_DIR, VALIDATION_DIR)"
      ],
      "id": "qM7FxrjGiobD"
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "cellView": "code",
        "id": "oDPK8tUB_O9e"
      },
      "outputs": [],
      "source": [
        "def create_model():\n",
        "\n",
        "  model = tf.keras.models.Sequential([ \n",
        "      tf.keras.layers.Conv2D(16, (3,3), activation = \"relu\", input_shape = (150,150,3)),\n",
        "      tf.keras.layers.MaxPool2D(2,2),\n",
        "      tf.keras.layers.Conv2D(32, (3,3), activation = \"relu\"),\n",
        "      tf.keras.layers.MaxPool2D(2,2),\n",
        "      tf.keras.layers.Conv2D(64, (3,3), activation = \"relu\"),\n",
        "      tf.keras.layers.MaxPool2D(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",
        "  from tensorflow.keras.optimizers import RMSprop\n",
        "\n",
        "  model.compile(optimizer = RMSprop(learning_rate = 0.001),\n",
        "                loss = \"binary_crossentropy\",\n",
        "                metrics = ['accuracy']) \n",
        "    \n",
        "\n",
        "  return model"
      ],
      "id": "oDPK8tUB_O9e"
    },
    {
      "cell_type": "code",
      "source": [
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "\n",
        "    if(logs.get('accuracy') > 0.98):\n",
        "      print(\"\\nAccuracy is higher than 99% so canceling training!\")\n",
        "      self.model.stop_training = True\n",
        "\n",
        "callbacks = myCallback()"
      ],
      "metadata": {
        "id": "UNKbTIGN3KsV"
      },
      "id": "UNKbTIGN3KsV",
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5qE1G6JB4fMn",
        "outputId": "5a9d532d-2501-4220-d945-5c1ed08ab201"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            " 74/225 [========>.....................] - ETA: 42s - loss: 0.7943 - accuracy: 0.5853"
          ]
        },
        {
          "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": [
            "225/225 [==============================] - 72s 319ms/step - loss: 0.6643 - accuracy: 0.6501 - val_loss: 0.5244 - val_accuracy: 0.7424\n",
            "Epoch 2/20\n",
            "225/225 [==============================] - 71s 314ms/step - loss: 0.5103 - accuracy: 0.7496 - val_loss: 0.4683 - val_accuracy: 0.7804\n",
            "Epoch 3/20\n",
            "225/225 [==============================] - 71s 317ms/step - loss: 0.4322 - accuracy: 0.7989 - val_loss: 0.4839 - val_accuracy: 0.7616\n",
            "Epoch 4/20\n",
            "225/225 [==============================] - 70s 312ms/step - loss: 0.3632 - accuracy: 0.8363 - val_loss: 0.4039 - val_accuracy: 0.8176\n",
            "Epoch 5/20\n",
            "225/225 [==============================] - 70s 312ms/step - loss: 0.3014 - accuracy: 0.8715 - val_loss: 0.4154 - val_accuracy: 0.8216\n",
            "Epoch 6/20\n",
            "225/225 [==============================] - 71s 316ms/step - loss: 0.2263 - accuracy: 0.9076 - val_loss: 0.4677 - val_accuracy: 0.8276\n",
            "Epoch 7/20\n",
            "225/225 [==============================] - 70s 312ms/step - loss: 0.1534 - accuracy: 0.9401 - val_loss: 0.5114 - val_accuracy: 0.8240\n",
            "Epoch 8/20\n",
            "225/225 [==============================] - 71s 314ms/step - loss: 0.1029 - accuracy: 0.9640 - val_loss: 0.6500 - val_accuracy: 0.8160\n",
            "Epoch 9/20\n",
            "225/225 [==============================] - 71s 317ms/step - loss: 0.0728 - accuracy: 0.9772 - val_loss: 0.7362 - val_accuracy: 0.8208\n",
            "Epoch 10/20\n",
            "225/225 [==============================] - ETA: 0s - loss: 0.0468 - accuracy: 0.9845\n",
            "Accuracy is higher than 99% so canceling training!\n",
            "225/225 [==============================] - 71s 316ms/step - loss: 0.0468 - accuracy: 0.9845 - val_loss: 0.9359 - val_accuracy: 0.8232\n"
          ]
        }
      ],
      "source": [
        "model = create_model()\n",
        "\n",
        "# Training the model\n",
        "history = model.fit(train_generator,\n",
        "                    epochs=20,\n",
        "                    verbose=1,\n",
        "                    validation_data=validation_generator,\n",
        "                    callbacks=[callbacks])"
      ],
      "id": "5qE1G6JB4fMn"
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "outputId": "298b5230-d6c3-4520-8f51-50e7cef665a3"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "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)) # number of epochs\n",
        "\n",
        "# Plot training and validation accuracy per epoch\n",
        "plt.plot(epochs, acc, 'r', label= \"Training Accuracy\")\n",
        "plt.plot(epochs, val_acc, 'b', label= \"Validation Accuracy\")\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "print(\"\")\n",
        "\n",
        "\n",
        "# Plot training and validation loss per epoch\n",
        "plt.plot(epochs, loss, 'r', label= \"Training Loss\")\n",
        "plt.plot(epochs, val_loss, 'b', label= \"Validation Loss\")\n",
        "plt.title('Training and validation loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "id": "MWZrJN4-65RC"
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NYIaqsN2pav6"
      },
      "source": [
        "The model is overfitting, which means that it is doing a great job at classifying the images in the training set but struggling with new data. \n"
      ],
      "id": "NYIaqsN2pav6"
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "cat vs dog classification [simple cnn architecture].ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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
}