Copy_of_CASA0018_2_3_Cats_v_Dogs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of CASA0018_2_3-Cats-v-Dogs.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "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/darennie/casa0018/blob/main/Copy_of_CASA0018_2_3_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": "f9c8e15f-50bd-4506-fcb5-cb321f4b7898"
      },
      "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",
          "text": [
            "--2021-01-19 11:25:24--  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.196.32.25, 2600:1408:2000:695::e59, 2600:1408:2000:683::e59\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|23.196.32.25|: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  70.7MB/s    in 14s     \n",
            "\n",
            "2021-01-19 11:25:38 (57.0 MB/s) - ‘/tmp/cats-and-dogs.zip’ saved [824894548/824894548]\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DM851ZmN28J3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1262bc99-08e3-4f0d-c88a-f0cee1024153"
      },
      "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",
          "text": [
            "12501\n",
            "12501\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "1006eb56-d2af-4148-dcad-e6d11c671d29"
      },
      "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 = .8\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",
          "text": [
            "666.jpg is zero length, so ignoring.\n",
            "11702.jpg is zero length, so ignoring.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hwHXFhVG3786",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fa4ceb3-0595-42a3-8146-6a6db3def5ad"
      },
      "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",
          "text": [
            "10000\n",
            "10000\n",
            "2500\n",
            "2500\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-BQrav4anTmj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8a6071a7-7921-4f14-b74d-d27eef250806"
      },
      "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.0001), loss='binary_crossentropy', metrics=['acc'])\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": {
        "id": "fQrZfVgz4j2g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "995d6c51-4acf-474c-9efd-aaffa3d0c310"
      },
      "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": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found 24809 images belonging to 2 classes.\n",
            "Found 12235 images belonging to 2 classes.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5qE1G6JB4fMn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3c8eac00-5727-456b-f07f-1572d53c0e01"
      },
      "source": [
        "# Note that this may take some time.\n",
        "history = model.fit(train_generator, epochs=15, steps_per_epoch=80,\n",
        "                    validation_data=validation_generator, validation_steps=6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "80/80 [==============================] - 66s 773ms/step - loss: 0.7442 - acc: 0.5293 - val_loss: 0.6492 - val_acc: 0.5980\n",
            "Epoch 2/15\n",
            "80/80 [==============================] - 60s 755ms/step - loss: 0.6427 - acc: 0.6166 - val_loss: 0.5786 - val_acc: 0.7013\n",
            "Epoch 3/15\n",
            "33/80 [===========>..................] - ETA: 32s - loss: 0.6071 - acc: 0.6629"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/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.6/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.6/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.6/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.6/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.6/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.6/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.6/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"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "80/80 [==============================] - 61s 760ms/step - loss: 0.5979 - acc: 0.6738 - val_loss: 0.5505 - val_acc: 0.7213\n",
            "Epoch 4/15\n",
            "80/80 [==============================] - 59s 742ms/step - loss: 0.5552 - acc: 0.7167 - val_loss: 0.5453 - val_acc: 0.7300\n",
            "Epoch 5/15\n",
            "80/80 [==============================] - 60s 750ms/step - loss: 0.5439 - acc: 0.7265 - val_loss: 0.5141 - val_acc: 0.7527\n",
            "Epoch 6/15\n",
            "80/80 [==============================] - 61s 757ms/step - loss: 0.5238 - acc: 0.7361 - val_loss: 0.4873 - val_acc: 0.7860\n",
            "Epoch 7/15\n",
            "80/80 [==============================] - 59s 741ms/step - loss: 0.5123 - acc: 0.7480 - val_loss: 0.5222 - val_acc: 0.7487\n",
            "Epoch 8/15\n",
            "80/80 [==============================] - 59s 743ms/step - loss: 0.4913 - acc: 0.7637 - val_loss: 0.4881 - val_acc: 0.7527\n",
            "Epoch 9/15\n",
            "80/80 [==============================] - 60s 752ms/step - loss: 0.4881 - acc: 0.7632 - val_loss: 0.4787 - val_acc: 0.7833\n",
            "Epoch 10/15\n",
            "80/80 [==============================] - 60s 751ms/step - loss: 0.4709 - acc: 0.7770 - val_loss: 0.4920 - val_acc: 0.7553\n",
            "Epoch 11/15\n",
            "80/80 [==============================] - 59s 740ms/step - loss: 0.4636 - acc: 0.7801 - val_loss: 0.4533 - val_acc: 0.7760\n",
            "Epoch 12/15\n",
            "80/80 [==============================] - 61s 758ms/step - loss: 0.4499 - acc: 0.7927 - val_loss: 0.4171 - val_acc: 0.8107\n",
            "Epoch 13/15\n",
            "80/80 [==============================] - 60s 752ms/step - loss: 0.4359 - acc: 0.7983 - val_loss: 0.4080 - val_acc: 0.8267\n",
            "Epoch 14/15\n",
            "80/80 [==============================] - 60s 752ms/step - loss: 0.4258 - acc: 0.8030 - val_loss: 0.3944 - val_acc: 0.8333\n",
            "Epoch 15/15\n",
            "80/80 [==============================] - 60s 755ms/step - loss: 0.4106 - acc: 0.8145 - val_loss: 0.4379 - val_acc: 0.7860\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wPCdIZEVNufu",
        "outputId": "7d95acd5-5c34-4998-925b-9400771618d5"
      },
      "source": [
        "model.save(\"/tmp/model\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Assets written to: /tmp/model/assets\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MWZrJN4-65RC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "outputId": "a8f9456b-01a7-4f9e-c129-5edba00e84ad"
      },
      "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', label='Training Accuracy')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation Accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend(loc=0)\n",
        "plt.figure()\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation loss per epoch\n",
        "#------------------------------------------------\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(loc=0)\n",
        "plt.figure()\n",
        "\n",
        "plt.show()\n",
        "\n",
        "# Desired output. Charts with training and validation metrics. No crash :)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "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"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "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": 39
        },
        "outputId": "dfc6a0fe-c987-4808-cbaa-d8d2cd0edf38"
      },
      "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",
        "  print(classes)\n",
        "  if classes[0]>0.5:\n",
        "    print(fn + \" is a dog\")\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-618d5374-9e61-4a7f-8741-9cfec63860b6\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-618d5374-9e61-4a7f-8741-9cfec63860b6\">\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": []
          }
        }
      ]
    }
  ]
}