Cats&Dogs Using Data Augmentation .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%20Using%20Data%20Augmentation%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": "a54ffb49-f98d-40e8-99aa-ab801b89aba7"
      },
      "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-07-01 05:45:59--  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:fe00:1b5::e59, 2a02:26f0:fe00:1bc::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   146MB/s    in 5.5s    \n",
            "\n",
            "2020-07-01 05:46:04 (142 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": "8e250145-3bca-4647-a894-abaf84827dde"
      },
      "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": "e003db32-2c7b-4ffd-a7c2-559a1dfa557f"
      },
      "source": [
        "# Write a python function called split_data which takes\n",
        "# a SOURCE directory containing the files\n",
        "# a TRAINING directory that a portion of the files will be copied to\n",
        "# a TESTING directory that a portion of the files will be copie to\n",
        "# a SPLIT SIZE to determine the portion\n",
        "# The files should also be randomized, so that the training set is a random\n",
        "# X% of the files, and the test set is the remaining files\n",
        "# SO, for example, if SOURCE is PetImages/Cat, and SPLIT SIZE is .9\n",
        "# Then 90% of the images in PetImages/Cat will be copied to the TRAINING dir\n",
        "# and 10% of the images will be copied to the TESTING dir\n",
        "# Also -- All images should be checked, and if they have a zero file length,\n",
        "# they will not be copied over\n",
        "#\n",
        "# os.listdir(DIRECTORY) gives you a listing of the contents of that directory\n",
        "# os.path.getsize(PATH) gives you the size of the file\n",
        "# copyfile(source, destination) copies a file from source to destination\n",
        "# random.sample(list, len(list)) shuffles a list\n",
        "def split_data(SOURCE, TRAINING, TESTING, SPLIT_SIZE):\n",
        "    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": "48996d0e-148e-40c0-d544-f0fcd181488e"
      },
      "source": [
        "\n",
        "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": "ea91705b-c786-40fb-d84f-23029a667ce7"
      },
      "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",
        "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": "dd7815bf-4c3f-4916-c1c6-f65dc2f2f7c3"
      },
      "source": [
        "TRAINING_DIR = '/tmp/cats-v-dogs/training'\n",
        "train_datagen = ImageDataGenerator( rescale = 1.0/255,rotation_range=40,width_shift_range=40,shear_range=0.2,zoom_range=0.2,horizontal_flip=True)#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 22499 images belonging to 2 classes.\n",
            "Found 2499 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": "0540408a-45f0-4474-cbf2-2d8390f75627"
      },
      "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": 199
        },
        "outputId": "75833042-8154-4ecd-db7b-7a92b737265a"
      },
      "source": [
        "history = model.fit(train_generator,\n",
        "                              epochs=5,\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/5\n",
            "1125/1125 [==============================] - 182s 162ms/step - loss: 0.5141 - accuracy: 0.7508 - val_loss: 0.5335 - val_accuracy: 0.7451\n",
            "Epoch 2/5\n",
            "1125/1125 [==============================] - 180s 160ms/step - loss: 0.5018 - accuracy: 0.7637 - val_loss: 0.5019 - val_accuracy: 0.7763\n",
            "Epoch 3/5\n",
            "1125/1125 [==============================] - 181s 161ms/step - loss: 0.4946 - accuracy: 0.7655 - val_loss: 0.4822 - val_accuracy: 0.7831\n",
            "Epoch 4/5\n",
            "1125/1125 [==============================] - 178s 159ms/step - loss: 0.4891 - accuracy: 0.7761 - val_loss: 0.4678 - val_accuracy: 0.7899\n",
            "Epoch 5/5\n",
            "1125/1125 [==============================] - 179s 159ms/step - loss: 0.4824 - accuracy: 0.7745 - val_loss: 0.5381 - val_accuracy: 0.7491\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 563
        },
        "outputId": "4db75e49-2182-4d10-ba03-f61c79961faf"
      },
      "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": 13
        },
        {
          "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": 1000
        },
        "outputId": "6f27164f-b7b1-4cd1-c647-7996dd0fc198"
      },
      "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": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-a3a2f7f9-bfe9-4b62-be2d-70ce4b55a80c\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-a3a2f7f9-bfe9-4b62-be2d-70ce4b55a80c\">\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 1800x1200_cat_relaxing_on_patio_other.jpg to 1800x1200_cat_relaxing_on_patio_other.jpg\n",
            "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.jpg\n",
            "Saving bed-1284238_1280.jpg to bed-1284238_1280.jpg\n",
            "Saving dog-and-cat.jpeg to dog-and-cat.jpeg\n",
            "Saving dog-breeds-that-are-like-cats-shiba-inu-1581448671.jpg to dog-breeds-that-are-like-cats-shiba-inu-1581448671.jpg\n",
            "Saving dog-puppy-on-garden-royalty-free-image-1586966191.jpg to dog-puppy-on-garden-royalty-free-image-1586966191.jpg\n",
            "Saving dogs_1280p_0.jpg to dogs_1280p_0.jpg\n",
            "Saving file-20200513-82353-g2zyb8.jpg to file-20200513-82353-g2zyb8.jpg\n",
            "Saving GettyImages-1199242002-1-scaled.jpg to GettyImages-1199242002-1-scaled.jpg\n",
            "Saving images.jpg to images.jpg\n",
            "Saving introducing-new-puppy-to-household-cat.jpg to introducing-new-puppy-to-household-cat.jpg\n",
            "Saving MotleyFool-TMOT-816b1ceb-0ece06e3.jpg to MotleyFool-TMOT-816b1ceb-0ece06e3.jpg\n",
            "Saving rs_1024x768-140516133943-husky1.jpg to rs_1024x768-140516133943-husky1.jpg\n",
            "[1.]\n",
            "1800x1200_cat_relaxing_on_patio_other.jpg is a dog\n",
            "[1.]\n",
            "article_stomach-issues-in-cats-why-cats-vomit-and-what-to-do_header.jpg is a dog\n",
            "[1.]\n",
            "bed-1284238_1280.jpg is a dog\n",
            "[1.]\n",
            "dog-and-cat.jpeg is a dog\n",
            "[1.]\n",
            "dog-breeds-that-are-like-cats-shiba-inu-1581448671.jpg is a dog\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.9999989]\n",
            "images.jpg is a dog\n",
            "[1.]\n",
            "introducing-new-puppy-to-household-cat.jpg is a dog\n",
            "[1.]\n",
            "MotleyFool-TMOT-816b1ceb-0ece06e3.jpg is a dog\n",
            "[1.]\n",
            "rs_1024x768-140516133943-husky1.jpg is a dog\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}