Cats&Dogs Classification .ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Cats&Dogs.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Kushagratandon12/Introduction_to_tensorflow/blob/master/Cats%26Dogs%20Classification%20.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zX4Kg8DUTKWO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dn-6c02VmqiN",
        "colab": {}
      },
      "source": [
        "# In this exercise you will train a CNN on the FULL Cats-v-dogs dataset\n",
        "# This will require you doing a lot of data preprocessing because\n",
        "# the dataset isn't split into training and validation for you\n",
        "# This code block has all the required inputs\n",
        "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": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3sd9dQWa23aj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 217
        },
        "outputId": "ec8526c3-7889-4365-c6c8-8de451185ae4"
      },
      "source": [
        "# This code block downloads the full Cats-v-Dogs dataset and stores it as \n",
        "# cats-and-dogs.zip. It then unzips it to /tmp\n",
        "# which will create a tmp/PetImages directory containing subdirectories\n",
        "# called 'Cat' and 'Dog' (that's how the original researchers structured it)\n",
        "# If the URL doesn't work, \n",
        "# .   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\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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "--2020-06-26 17:32:21--  https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip\n",
            "Resolving download.microsoft.com (download.microsoft.com)... 104.81.140.145, 2a02:26f0:12f:281::e59, 2a02:26f0:12f:2a1::e59\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|104.81.140.145|: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   100MB/s    in 7.5s    \n",
            "\n",
            "2020-06-26 17:32:29 (104 MB/s) - ‘/tmp/cats-and-dogs.zip’ saved [824894548/824894548]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "gi3yD62a6X3S",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "0bcae377-68ef-4c4d-f12a-653db7f1d541"
      },
      "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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12501\n",
            "12501\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "F-QkLjxpmyK2",
        "colab": {}
      },
      "source": [
        "# Use os.mkdir to create your directories\n",
        "# You will need a directory for cats-v-dogs, and subdirectories for training\n",
        "# and testing. These in turn will need subdirectories for 'cats' and 'dogs'\n",
        "try:\n",
        "    #YOUR CODE GOES HERE\n",
        "    os.mkdir('/tmp/cats-v-dogs')\n",
        "    os.mkdir('/tmp/cats-v-dogs/training')\n",
        "    os.mkdir('/tmp/cats-v-dogs/training/cats')\n",
        "    os.mkdir('/tmp/cats-v-dogs/training/dogs')\n",
        "    os.mkdir('/tmp/cats-v-dogs/testing')\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": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "zvSODo0f9LaU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "f47a1ea0-58fc-4246-ee47-61bd79e279d3"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "# Write a python function called split_data which takes\n",
        "# a SOURCE directory containing the files\n",
        "# a TRAINING directory that a portion of the files will be copied to\n",
        "# a TESTING directory that a portion of the files will be copie to\n",
        "# a SPLIT SIZE to determine the portion\n",
        "# The files should also be randomized, so that the training set is a random\n",
        "# X% of the files, and the test set is the remaining files\n",
        "# SO, for example, if SOURCE is PetImages/Cat, and SPLIT SIZE is .9\n",
        "# Then 90% of the images in PetImages/Cat will be copied to the TRAINING dir\n",
        "# and 10% of the images will be copied to the TESTING dir\n",
        "# Also -- All images should be checked, and if they have a zero file length,\n",
        "# they will not be copied over\n",
        "#\n",
        "# os.listdir(DIRECTORY) gives you a listing of the contents of that directory\n",
        "# os.path.getsize(PATH) gives you the size of the file\n",
        "# copyfile(source, destination) copies a file from source to destination\n",
        "# random.sample(list, len(list)) shuffles a list\n",
        "def split_data(SOURCE, TRAINING, TESTING, SPLIT_SIZE):\n",
        "    all_files = []\n",
        "    \n",
        "    for file_name in os.listdir(SOURCE):\n",
        "        file_path = SOURCE + file_name\n",
        "\n",
        "        if os.path.getsize(file_path):\n",
        "            all_files.append(file_name)\n",
        "        else:\n",
        "            print('{} is zero length, so ignoring'.format(file_name))\n",
        "    \n",
        "    n_files = len(all_files)\n",
        "    split_point = int(n_files * SPLIT_SIZE)\n",
        "    \n",
        "    shuffled = random.sample(all_files, n_files)\n",
        "    \n",
        "    train_set = shuffled[:split_point]\n",
        "    test_set = shuffled[split_point:]\n",
        "    \n",
        "    for file_name in train_set:\n",
        "        copyfile(SOURCE + file_name, TRAINING + file_name)\n",
        "        \n",
        "    for file_name in test_set:\n",
        "        copyfile(SOURCE + file_name, TESTING + file_name)\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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "666.jpg is zero length, so ignoring\n",
            "11702.jpg is zero length, so ignoring\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "luthalB76ufC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 90
        },
        "outputId": "982b73a1-e967-4cdc-f351-1e49be58b1ac"
      },
      "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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "11250\n",
            "11250\n",
            "1250\n",
            "1250\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "-BQrav4anTmj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 490
        },
        "outputId": "17684315-b0f5-4de9-c9dc-c41c0fd3f531"
      },
      "source": [
        "# DEFINE A KERAS MODEL TO CLASSIFY CATS V DOGS\n",
        "# USE AT LEAST 3 CONVOLUTION LAYERS\n",
        "model = tf.keras.models.Sequential([\n",
        "#additing the 1st convolution layers\n",
        "tf.keras.layers.Conv2D(16,(3,3) ,activation='relu',input_shape=(150,150,3)), \n",
        "tf.keras.layers.MaxPool2D(2,2),   \n",
        "#addition the 2nd convolution layers\n",
        "tf.keras.layers.Conv2D(32,(3,3) , activation='relu'),\n",
        "tf.keras.layers.MaxPool2D(2,2),\n",
        "#addition the 3rd convolution layers\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",
        "# YOUR CODE HERE\n",
        "])\n",
        "\n",
        "model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "conv2d (Conv2D)              (None, 148, 148, 16)      448       \n",
            "_________________________________________________________________\n",
            "max_pooling2d (MaxPooling2D) (None, 74, 74, 16)        0         \n",
            "_________________________________________________________________\n",
            "conv2d_1 (Conv2D)            (None, 72, 72, 32)        4640      \n",
            "_________________________________________________________________\n",
            "max_pooling2d_1 (MaxPooling2 (None, 36, 36, 32)        0         \n",
            "_________________________________________________________________\n",
            "conv2d_2 (Conv2D)            (None, 34, 34, 64)        18496     \n",
            "_________________________________________________________________\n",
            "max_pooling2d_2 (MaxPooling2 (None, 17, 17, 64)        0         \n",
            "_________________________________________________________________\n",
            "flatten (Flatten)            (None, 18496)             0         \n",
            "_________________________________________________________________\n",
            "dense (Dense)                (None, 512)               9470464   \n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              (None, 1)                 513       \n",
            "=================================================================\n",
            "Total params: 9,494,561\n",
            "Trainable params: 9,494,561\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "mlNjoJ5D61N6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "a6582c35-46c7-4b00-bf9c-4cc2543ee51c"
      },
      "source": [
        "TRAINING_DIR = '/tmp/cats-v-dogs/training'\n",
        "train_datagen = ImageDataGenerator( rescale = 1.0/255. )#YOUR CODE HERE\n",
        "train_generator = train_datagen.flow_from_directory(TRAINING_DIR,\n",
        "                                                    batch_size=20,\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. )#YOUR CODE HERE\n",
        "validation_generator = train_datagen.flow_from_directory(VALIDATION_DIR,\n",
        "                                                    batch_size=20,\n",
        "                                                    class_mode='binary',\n",
        "                                                    target_size=(150, 150))\n",
        "# Expected Output:\n",
        "# Found 22498 images belonging to 2 classes.\n",
        "# Found 2500 images belonging to 2 classes."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found 22498 images belonging to 2 classes.\n",
            "Found 2500 images belonging to 2 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zuwCE3AmJzXt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6bf84e08-24cc-42dc-aba3-d2e6b9e79022"
      },
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "print('warnings ignored')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "warnings ignored\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "KyS4n53w7DxC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 563
        },
        "outputId": "b49b0245-5efd-4d02-b2f2-08728e1a8088"
      },
      "source": [
        "history = model.fit(train_generator,\n",
        "                              epochs=15,\n",
        "                              verbose=1,\n",
        "                              validation_data=validation_generator)\n",
        "\n",
        "# The expectation here is that the model will train, and that accuracy will be > 95% on both training and validation\n",
        "# i.e. acc:A1 and val_acc:A2 will be visible, and both A1 and A2 will be > .9"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "1125/1125 [==============================] - 78s 69ms/step - loss: 0.2953 - accuracy: 0.8805 - val_loss: 0.4094 - val_accuracy: 0.8308\n",
            "Epoch 2/15\n",
            "1125/1125 [==============================] - 76s 67ms/step - loss: 0.2726 - accuracy: 0.8946 - val_loss: 0.4239 - val_accuracy: 0.8276\n",
            "Epoch 3/15\n",
            "1125/1125 [==============================] - 75s 67ms/step - loss: 0.2458 - accuracy: 0.9048 - val_loss: 0.4975 - val_accuracy: 0.8444\n",
            "Epoch 4/15\n",
            "1125/1125 [==============================] - 75s 66ms/step - loss: 0.2298 - accuracy: 0.9126 - val_loss: 0.4585 - val_accuracy: 0.8340\n",
            "Epoch 5/15\n",
            "1125/1125 [==============================] - 75s 67ms/step - loss: 0.2183 - accuracy: 0.9197 - val_loss: 0.5193 - val_accuracy: 0.8524\n",
            "Epoch 6/15\n",
            "1125/1125 [==============================] - 74s 66ms/step - loss: 0.2139 - accuracy: 0.9228 - val_loss: 0.5966 - val_accuracy: 0.7976\n",
            "Epoch 7/15\n",
            "1125/1125 [==============================] - 74s 66ms/step - loss: 0.2060 - accuracy: 0.9277 - val_loss: 0.6170 - val_accuracy: 0.7620\n",
            "Epoch 8/15\n",
            "1125/1125 [==============================] - 74s 66ms/step - loss: 0.2183 - accuracy: 0.9262 - val_loss: 0.4891 - val_accuracy: 0.8016\n",
            "Epoch 9/15\n",
            "1125/1125 [==============================] - 74s 65ms/step - loss: 0.2331 - accuracy: 0.9205 - val_loss: 0.6185 - val_accuracy: 0.8392\n",
            "Epoch 10/15\n",
            "1125/1125 [==============================] - 73s 65ms/step - loss: 0.2527 - accuracy: 0.9172 - val_loss: 0.6246 - val_accuracy: 0.8200\n",
            "Epoch 11/15\n",
            "1125/1125 [==============================] - 74s 66ms/step - loss: 0.2475 - accuracy: 0.9182 - val_loss: 0.9087 - val_accuracy: 0.8404\n",
            "Epoch 12/15\n",
            "1125/1125 [==============================] - 73s 65ms/step - loss: 0.2631 - accuracy: 0.9153 - val_loss: 0.7331 - val_accuracy: 0.8232\n",
            "Epoch 13/15\n",
            "1125/1125 [==============================] - 73s 65ms/step - loss: 0.2643 - accuracy: 0.9159 - val_loss: 0.6042 - val_accuracy: 0.7668\n",
            "Epoch 14/15\n",
            "1125/1125 [==============================] - 73s 65ms/step - loss: 0.2775 - accuracy: 0.9155 - val_loss: 0.6300 - val_accuracy: 0.8164\n",
            "Epoch 15/15\n",
            "1125/1125 [==============================] - 73s 65ms/step - loss: 0.2830 - accuracy: 0.9085 - val_loss: 0.8355 - val_accuracy: 0.7764\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 563
        },
        "outputId": "064718c0-767f-49c1-bebf-8df43fd96b1d"
      },
      "source": [
        "# PLOT LOSS AND ACCURACY\n",
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.image  as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#-----------------------------------------------------------\n",
        "# Retrieve a list of list results on training and test data\n",
        "# sets for each training epoch\n",
        "#-----------------------------------------------------------\n",
        "acc=history.history['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.figure()\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation loss per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, loss, 'r', \"Training Loss\")\n",
        "plt.plot(epochs, val_loss, 'b', \"Validation Loss\")\n",
        "\n",
        "\n",
        "plt.title('Training and validation loss')\n",
        "\n",
        "# Desired output. Charts with training and validation metrics. No crash :)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Training and validation loss')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LmUWCuJMet7A",
        "colab_type": "code",
        "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": 612
        },
        "outputId": "d212ef85-9c08-44e2-bc7f-bd514bc80224"
      },
      "source": [
        "import numpy as np\n",
        "\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",
        "  \n",
        "  x=image.img_to_array(img)\n",
        "  x=np.expand_dims(x, axis=0)\n",
        "  images = np.vstack([x])\n",
        "  \n",
        "  classes = model.predict(images, batch_size=10)\n",
        "  \n",
        "  print(classes[0])\n",
        "  \n",
        "  if classes[0]>0:\n",
        "    print(fn + \" is a dog\")\n",
        "    \n",
        "  else:\n",
        "    print(fn + \" is a cat\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-9740eac3-a19b-4ed8-b038-c438de8bae0e\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-9740eac3-a19b-4ed8-b038-c438de8bae0e\">\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": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving article_stomach-issues-in-cats-why-cats-vomit-and-what-to-do_header.jpg to article_stomach-issues-in-cats-why-cats-vomit-and-what-to-do_header (1).jpg\n",
            "Saving dog-and-cat.jpeg to dog-and-cat (3).jpeg\n",
            "Saving dog-puppy-on-garden-royalty-free-image-1586966191.jpg to dog-puppy-on-garden-royalty-free-image-1586966191 (3).jpg\n",
            "Saving dogs_1280p_0.jpg to dogs_1280p_0 (3).jpg\n",
            "Saving file-20200513-82353-g2zyb8.jpg to file-20200513-82353-g2zyb8 (1).jpg\n",
            "Saving GettyImages-1199242002-1-scaled.jpg to GettyImages-1199242002-1-scaled (1).jpg\n",
            "Saving introducing-new-puppy-to-household-cat.jpg to introducing-new-puppy-to-household-cat (2).jpg\n",
            "Saving MotleyFool-TMOT-816b1ceb-0ece06e3.jpg to MotleyFool-TMOT-816b1ceb-0ece06e3 (2).jpg\n",
            "[1.]\n",
            "article_stomach-issues-in-cats-why-cats-vomit-and-what-to-do_header.jpg is a dog\n",
            "[0.]\n",
            "dog-and-cat.jpeg is a cat\n",
            "[1.]\n",
            "dog-puppy-on-garden-royalty-free-image-1586966191.jpg is a dog\n",
            "[1.]\n",
            "dogs_1280p_0.jpg is a dog\n",
            "[0.]\n",
            "file-20200513-82353-g2zyb8.jpg is a cat\n",
            "[0.]\n",
            "GettyImages-1199242002-1-scaled.jpg is a cat\n",
            "[0.]\n",
            "introducing-new-puppy-to-household-cat.jpg is a cat\n",
            "[0.]\n",
            "MotleyFool-TMOT-816b1ceb-0ece06e3.jpg is a cat\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0fGA-Mye06Ag",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}