klasifikasi-gunting_batu-kertas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sIM6HwN1_ggL"
      },
      "outputs": [],
      "source": [
        "#import module\n",
        "import os\n",
        "import shutil\n",
        "import zipfile\n",
        "import pathlib\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.optimizers import RMSprop\n",
        "from sklearn.model_selection import train_test_split\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "import numpy as np\n",
        "from google.colab import files\n",
        "from 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"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#melakukan download dataset\n",
        "!wget --no-check-certificate \\\n",
        "https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-R5IcVVk_0iJ",
        "outputId": "5ff5a9f2-0dc0-4819-ecff-dd5cf8dc21d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-11-05 11:46:54--  https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip\n",
            "Resolving github.com (github.com)... 140.82.113.3\n",
            "Connecting to github.com (github.com)|140.82.113.3|: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%2F20231105%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20231105T114654Z&X-Amz-Expires=300&X-Amz-Signature=8e68714dd1998c7fb971b8b57aa3e9db7126e989ca975d097f5140773572d4a4&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",
            "--2023-11-05 11:46:54--  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%2F20231105%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20231105T114654Z&X-Amz-Expires=300&X-Amz-Signature=8e68714dd1998c7fb971b8b57aa3e9db7126e989ca975d097f5140773572d4a4&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.111.133, 185.199.110.133, 185.199.108.133, ...\n",
            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.111.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  92.9MB/s    in 3.4s    \n",
            "\n",
            "2023-11-05 11:46:58 (90.8 MB/s) - ‘rockpaperscissors.zip’ saved [322873683/322873683]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#melakukan ekstrak pada data set yang berupa zip\n",
        "\n",
        "\n",
        "local_zip = \"rockpaperscissors.zip\"\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/content')\n",
        "zip_ref.close()\n"
      ],
      "metadata": {
        "id": "y8sySXYzBOlf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#melakukan pengecekan\n",
        "os.listdir('/content/rockpaperscissors')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-tOUKvODEbIB",
        "outputId": "49e14a5e-61c7-4904-f867-98e7e4fb9f1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['paper', 'scissors', 'rps-cv-images', 'README_rpc-cv-images.txt', 'rock']"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#menampilkan panjang dataset\n",
        "print(len(os.listdir('/content/rockpaperscissors/rock')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/paper')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/scissors')))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SRvv1aY_E6Yf",
        "outputId": "5b1d7161-f733-4b90-8226-950523c1af35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "726\n",
            "712\n",
            "750\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# membuat nama direktori\n",
        "base_dir = '/content/rockpaperscissors'\n",
        "train_dir = os.path.join(base_dir,'train')\n",
        "validation_dir = os.path.join(base_dir,'valid')\n"
      ],
      "metadata": {
        "id": "LYpwCl9FFPHX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# membuat direktori train jika belum ada\n",
        "if not os.path.exists(train_dir):\n",
        "    os.mkdir(train_dir)\n",
        "\n",
        "# membuat direktori validation jika belum ada\n",
        "if not os.path.exists(validation_dir):\n",
        "    os.mkdir(validation_dir)\n"
      ],
      "metadata": {
        "id": "cyJXn9_GFp2p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# menentukan path direktori\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')"
      ],
      "metadata": {
        "id": "G0D0uBxBF1KT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# membagi direktori masing-masing kelas data menjadi data train dan data validation\n",
        "train_rock_dir, valid_rock_dir = train_test_split(os.listdir(rock_dir), test_size=0.4)\n",
        "train_paper_dir, valid_paper_dir = train_test_split(os.listdir(paper_dir), test_size=0.4)\n",
        "train_scissors_dir, valid_scissors_dir = train_test_split(os.listdir(scissors_dir), test_size=0.4)"
      ],
      "metadata": {
        "id": "UNMBtdXgF517"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# menentukan path untuk direktori training dan validation masing-masing kelas data\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",
        "valid_rock = os.path.join(validation_dir,'rock')\n",
        "valid_paper = os.path.join(validation_dir,'paper')\n",
        "valid_scissors = os.path.join(validation_dir,'scissors')"
      ],
      "metadata": {
        "id": "9OLBPy-6F7fM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# membuat direktori baru di dalam direktori train\n",
        "if not os.path.exists(train_rock):\n",
        "  os.mkdir(train_rock)\n",
        "if not os.path.exists(train_paper):\n",
        "  os.mkdir(train_paper)\n",
        "if not os.path.exists(train_scissors):\n",
        "  os.mkdir(train_scissors)\n"
      ],
      "metadata": {
        "id": "xeWpEuZaGCKQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# membuat direktori baru di dalam direktori validation\n",
        "if not os.path.exists(valid_rock):\n",
        "  os.mkdir(valid_rock)\n",
        "if not os.path.exists(valid_paper):\n",
        "  os.mkdir(valid_paper)\n",
        "if not os.path.exists(valid_scissors):\n",
        "  os.mkdir(valid_scissors)"
      ],
      "metadata": {
        "id": "e8xsd02xGTHC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " # menyalin data train ke direktori baru\n",
        "for i in train_rock_dir:\n",
        "  shutil.copy(os.path.join(rock_dir, i), os.path.join(train_rock, i))\n",
        "for i in train_paper_dir:\n",
        "  shutil.copy(os.path.join(paper_dir,i), os.path.join(train_paper,i))\n",
        "for i in train_scissors_dir:\n",
        "  shutil.copy(os.path.join(scissors_dir,i), os.path.join(train_scissors,i))\n"
      ],
      "metadata": {
        "id": "XzRiezjJGaWe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# menyalin data validation ke direktori baru\n",
        "for i in valid_rock_dir:\n",
        "  shutil.copy(os.path.join(rock_dir, i), os.path.join(valid_rock,i))\n",
        "for i in valid_paper_dir:\n",
        "  shutil.copy(os.path.join(paper_dir,i), os.path.join(valid_paper,i))\n",
        "for i in valid_scissors_dir:\n",
        "  shutil.copy(os.path.join(scissors_dir,i), os.path.join(valid_scissors,i))"
      ],
      "metadata": {
        "id": "sTJd-gloGfRE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#menampilkan panjang dari data train dan data valid\n",
        "print(len(os.listdir('/content/rockpaperscissors/train/rock')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/valid/rock')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/train/scissors')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/valid/scissors')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/train/paper')))\n",
        "print(len(os.listdir('/content/rockpaperscissors/valid/paper')))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XcpD2ua8TD57",
        "outputId": "af16a09e-5b21-451a-f106-96b56e791e5f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "435\n",
            "291\n",
            "450\n",
            "300\n",
            "427\n",
            "285\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\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",
        "                    validation_split=0.4)\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        train_dir,\n",
        "        target_size=(150, 150),\n",
        "        batch_size=32,\n",
        "        class_mode='categorical')\n",
        "\n",
        "validation_generator = test_datagen.flow_from_directory(\n",
        "        validation_dir,\n",
        "        target_size=(150, 150),\n",
        "        batch_size=32,\n",
        "        class_mode='categorical')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lFocAwKkGm76",
        "outputId": "91a56e67-7f51-4734-a7cc-84e56ba89d22"
      },
      "execution_count": null,
      "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": [
        "#Menginisiasi fungsi callback\n",
        "\n",
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if (logs.get('loss') < 0.1):\n",
        "      print()\n",
        "      print(\"akurasi mencapai lebih dari 95%!\")\n",
        "      self.model.stop_training = True\n",
        "\n",
        "callbacks = myCallback()"
      ],
      "metadata": {
        "id": "mSn479URHdYO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Membuat model saraf tiruan\n",
        "\n",
        "model = tf.keras.models.Sequential([\n",
        "  tf.keras.layers.Conv2D(32, (3,3), padding='same', activation = 'relu', input_shape= (150,150,3)),\n",
        "  tf.keras.layers.MaxPooling2D(2,2),\n",
        "  tf.keras.layers.Conv2D(64,(3,3), padding='same', activation= 'relu'),\n",
        "  tf.keras.layers.MaxPooling2D(2,2),\n",
        "  tf.keras.layers.Conv2D(128,(3,3), padding='same', activation= 'relu'),\n",
        "  tf.keras.layers.MaxPooling2D(2,2),\n",
        "  tf.keras.layers.Conv2D(256,(3,3), padding='same', 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",
        "model.summary()\n",
        "\n",
        "model.compile(loss = 'categorical_crossentropy',\n",
        "              optimizer = tf.optimizers.Adam(learning_rate=0.001),\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-GR1CtC6HfgK",
        "outputId": "1cb77eea-407e-44ac-88ff-d64b5f94eae9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 150, 150, 32)      896       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 75, 75, 32)        0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 75, 75, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 37, 37, 64)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 37, 37, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 18, 18, 128)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 18, 18, 256)       295168    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPoolin  (None, 9, 9, 256)         0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 20736)             0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 20736)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               10617344  \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 3)                 1539      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 11007299 (41.99 MB)\n",
            "Trainable params: 11007299 (41.99 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Training data\n",
        "\n",
        "history = model.fit(\n",
        "    train_generator,\n",
        "    steps_per_epoch = 35,\n",
        "    epochs = 20,\n",
        "    validation_data = validation_generator,\n",
        "    validation_steps = 5,\n",
        "    verbose =2,\n",
        "    callbacks=[callbacks]\n",
        ")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f2df912OHnHE",
        "outputId": "bce08052-ca65-42e2-ad68-6aaaf328ebf6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "35/35 - 86s - loss: 1.0428 - accuracy: 0.4384 - val_loss: 0.6811 - val_accuracy: 0.7625 - 86s/epoch - 2s/step\n",
            "Epoch 2/20\n",
            "35/35 - 83s - loss: 0.4868 - accuracy: 0.8223 - val_loss: 0.2356 - val_accuracy: 0.9312 - 83s/epoch - 2s/step\n",
            "Epoch 3/20\n",
            "35/35 - 81s - loss: 0.2603 - accuracy: 0.8929 - val_loss: 0.3276 - val_accuracy: 0.8875 - 81s/epoch - 2s/step\n",
            "Epoch 4/20\n",
            "35/35 - 81s - loss: 0.1954 - accuracy: 0.9339 - val_loss: 0.2996 - val_accuracy: 0.9250 - 81s/epoch - 2s/step\n",
            "Epoch 5/20\n",
            "35/35 - 83s - loss: 0.2446 - accuracy: 0.9134 - val_loss: 0.1703 - val_accuracy: 0.9250 - 83s/epoch - 2s/step\n",
            "Epoch 6/20\n",
            "35/35 - 82s - loss: 0.1631 - accuracy: 0.9420 - val_loss: 0.1295 - val_accuracy: 0.9500 - 82s/epoch - 2s/step\n",
            "Epoch 7/20\n",
            "35/35 - 84s - loss: 0.1522 - accuracy: 0.9464 - val_loss: 0.1145 - val_accuracy: 0.9688 - 84s/epoch - 2s/step\n",
            "Epoch 8/20\n",
            "35/35 - 82s - loss: 0.1184 - accuracy: 0.9643 - val_loss: 0.1887 - val_accuracy: 0.9187 - 82s/epoch - 2s/step\n",
            "Epoch 9/20\n",
            "35/35 - 83s - loss: 0.1494 - accuracy: 0.9554 - val_loss: 0.1881 - val_accuracy: 0.9375 - 83s/epoch - 2s/step\n",
            "Epoch 10/20\n",
            "35/35 - 84s - loss: 0.1699 - accuracy: 0.9438 - val_loss: 0.0735 - val_accuracy: 0.9812 - 84s/epoch - 2s/step\n",
            "Epoch 11/20\n",
            "35/35 - 84s - loss: 0.1200 - accuracy: 0.9625 - val_loss: 0.0712 - val_accuracy: 0.9688 - 84s/epoch - 2s/step\n",
            "Epoch 12/20\n",
            "35/35 - 84s - loss: 0.1082 - accuracy: 0.9679 - val_loss: 0.2098 - val_accuracy: 0.9563 - 84s/epoch - 2s/step\n",
            "Epoch 13/20\n",
            "35/35 - 84s - loss: 0.1244 - accuracy: 0.9589 - val_loss: 0.1294 - val_accuracy: 0.9500 - 84s/epoch - 2s/step\n",
            "Epoch 14/20\n",
            "35/35 - 83s - loss: 0.1017 - accuracy: 0.9688 - val_loss: 0.1041 - val_accuracy: 0.9812 - 83s/epoch - 2s/step\n",
            "Epoch 15/20\n",
            "\n",
            "akurasi mencapai lebih dari 95%!\n",
            "35/35 - 81s - loss: 0.0695 - accuracy: 0.9741 - val_loss: 0.0310 - val_accuracy: 0.9937 - 81s/epoch - 2s/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Visualisasi hasil pada data training dan data validation\n",
        "\n",
        "%matplotlib inline\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs_range = range(20)\n",
        "\n",
        "plt.figure(figsize=(15,5))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.ylabel('Loss', fontsize=16)\n",
        "plt.plot(history.history['loss'], label='Training Loss')\n",
        "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
        "plt.legend(loc='upper right')\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.ylabel('Accuracy', fontsize=16)\n",
        "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
        "plt.legend(loc='lower right')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "rnxjDaN8IFg1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        },
        "outputId": "6ce4e079-9932-4dc5-f2ff-b64fc53bef1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#melakukan Prediksi dengan mengunggah gambar\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": "UVzsMcQ5Npqa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "outputId": "b1e1499e-d77e-475c-c4ec-8b7e30e23c3e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-5b6edf39-71cb-4a99-a20f-33642db18a63\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-5b6edf39-71cb-4a99-a20f-33642db18a63\">\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 gunting_hijau.jpg to gunting_hijau (1).jpg\n",
            "1/1 [==============================] - 0s 50ms/step\n",
            "gunting_hijau (1).jpg\n",
            "scissors\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}