Final_Submission(YB_Aditya_Tri_Agam_Purnomo).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Final Submission\n",
        "\n",
        "Proyek Akhir : Klasifikasi Gambar\n",
        "\n",
        "Nama : YB Aditya Tri Agam Purnomo \n",
        "\n",
        "Nomor Register : MLDBDT22-01216\n",
        "\n",
        "Program Fasilitasi Baparekraf Digital Talent 2022 Tahap 2."
      ],
      "metadata": {
        "id": "Gjwg3haHkD16"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "GJ6X7Phcj0Z-"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!wget --no-check-certificate \\\n",
        "  https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "33Y8evC-kIpR",
        "outputId": "8e24fb53-e61c-419e-d471-22a7c7296979"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-10-28 07:56:11--  https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip\n",
            "Resolving github.com (github.com)... 140.82.114.4\n",
            "Connecting to github.com (github.com)|140.82.114.4|:443... connected.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://objects.githubusercontent.com/github-production-release-asset-2e65be/391417272/7eb836f2-695b-4a46-9c78-b65867166957?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20221028%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20221028T075611Z&X-Amz-Expires=300&X-Amz-Signature=e4d31044716f2a81b254d9b44b09ab04e1a8dc17dce22b469ba1417a4b3ed72d&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=391417272&response-content-disposition=attachment%3B%20filename%3Drockpaperscissors.zip&response-content-type=application%2Foctet-stream [following]\n",
            "--2022-10-28 07:56:11--  https://objects.githubusercontent.com/github-production-release-asset-2e65be/391417272/7eb836f2-695b-4a46-9c78-b65867166957?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20221028%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20221028T075611Z&X-Amz-Expires=300&X-Amz-Signature=e4d31044716f2a81b254d9b44b09ab04e1a8dc17dce22b469ba1417a4b3ed72d&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=391417272&response-content-disposition=attachment%3B%20filename%3Drockpaperscissors.zip&response-content-type=application%2Foctet-stream\n",
            "Resolving objects.githubusercontent.com (objects.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 322873683 (308M) [application/octet-stream]\n",
            "Saving to: ‘rockpaperscissors.zip’\n",
            "\n",
            "rockpaperscissors.z 100%[===================>] 307.92M  56.9MB/s    in 4.7s    \n",
            "\n",
            "2022-10-28 07:56:16 (65.7 MB/s) - ‘rockpaperscissors.zip’ saved [322873683/322873683]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# melakukan ekstraksi pada file zip\n",
        "import zipfile,os\n",
        "local_zip = '/content/rockpaperscissors.zip'\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/tmp')\n",
        "zip_ref.close()"
      ],
      "metadata": {
        "id": "vrl-KcBlkMiB"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#membagi data set menjadi train_set dan validation_set\n",
        "import shutil\n",
        "base_dir = '/tmp/rockpaperscissors/rps-cv-images'\n",
        "\n",
        "train_dir = os.path.join(base_dir,'train')\n",
        "validation_dir = os.path.join(base_dir,'validation')\n",
        "\n",
        "rock_dir = os.path.join(base_dir,'rock')\n",
        "paper_dir = os.path.join(base_dir, 'paper')\n",
        "scissors_dir = os.path.join(base_dir, 'scissors')\n",
        "\n",
        "#membuat folder train_dir dan validation_dir\n",
        "os.makedirs(train_dir, exist_ok=True)\n",
        "os.makedirs(validation_dir, exist_ok=True)\n",
        "\n",
        "#setup path\n",
        "train_rock = os.path.join(train_dir, 'rock')\n",
        "train_paper = os.path.join(train_dir, 'paper')\n",
        "train_scissors = os.path.join(train_dir, 'scissors')\n",
        "val_rock = os.path.join(validation_dir, 'rock')\n",
        "val_paper = os.path.join(validation_dir, 'paper')\n",
        "val_scissors = os.path.join(validation_dir, 'scissors')\n",
        "\n",
        "#membuat folder train_dir & validation_dir untuk setiap rock, paper, scissors\n",
        "os.makedirs(train_rock, exist_ok=True)\n",
        "os.makedirs(train_paper, exist_ok=True)\n",
        "os.makedirs(train_scissors, exist_ok=True)\n",
        "os.makedirs(val_rock, exist_ok=True)\n",
        "os.makedirs(val_paper, exist_ok=True)\n",
        "os.makedirs(val_scissors, exist_ok=True)"
      ],
      "metadata": {
        "id": "BX8cPkh2kRYG"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Ukuran validation set harus 40% dari total dataset (data training memiliki 1314 sampel, dan data validasi sebanyak 874 sampel)\n",
        "from sklearn.model_selection import train_test_split\n",
        "train_rock_dir, val_rock_dir = train_test_split(os.listdir(rock_dir), test_size = 0.40)\n",
        "train_paper_dir, val_paper_dir = train_test_split(os.listdir(paper_dir), test_size = 0.40)\n",
        "train_scissors_dir, val_scissors_dir = train_test_split(os.listdir(scissors_dir), test_size = 0.40)"
      ],
      "metadata": {
        "id": "oLUnqy1dw-Um"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#membuat train_dataset\n",
        "for file in train_rock_dir:\n",
        "  shutil.copy(os.path.join(rock_dir, file), os.path.join(train_rock, file))\n",
        "for file in train_paper_dir:\n",
        "  shutil.copy(os.path.join(paper_dir,file), os.path.join(train_paper,file))\n",
        "for file in train_scissors_dir:\n",
        "  shutil.copy(os.path.join(scissors_dir,file), os.path.join(train_scissors,file))\n",
        "\n",
        "#membuat validation_dataset\n",
        "for file in val_rock_dir:\n",
        "  shutil.copy(os.path.join(rock_dir, file), os.path.join(val_rock,file))\n",
        "for file in val_paper_dir:\n",
        "  shutil.copy(os.path.join(paper_dir,file), os.path.join(val_paper,file))\n",
        "for file in val_scissors_dir:\n",
        "  shutil.copy(os.path.join(scissors_dir,file), os.path.join(val_scissors,file))"
      ],
      "metadata": {
        "id": "mvQVDYkz8FuP"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#jumlah data train_set & data validation_set\n",
        "jmlh_dts_rock = len(os.listdir(train_rock))\n",
        "jmlh_dts_paper =len(os.listdir(train_paper))\n",
        "jmlh_dts_scissors =len(os.listdir(train_scissors))\n",
        "\n",
        "jmlh_dvt_rock = len(os.listdir(val_rock))\n",
        "jmlh_dvt_paper = len(os.listdir(val_paper))\n",
        "jmlh_dvt_scissors = len(os.listdir(val_scissors))\n",
        "\n",
        "print(\"data train set untuk rock sebanyak\", jmlh_dts_rock,\" samples\")\n",
        "print(\"data train set untuk paper sebanyak\", jmlh_dts_paper,\" samples\")\n",
        "print(\"data train set untuk scissors sebanyak\", jmlh_dts_scissors,\" samples\")\n",
        "\n",
        "total_dts = jmlh_dts_rock + jmlh_dts_paper + jmlh_dts_scissors\n",
        "print(\"Total data train set \", total_dts,\" samples\")\n",
        "\n",
        "print(\"data validation set untuk rock sebanyak\", jmlh_dvt_rock,\" samples\")\n",
        "print(\"data validation set untuk paper sebanyak\", jmlh_dvt_paper,\" samples\")\n",
        "print(\"data validation set untuk scissors sebanyak\", jmlh_dvt_scissors,\" samples\")\n",
        "\n",
        "total_dvt = jmlh_dvt_rock + jmlh_dvt_paper + jmlh_dvt_scissors\n",
        "print(\"Total data validation set \", total_dvt,\" samples\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fWJhp-3j8yrt",
        "outputId": "ca4feea7-58c5-4669-f390-de4d04d989da"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "data train set untuk rock sebanyak 435  samples\n",
            "data train set untuk paper sebanyak 427  samples\n",
            "data train set untuk scissors sebanyak 450  samples\n",
            "Total data train set  1312  samples\n",
            "data validation set untuk rock sebanyak 291  samples\n",
            "data validation set untuk paper sebanyak 285  samples\n",
            "data validation set untuk scissors sebanyak 300  samples\n",
            "Total data validation set  876  samples\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Menggunakan image data generator & implementasikan Augmentasi gambar\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "train_datagen = ImageDataGenerator(\n",
        "    rescale = 1./255,\n",
        "    rotation_range = 20,\n",
        "    horizontal_flip = True,\n",
        "    shear_range = 0.2,\n",
        "    fill_mode = 'nearest',\n",
        ")\n",
        "test_datagen = ImageDataGenerator(\n",
        "    rescale = 1./255,\n",
        "    rotation_range = 20,\n",
        "    horizontal_flip = True,\n",
        "    vertical_flip = True,\n",
        "    shear_range = 0.2,\n",
        "    fill_mode = 'nearest'\n",
        ")"
      ],
      "metadata": {
        "id": "srUSjxjv9IOb"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_generator = train_datagen.flow_from_directory(\n",
        "    train_dir,\n",
        "    target_size=(150,150),\n",
        "    batch_size= 64,\n",
        "    shuffle = True,\n",
        "    class_mode='categorical'\n",
        ")\n",
        "\n",
        "validation_generator = test_datagen.flow_from_directory(\n",
        "    validation_dir,\n",
        "    target_size = (150,150),\n",
        "    batch_size = 64,\n",
        "    class_mode = 'categorical'\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4Ocp_lDKytlH",
        "outputId": "4235be92-dd2c-4196-9aed-09c4a6d8b1fc"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 1312 images belonging to 3 classes.\n",
            "Found 876 images belonging to 3 classes.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Model harus menggunakan model sequential\n",
        "#menggunakan lebih dari 1 hidden layer\n",
        "model = tf.keras.models.Sequential([\n",
        "  tf.keras.layers.Conv2D(32, (3,3), activation = 'relu', input_shape= (150,150,3)),\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.Conv2D(128,(3,3), activation= 'relu'),\n",
        "  tf.keras.layers.MaxPooling2D(2,2),\n",
        "  tf.keras.layers.Flatten(),\n",
        "  tf.keras.layers.Dropout(0.5),\n",
        "  tf.keras.layers.Dense(512, activation= 'relu'),\n",
        "  tf.keras.layers.Dense(3, activation= 'softmax')\n",
        "])\n",
        "\n",
        "#menggunakan optimizer dan loss-function yang tidak diajarkan di kelas.\n",
        "model.summary()\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer=tf.optimizers.Adam(learning_rate=0.001),\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "CxBxQ5FAGyrb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0a25b424-40aa-483f-bd8f-ead63c2096c3"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 148, 148, 32)      896       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 74, 74, 32)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 72, 72, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 36, 36, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 17, 17, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 36992)             0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 36992)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               18940416  \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 3)                 1539      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 19,035,203\n",
            "Trainable params: 19,035,203\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(\n",
        "      train_generator,\n",
        "      steps_per_epoch=20,  #Sample = Batchsize * steps\n",
        "      epochs=15,\n",
        "      validation_data=validation_generator, \n",
        "      validation_steps=13,  #Sample = Batchsize * steps\n",
        "      verbose=2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I5q-gPvyaX8n",
        "outputId": "54ac2dcd-f4f8-49e5-8f0f-dd67fee90fe8"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/15\n",
            "20/20 - 72s - loss: 1.3478 - accuracy: 0.3918 - val_loss: 1.0014 - val_accuracy: 0.4555 - 72s/epoch - 4s/step\n",
            "Epoch 2/15\n",
            "20/20 - 71s - loss: 0.8754 - accuracy: 0.5689 - val_loss: 0.7408 - val_accuracy: 0.7380 - 71s/epoch - 4s/step\n",
            "Epoch 3/15\n",
            "20/20 - 71s - loss: 0.6478 - accuracy: 0.7469 - val_loss: 0.5568 - val_accuracy: 0.8245 - 71s/epoch - 4s/step\n",
            "Epoch 4/15\n",
            "20/20 - 74s - loss: 0.4515 - accuracy: 0.8389 - val_loss: 0.4124 - val_accuracy: 0.8438 - 74s/epoch - 4s/step\n",
            "Epoch 5/15\n",
            "20/20 - 72s - loss: 0.3017 - accuracy: 0.8926 - val_loss: 0.4547 - val_accuracy: 0.8197 - 72s/epoch - 4s/step\n",
            "Epoch 6/15\n",
            "20/20 - 70s - loss: 0.2829 - accuracy: 0.8998 - val_loss: 0.2909 - val_accuracy: 0.9014 - 70s/epoch - 3s/step\n",
            "Epoch 7/15\n",
            "20/20 - 73s - loss: 0.2241 - accuracy: 0.9167 - val_loss: 0.3341 - val_accuracy: 0.8918 - 73s/epoch - 4s/step\n",
            "Epoch 8/15\n",
            "20/20 - 70s - loss: 0.1951 - accuracy: 0.9327 - val_loss: 0.2288 - val_accuracy: 0.9279 - 70s/epoch - 3s/step\n",
            "Epoch 9/15\n",
            "20/20 - 69s - loss: 0.1696 - accuracy: 0.9423 - val_loss: 0.1965 - val_accuracy: 0.9351 - 69s/epoch - 3s/step\n",
            "Epoch 10/15\n",
            "20/20 - 70s - loss: 0.1325 - accuracy: 0.9439 - val_loss: 0.2320 - val_accuracy: 0.9291 - 70s/epoch - 4s/step\n",
            "Epoch 11/15\n",
            "20/20 - 72s - loss: 0.1248 - accuracy: 0.9519 - val_loss: 0.2085 - val_accuracy: 0.9387 - 72s/epoch - 4s/step\n",
            "Epoch 12/15\n",
            "20/20 - 79s - loss: 0.1026 - accuracy: 0.9688 - val_loss: 0.2495 - val_accuracy: 0.9099 - 79s/epoch - 4s/step\n",
            "Epoch 13/15\n",
            "20/20 - 72s - loss: 0.1416 - accuracy: 0.9463 - val_loss: 0.1717 - val_accuracy: 0.9435 - 72s/epoch - 4s/step\n",
            "Epoch 14/15\n",
            "20/20 - 70s - loss: 0.1199 - accuracy: 0.9599 - val_loss: 0.1664 - val_accuracy: 0.9507 - 70s/epoch - 4s/step\n",
            "Epoch 15/15\n",
            "20/20 - 72s - loss: 0.0707 - accuracy: 0.9736 - val_loss: 0.1977 - val_accuracy: 0.9447 - 72s/epoch - 4s/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#plot grafik\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "accuracy = history.history['accuracy']\n",
        "val_accuracy = history.history['val_accuracy'] \n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "#train & validation accuracy\n",
        "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "plt.legend(loc=0)\n",
        "plt.show()\n",
        "\n",
        "#train & validation loss\n",
        "plt.plot(history.history['loss'], label='Training Loss')\n",
        "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
        "plt.title('Training and validation Loss')\n",
        "plt.legend(loc=\"upper right\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 545
        },
        "id": "l1lEYNQPeT7u",
        "outputId": "bee96f9a-9bd0-4209-93b3-0c6815f67b6f"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(train_generator.class_indices)"
      ],
      "metadata": {
        "id": "Jnexq-h2egYQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a65d424-fa6b-4667-a0ac-1464fc62ae42"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'paper': 0, 'rock': 1, 'scissors': 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Evaluasi Hasil\n",
        "import numpy as np\n",
        "from google.colab import files\n",
        "from tensorflow.keras.preprocessing import image\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "%matplotlib inline\n",
        "\n",
        "uploaded = files.upload()\n",
        "\n",
        "for fn in uploaded.keys():\n",
        "\n",
        "  path = fn \n",
        "  img = image.load_img(path, target_size =(150,150))\n",
        "  imgplot = plt.imshow(img)\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",
        "\n",
        "  print(fn)\n",
        "  if classes[0,0]!=0:\n",
        "    print('paper')\n",
        "  elif classes[0,1]!=0:\n",
        "    print('rock')\n",
        "  else:\n",
        "    print('scissors')"
      ],
      "metadata": {
        "id": "NZDLOgnNehuK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 382
        },
        "outputId": "4a9fe864-a907-4009-d94c-e5cca948e8d7"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6c39c493-31c8-403e-99d4-a0da4e92211c\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6c39c493-31c8-403e-99d4-a0da4e92211c\">\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 65PVbRzrpzfdu8nJ.png to 65PVbRzrpzfdu8nJ.png\n",
            "1/1 [==============================] - 0s 137ms/step\n",
            "65PVbRzrpzfdu8nJ.png\n",
            "scissors\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}