CNN_CV_ML_AI_Paper_Rock_Scissor.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I_rDtn5fgSyq"
      },
      "source": [
        "# Machine Learning For Image Recognition RPS (Rock, Paper, Scissors)\n",
        "## With CNN Architecture (Computer Vision)\n",
        "Name     : Muhammad Anandha Fritama\n",
        "Email    : anandha.fritama@gmail.com"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8V9uaAoT_3v_"
      },
      "source": [
        "## Workflow For Creating Machine Learning\n",
        "\n",
        "\n",
        "1.   TensorFlow Version Check\n",
        "2.   Download & Unzip Datasets\n",
        "3.   Set-Up Directory\n",
        "4.   Pre-Processing (Image Augmentation)\n",
        "5.   Pre-Training & Validation\n",
        "6.   Creating Machine learning Architecture (CNN)\n",
        "7.   Compile & Training\n",
        "8.   Prediction\n",
        "9.   Final & Re-Test\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bI6TduHxBpYQ"
      },
      "source": [
        "### 1. TensorFlow Version Check"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gPzb4MLsgMN4",
        "outputId": "ec1f7b5a-66bc-49d8-f6c1-c69c70999e59"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.8.2\n"
          ]
        }
      ],
      "source": [
        "import tensorflow as tflow\n",
        "print(tflow.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mkXQ4y8gCKv-"
      },
      "source": [
        "### 2. Download & Un-ZIP datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "93CqivyEfmiN"
      },
      "outputs": [],
      "source": [
        "!pip install -q kaggle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jBXUV77ZfrJc",
        "outputId": "cb9cb31a-7d40-4174-cbb4-4c0ec717cbbf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "mkdir: cannot create directory ‘/root/.kaggle’: File exists\n"
          ]
        }
      ],
      "source": [
        "!mkdir ~/.kaggle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vwo01kBvfzCE"
      },
      "outputs": [],
      "source": [
        "!cp kaggle.json ~/.kaggle/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a35E2sjkf40N",
        "outputId": "75828c45-94eb-499c-8efc-3cd66964f9ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "chmod: cannot access '~./kaggle/kaggle.json': No such file or directory\n"
          ]
        }
      ],
      "source": [
        "!chmod 600 ~./kaggle/kaggle.json"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cz8uykdQg0wJ",
        "outputId": "340cd654-9bc2-4e68-b6fa-5395f4b4a3d6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /root/.kaggle/kaggle.json'\n",
            "Downloading rockpaperscissors.zip to /content\n",
            " 94% 289M/306M [00:02<00:00, 106MB/s] \n",
            "100% 306M/306M [00:02<00:00, 115MB/s]\n"
          ]
        }
      ],
      "source": [
        "!kaggle datasets download -d drgfreeman/rockpaperscissors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q13KQvHOXWcL"
      },
      "outputs": [],
      "source": [
        "import zipfile,os,shutil\n",
        "file_zip = '/content/rockpaperscissors.zip'\n",
        "file_ekstrak = zipfile.ZipFile(file_zip, 'r')\n",
        "file_ekstrak.extractall('/content/data')\n",
        "file_ekstrak.close()\n",
        "\n",
        "os.mkdir(os.path.join(\"/content/data/latih\"))\n",
        "shutil.move(\"/content/data/paper\", \"/content/data/latih\")\n",
        "shutil.move(\"/content/data/rock\", \"/content/data/latih\")\n",
        "shutil.move(\"/content/data/scissors\", \"/content/data/latih\")\n",
        "file_latih = os.path.join(\"/content/data/latih\")\n",
        "file_validasi = os.path.join(\"/content/data\", 'rps-cv-images')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0vbUhgsPdb5v"
      },
      "source": [
        "### 3. Set-Up Directory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FaBb6rccXWK1",
        "outputId": "0df88914-1944-42a3-bf12-f2ea6eab75d2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['scissors', 'rock', 'paper']"
            ]
          },
          "execution_count": 39,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "os.listdir(file_latih)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MztksOKyeY40",
        "outputId": "f2642bc0-b9f6-43b5-8c8a-d2b05c33b675"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['scissors', 'rock', 'paper', 'README_rpc-cv-images.txt']"
            ]
          },
          "execution_count": 40,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "os.listdir(file_validasi)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISc5ZZ6ndapP"
      },
      "source": [
        "### 4. Pre-Processing (Image Augmentation)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5qZ6DOkteZuH"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        " \n",
        "data_train = ImageDataGenerator(rescale=1./255,\n",
        "                    horizontal_flip=True,\n",
        "                    vertical_flip=True,\n",
        "                    shear_range = 0.2,\n",
        "                    zoom_range = 0.2,\n",
        "                    validation_split=0.4,\n",
        "                    fill_mode = \"reflect\")\n",
        " \n",
        "data_validation = ImageDataGenerator(rescale=1./255,\n",
        "                    horizontal_flip=True,\n",
        "                    vertical_flip=True,\n",
        "                    shear_range = 0.2,\n",
        "                    zoom_range = 0.2,\n",
        "                    validation_split=0.4,\n",
        "                    fill_mode = \"reflect\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2bmSmmQidZge"
      },
      "source": [
        "### 5. Pre-Training & Validation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_4CbusMbjvtf",
        "outputId": "82217555-b783-4d26-a417-3ab07a27c1f7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Found 1314 images belonging to 3 classes.\n",
            "Found 874 images belonging to 3 classes.\n"
          ]
        }
      ],
      "source": [
        "train_generator = data_train.flow_from_directory(\n",
        "    file_latih,\n",
        "    target_size=(150, 150),\n",
        "    batch_size=8,\n",
        "    shuffle=True,\n",
        "    interpolation='nearest',\n",
        "    class_mode='categorical',\n",
        "    subset='training')\n",
        "\n",
        "validation_generator = data_validation.flow_from_directory(\n",
        "    file_validasi,\n",
        "    target_size=(150, 150),\n",
        "    batch_size=8,\n",
        "    shuffle=True,\n",
        "    interpolation='nearest',\n",
        "    class_mode='categorical',\n",
        "    subset='validation')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tDrrbHHldQZm"
      },
      "source": [
        "### 6. Creating Machine learning Architecture (CNN)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9y1bhqzEp90N"
      },
      "outputs": [],
      "source": [
        "model = tflow.keras.models.Sequential([\n",
        "    tflow.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)),\n",
        "    tflow.keras.layers.MaxPooling2D(2, 2),\n",
        "    tflow.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tflow.keras.layers.MaxPooling2D(2,2),\n",
        "    tflow.keras.layers.Conv2D(128, (3,3), activation='relu'),\n",
        "    tflow.keras.layers.MaxPooling2D(2,2),\n",
        "    tflow.keras.layers.Conv2D(128, (3,3), activation='relu'),\n",
        "    tflow.keras.layers.MaxPooling2D(2,2),\n",
        "    tflow.keras.layers.Flatten(),\n",
        "    tflow.keras.layers.Dropout(0.4),\n",
        "    tflow.keras.layers.Dense(512, activation='relu'),\n",
        "    tflow.keras.layers.Dense(3, activation='softmax')\n",
        "])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xf9O-eT2pESl",
        "outputId": "1807e9b5-9f92-46ab-87e3-c9766f17b321"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_4 (Conv2D)           (None, 148, 148, 32)      896       \n",
            "                                                                 \n",
            " max_pooling2d_4 (MaxPooling  (None, 74, 74, 32)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_5 (Conv2D)           (None, 72, 72, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_5 (MaxPooling  (None, 36, 36, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_6 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_6 (MaxPooling  (None, 17, 17, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_7 (Conv2D)           (None, 15, 15, 128)       147584    \n",
            "                                                                 \n",
            " max_pooling2d_7 (MaxPooling  (None, 7, 7, 128)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten_1 (Flatten)         (None, 6272)              0         \n",
            "                                                                 \n",
            " dropout_1 (Dropout)         (None, 6272)              0         \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 512)               3211776   \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 3)                 1539      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3,454,147\n",
            "Trainable params: 3,454,147\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oWuk_4iRdOM3"
      },
      "source": [
        "### 7. Compile & Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z2LXqf0JUfr5"
      },
      "outputs": [],
      "source": [
        "model.compile(loss=tflow.keras.losses.CategoricalCrossentropy(),\n",
        "              optimizer=tflow.optimizers.SGD(nesterov=True),\n",
        "              metrics=['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sQ1JZDI7jaI_",
        "outputId": "f4a22b66-0296-40fd-9b6c-e61d84a9f537"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/40\n",
            "32/32 - 4s - loss: 0.3663 - accuracy: 0.8789 - val_loss: 0.2949 - val_accuracy: 0.9023 - 4s/epoch - 139ms/step\n",
            "Epoch 2/40\n",
            "32/32 - 3s - loss: 0.3393 - accuracy: 0.8711 - val_loss: 0.2441 - val_accuracy: 0.9336 - 3s/epoch - 109ms/step\n",
            "Epoch 3/40\n",
            "32/32 - 4s - loss: 0.3111 - accuracy: 0.8867 - val_loss: 0.2696 - val_accuracy: 0.9062 - 4s/epoch - 110ms/step\n",
            "Epoch 4/40\n",
            "32/32 - 3s - loss: 0.3407 - accuracy: 0.8640 - val_loss: 0.2969 - val_accuracy: 0.9102 - 3s/epoch - 108ms/step\n",
            "Epoch 5/40\n",
            "32/32 - 4s - loss: 0.2611 - accuracy: 0.9102 - val_loss: 0.3731 - val_accuracy: 0.8945 - 4s/epoch - 110ms/step\n",
            "Epoch 6/40\n",
            "32/32 - 3s - loss: 0.3103 - accuracy: 0.8867 - val_loss: 0.2255 - val_accuracy: 0.9297 - 3s/epoch - 109ms/step\n",
            "Epoch 7/40\n",
            "32/32 - 3s - loss: 0.2568 - accuracy: 0.9023 - val_loss: 0.3447 - val_accuracy: 0.8711 - 3s/epoch - 108ms/step\n",
            "Epoch 8/40\n",
            "32/32 - 3s - loss: 0.2809 - accuracy: 0.9062 - val_loss: 0.2511 - val_accuracy: 0.9102 - 3s/epoch - 109ms/step\n",
            "Epoch 9/40\n",
            "32/32 - 3s - loss: 0.3313 - accuracy: 0.9062 - val_loss: 0.2255 - val_accuracy: 0.9375 - 3s/epoch - 109ms/step\n",
            "Epoch 10/40\n",
            "32/32 - 3s - loss: 0.2552 - accuracy: 0.8984 - val_loss: 0.3736 - val_accuracy: 0.8750 - 3s/epoch - 108ms/step\n",
            "Epoch 11/40\n",
            "32/32 - 4s - loss: 0.2439 - accuracy: 0.9141 - val_loss: 0.2085 - val_accuracy: 0.9414 - 4s/epoch - 136ms/step\n",
            "Epoch 12/40\n",
            "32/32 - 3s - loss: 0.1966 - accuracy: 0.9375 - val_loss: 0.4487 - val_accuracy: 0.8398 - 3s/epoch - 108ms/step\n",
            "Epoch 13/40\n",
            "32/32 - 4s - loss: 0.2294 - accuracy: 0.9141 - val_loss: 0.2542 - val_accuracy: 0.9258 - 4s/epoch - 110ms/step\n",
            "Epoch 14/40\n",
            "32/32 - 4s - loss: 0.2638 - accuracy: 0.8867 - val_loss: 0.3373 - val_accuracy: 0.8750 - 4s/epoch - 135ms/step\n",
            "Epoch 15/40\n",
            "32/32 - 3s - loss: 0.2149 - accuracy: 0.9258 - val_loss: 0.2512 - val_accuracy: 0.9062 - 3s/epoch - 108ms/step\n",
            "Epoch 16/40\n",
            "32/32 - 3s - loss: 0.2479 - accuracy: 0.8760 - val_loss: 0.1873 - val_accuracy: 0.9375 - 3s/epoch - 106ms/step\n",
            "Epoch 17/40\n",
            "32/32 - 4s - loss: 0.2058 - accuracy: 0.9375 - val_loss: 0.1566 - val_accuracy: 0.9414 - 4s/epoch - 110ms/step\n",
            "Epoch 18/40\n",
            "32/32 - 3s - loss: 0.2145 - accuracy: 0.9336 - val_loss: 0.2076 - val_accuracy: 0.9375 - 3s/epoch - 108ms/step\n",
            "Epoch 19/40\n",
            "32/32 - 3s - loss: 0.2580 - accuracy: 0.8945 - val_loss: 0.2215 - val_accuracy: 0.9375 - 3s/epoch - 108ms/step\n",
            "Epoch 20/40\n",
            "32/32 - 3s - loss: 0.2363 - accuracy: 0.9375 - val_loss: 0.2988 - val_accuracy: 0.9102 - 3s/epoch - 108ms/step\n",
            "Epoch 21/40\n",
            "32/32 - 3s - loss: 0.2366 - accuracy: 0.9280 - val_loss: 0.1878 - val_accuracy: 0.9570 - 3s/epoch - 106ms/step\n",
            "Epoch 22/40\n",
            "32/32 - 3s - loss: 0.2932 - accuracy: 0.9023 - val_loss: 0.2039 - val_accuracy: 0.9531 - 3s/epoch - 108ms/step\n",
            "Epoch 23/40\n",
            "32/32 - 3s - loss: 0.1618 - accuracy: 0.9480 - val_loss: 0.2981 - val_accuracy: 0.8945 - 3s/epoch - 108ms/step\n",
            "Epoch 24/40\n",
            "32/32 - 3s - loss: 0.3040 - accuracy: 0.8840 - val_loss: 0.2223 - val_accuracy: 0.9336 - 3s/epoch - 106ms/step\n",
            "Epoch 25/40\n",
            "32/32 - 3s - loss: 0.2790 - accuracy: 0.8984 - val_loss: 0.2164 - val_accuracy: 0.9336 - 3s/epoch - 108ms/step\n",
            "Epoch 26/40\n",
            "32/32 - 3s - loss: 0.2393 - accuracy: 0.9280 - val_loss: 0.2485 - val_accuracy: 0.9219 - 3s/epoch - 106ms/step\n",
            "Epoch 27/40\n",
            "32/32 - 3s - loss: 0.2025 - accuracy: 0.9258 - val_loss: 0.2062 - val_accuracy: 0.9375 - 3s/epoch - 107ms/step\n",
            "Epoch 28/40\n",
            "32/32 - 3s - loss: 0.2358 - accuracy: 0.9102 - val_loss: 0.2497 - val_accuracy: 0.9258 - 3s/epoch - 107ms/step\n",
            "Epoch 29/40\n",
            "32/32 - 3s - loss: 0.2869 - accuracy: 0.8960 - val_loss: 0.1588 - val_accuracy: 0.9297 - 3s/epoch - 108ms/step\n",
            "Epoch 30/40\n",
            "32/32 - 3s - loss: 0.1952 - accuracy: 0.9258 - val_loss: 0.2764 - val_accuracy: 0.8984 - 3s/epoch - 108ms/step\n",
            "Epoch 31/40\n",
            "32/32 - 3s - loss: 0.1527 - accuracy: 0.9492 - val_loss: 0.1479 - val_accuracy: 0.9570 - 3s/epoch - 107ms/step\n",
            "Epoch 32/40\n",
            "32/32 - 3s - loss: 0.1819 - accuracy: 0.9440 - val_loss: 0.1848 - val_accuracy: 0.9453 - 3s/epoch - 106ms/step\n",
            "Epoch 33/40\n",
            "32/32 - 3s - loss: 0.2265 - accuracy: 0.9258 - val_loss: 0.2021 - val_accuracy: 0.9375 - 3s/epoch - 107ms/step\n",
            "Epoch 34/40\n",
            "32/32 - 3s - loss: 0.1173 - accuracy: 0.9648 - val_loss: 0.1589 - val_accuracy: 0.9531 - 3s/epoch - 109ms/step\n",
            "Epoch 35/40\n",
            "32/32 - 4s - loss: 0.1876 - accuracy: 0.9336 - val_loss: 0.1717 - val_accuracy: 0.9453 - 4s/epoch - 134ms/step\n",
            "Epoch 36/40\n",
            "32/32 - 3s - loss: 0.1482 - accuracy: 0.9440 - val_loss: 0.2194 - val_accuracy: 0.9414 - 3s/epoch - 109ms/step\n",
            "Epoch 37/40\n",
            "32/32 - 4s - loss: 0.1561 - accuracy: 0.9453 - val_loss: 0.2442 - val_accuracy: 0.9492 - 4s/epoch - 110ms/step\n",
            "Epoch 38/40\n",
            "32/32 - 3s - loss: 0.1493 - accuracy: 0.9453 - val_loss: 0.1543 - val_accuracy: 0.9453 - 3s/epoch - 107ms/step\n",
            "Epoch 39/40\n",
            "32/32 - 3s - loss: 0.1941 - accuracy: 0.9360 - val_loss: 0.2514 - val_accuracy: 0.9180 - 3s/epoch - 106ms/step\n",
            "Epoch 40/40\n",
            "32/32 - 3s - loss: 0.2297 - accuracy: 0.9258 - val_loss: 0.1132 - val_accuracy: 0.9688 - 3s/epoch - 107ms/step\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f3dab754e90>"
            ]
          },
          "execution_count": 48,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.fit(\n",
        "      train_generator, \n",
        "      epochs=40,\n",
        "      steps_per_epoch=32, \n",
        "      validation_data=validation_generator,\n",
        "      validation_steps=32,\n",
        "      shuffle=True,\n",
        "      verbose=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ep778mksc9-0"
      },
      "source": [
        "### 8. Prediksi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 360
        },
        "id": "_ObrP3yUW_CM",
        "outputId": "a8b8e0e5-cc90-41db-e62d-ec4a6eee3f7b"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6741cf90-69f3-4474-812a-8d884117daa9\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6741cf90-69f3-4474-812a-8d884117daa9\">\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> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving testpaper01-00.png to testpaper01-00.png\n",
            "testpaper01-00.png\n",
            "Kertas\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "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",
        "%matplotlib inline\n",
        " \n",
        "testing = files.upload()\n",
        " \n",
        "for images in testing.keys():\n",
        " \n",
        "  path = images\n",
        "  picture = image.load_img(path, target_size=(150,150))\n",
        "  imgplot = plt.imshow(picture)\n",
        "  x = image.img_to_array(picture)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        " \n",
        "  pictures = np.vstack([x])\n",
        "  class_rps = model.predict(pictures, batch_size=16)\n",
        "  output = np.argmax(class_rps)\n",
        "  \n",
        "  print(images)\n",
        "  if output==0:\n",
        "    print('Paper')\n",
        "  elif output==1:\n",
        "    print('Rock')\n",
        "  elif output==2:\n",
        "    print('Scissor')\n",
        "  else:\n",
        "    print('Not a Hand :)')"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}