transfer_learning_bruno_borges.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOxnSwt2e19tE+oRsACtSxr",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nunonaweb/mlops/blob/main/transfer_learning_bruno_borges.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "7mSxo6oJ1K7i"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "https://colab.research.google.com/github/kylemath/ml4a-guides/blob/master/notebooks/transfer-learning.ipynb#scrollTo=5nAUr-ooYoZ4"
      ],
      "metadata": {
        "id": "jQ5oLUMu1J_i"
      }
    },
    {
      "cell_type": "code",
      "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 \"https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip\" -O \"/tmp/kagglecatsanddogs_5340.zip\"\n",
        "local_zip = '/tmp/kagglecatsanddogs_5340.zip'\n",
        "zip_ref   = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp')\n",
        "zip_ref.close()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oQCIrJUm1W6X",
        "outputId": "16139987-68e0-4e21-cad3-1e61199db43b"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-12-03 00:22:46--  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.63.210.18, 2600:1406:2e00:8a2::317f, 2600:1406:2e00:8ab::317f\n",
            "Connecting to download.microsoft.com (download.microsoft.com)|23.63.210.18|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 824887076 (787M) [application/octet-stream]\n",
            "Saving to: ‘/tmp/kagglecatsanddogs_5340.zip’\n",
            "\n",
            "/tmp/kagglecatsandd 100%[===================>] 786.67M  77.0MB/s    in 8.2s    \n",
            "\n",
            "2024-12-03 00:22:55 (96.0 MB/s) - ‘/tmp/kagglecatsanddogs_5340.zip’ saved [824887076/824887076]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(os.listdir('/tmp/PetImages/Cat/')))\n",
        "print(len(os.listdir('/tmp/PetImages/Dog/')))\n",
        "\n",
        "# Expected Output:\n",
        "# 12501\n",
        "# 12501"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5qJha4Jo1vMr",
        "outputId": "813f440f-7beb-4606-c02b-224e6fb5f244"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12501\n",
            "12501\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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"
      ],
      "metadata": {
        "id": "2d6cmG2J3ttx"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "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",
        "    os.makedirs(TRAINING, exist_ok=True)\n",
        "    os.makedirs(TESTING, exist_ok=True)\n",
        "\n",
        "    for filename in testing_set:\n",
        "        this_file = SOURCE + filename\n",
        "        destination = TESTING + filename\n",
        "        copyfile(this_file, destination)\n",
        "\n",
        "\n",
        "CAT_SOURCE_DIR = \"/tmp/PetImages/Cat/\"\n",
        "TRAINING_CATS_DIR = \"/tmp/cats-v-dogs/training/cats/\"\n",
        "TESTING_CATS_DIR = \"/tmp/cats-v-dogs/testing/cats/\"\n",
        "DOG_SOURCE_DIR = \"/tmp/PetImages/Dog/\"\n",
        "TRAINING_DOGS_DIR = \"/tmp/cats-v-dogs/training/dogs/\"\n",
        "TESTING_DOGS_DIR = \"/tmp/cats-v-dogs/testing/dogs/\"\n",
        "\n",
        "split_size = .9\n",
        "split_data(CAT_SOURCE_DIR, TRAINING_CATS_DIR, TESTING_CATS_DIR, split_size)\n",
        "split_data(DOG_SOURCE_DIR, TRAINING_DOGS_DIR, TESTING_DOGS_DIR, split_size)\n",
        "\n",
        "# Expected output\n",
        "# 666.jpg is zero length, so ignoring\n",
        "# 11702.jpg is zero length, so ignoring"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BRugLXdj1zX2",
        "outputId": "dd1a05c7-8e6b-4d36-a8dc-bd2a305a837d"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "666.jpg is zero length, so ignoring.\n",
            "11702.jpg is zero length, so ignoring.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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\n",
        "# Apresentou\n",
        "# 12381\n",
        "# 12382\n",
        "# 2381\n",
        "# 2382"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PxDmaOJn4FH5",
        "outputId": "56a26437-5e7c-4622-c241-e5401404dd5b"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12381\n",
            "12382\n",
            "2381\n",
            "2382\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = tf.keras.models.Sequential([\n",
        "    tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(150, 150, 3)),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Conv2D(32, (3, 3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "#model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['acc'])\n",
        "model.compile(optimizer=RMSprop(learning_rate=0.001), loss='binary_crossentropy', metrics=['acc'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LWqrSg154IMW",
        "outputId": "26ade79b-1a8f-4abf-debd-96a41894ec78"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pWodcIC8456B",
        "outputId": "b3d7e024-c2c2-40fb-c164-be1bea8cbff3"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 24761 images belonging to 2 classes.\n",
            "Found 4763 images belonging to 2 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Note that this may take some time.\n",
        "history = model.fit(train_generator, epochs=15, steps_per_epoch=90,validation_data=validation_generator, validation_steps=6)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W0bF3cnZ49H0",
        "outputId": "4b0002c4-70bb-4f24-e1bb-9f8e4f5491a2"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:122: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
            "  self._warn_if_super_not_called()\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m83/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━\u001b[0m \u001b[1m23s\u001b[0m 3s/step - acc: 0.5400 - loss: 0.7276"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/PIL/TiffImagePlugin.py:935: UserWarning: Truncated File Read\n",
            "  warnings.warn(str(msg))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m313s\u001b[0m 3s/step - acc: 0.5423 - loss: 0.7245 - val_acc: 0.6647 - val_loss: 0.6247\n",
            "Epoch 2/15\n",
            "\u001b[1m10/90\u001b[0m \u001b[32m━━\u001b[0m\u001b[37m━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[1m4:15\u001b[0m 3s/step - acc: 0.6464 - loss: 0.6319"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/lib/python3.10/contextlib.py:153: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.\n",
            "  self.gen.throw(typ, value, traceback)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 400ms/step - acc: 0.6396 - loss: 0.6350 - val_acc: 0.6660 - val_loss: 0.6177\n",
            "Epoch 3/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m323s\u001b[0m 3s/step - acc: 0.6520 - loss: 0.6196 - val_acc: 0.7333 - val_loss: 0.5332\n",
            "Epoch 4/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 331ms/step - acc: 0.7101 - loss: 0.5557 - val_acc: 0.6996 - val_loss: 0.5482\n",
            "Epoch 5/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m325s\u001b[0m 4s/step - acc: 0.7257 - loss: 0.5436 - val_acc: 0.6607 - val_loss: 0.5952\n",
            "Epoch 6/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 417ms/step - acc: 0.7378 - loss: 0.5126 - val_acc: 0.7667 - val_loss: 0.4875\n",
            "Epoch 7/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m332s\u001b[0m 3s/step - acc: 0.7452 - loss: 0.5134 - val_acc: 0.7933 - val_loss: 0.4538\n",
            "Epoch 8/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m34s\u001b[0m 334ms/step - acc: 0.7788 - loss: 0.4634 - val_acc: 0.8289 - val_loss: 0.4161\n",
            "Epoch 9/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m361s\u001b[0m 4s/step - acc: 0.7763 - loss: 0.4752 - val_acc: 0.8087 - val_loss: 0.4116\n",
            "Epoch 10/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 381ms/step - acc: 0.7422 - loss: 0.5138 - val_acc: 0.8040 - val_loss: 0.4340\n",
            "Epoch 11/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m316s\u001b[0m 3s/step - acc: 0.7971 - loss: 0.4339 - val_acc: 0.8047 - val_loss: 0.4168\n",
            "Epoch 12/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 868ms/step - acc: 0.8049 - loss: 0.4170 - val_acc: 0.7909 - val_loss: 0.4751\n",
            "Epoch 13/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m363s\u001b[0m 4s/step - acc: 0.8037 - loss: 0.4207 - val_acc: 0.7887 - val_loss: 0.4530\n",
            "Epoch 14/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 409ms/step - acc: 0.7933 - loss: 0.4189 - val_acc: 0.8353 - val_loss: 0.3811\n",
            "Epoch 15/15\n",
            "\u001b[1m90/90\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m317s\u001b[0m 3s/step - acc: 0.8299 - loss: 0.3752 - val_acc: 0.8260 - val_loss: 0.3930\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.image  as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#-----------------------------------------------------------\n",
        "# Retrieve a list of list results on training and test data\n",
        "# sets for each training epoch\n",
        "#-----------------------------------------------------------\n",
        "acc=history.history['acc']\n",
        "val_acc=history.history['val_acc']\n",
        "loss=history.history['loss']\n",
        "val_loss=history.history['val_loss']\n",
        "\n",
        "epochs=range(len(acc)) # Get number of epochs\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation accuracy per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, acc, 'r', \"Training Accuracy\")\n",
        "plt.plot(epochs, val_acc, 'b', \"Validation Accuracy\")\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.figure()\n",
        "\n",
        "#------------------------------------------------\n",
        "# Plot training and validation loss per epoch\n",
        "#------------------------------------------------\n",
        "plt.plot(epochs, loss, 'r', \"Training Loss\")\n",
        "plt.plot(epochs, val_loss, 'b', \"Validation Loss\")\n",
        "plt.figure()\n",
        "\n",
        "\n",
        "# Desired output. Charts with training and validation metrics. No crash :)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 900
        },
        "id": "cTTuWT_cFcSw",
        "outputId": "39608ce2-7150-4f72-fec7-31256bfb453e"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Here's a codeblock just for fun. You should be able to upload an image here\n",
        "# and have it classified without crashing\n",
        "import numpy as np\n",
        "from google.colab import files\n",
        "from keras.preprocessing import image\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        "\n",
        "  # predicting images\n",
        "  path = '/content/' + fn\n",
        "  img = image.load_img(path, target_size=(150, 150))\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "\n",
        "  images = np.vstack([x])\n",
        "  classes = model.predict(images, batch_size=10)\n",
        "  print(classes[0])\n",
        "  if classes[0]>0.5:\n",
        "    print(fn + \" is a dog\")\n",
        "  else:\n",
        "    print(fn + \" is a cat\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 125
        },
        "id": "EpqbsdL0FqWj",
        "outputId": "cdfee0d8-73ac-4669-a808-fc7e39a44e06"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-36008302-2d03-4def-8fd5-7dedf4769458\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-36008302-2d03-4def-8fd5-7dedf4769458\">\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>// Copyright 2017 Google LLC\n",
              "//\n",
              "// 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",
              "//      http://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.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving bab12f2493cf3295_org.jpg to bab12f2493cf3295_org.jpg\n",
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step\n",
            "[1.]\n",
            "bab12f2493cf3295_org.jpg is a dog\n"
          ]
        }
      ]
    }
  ]
}