Batu Kertas Gunting Classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO2ifr57aP8eANdG1Bi/Lfk",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/manabil/Machine_Learning_Fundamental/blob/main/Batu%20Kertas%20Gunting%20Classifier.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "# Projek Akhir - Klasifikasi Batu Kertas Gunting\n",
        "---\n",
        "<br>\n",
        "\n",
        "> ### Identitas Diri : \n",
        " * Nama : Muhammad Ammar Nabil\n",
        " * Email Dicoding : mammarnabil1@gmail.com\n",
        "\n",
        "\n",
        "Klasifikasi batu kertas gnting merupakan model yang mengklasifikan gambar batu, kertas, atau gunting\n",
        "<center>\n",
        "\n",
        "| Parameter | Value |\n",
        "| --- | :---: |\n",
        "| Test Size | 40 % of Data  |\n",
        "| Data Train Total | 1314 |\n",
        "| Data Test Total | 874 |\n",
        "| Features Total | 3 |\n",
        "| Model Build | `Sequential` |\n",
        "| Hidden Layer Build | `Dense` |\n",
        "| Hidden Layer Total | 11 |\n",
        "| Activation Method | relu |\n",
        "| Optimizer Method | Adam |\n",
        "| Loss Method | categorical_crossentropy |\n",
        "| Epoch | EarlyStop (max 50 epoch) |\n",
        "| Dataset| [RockPaperScissor](https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip) |\n",
        "\n",
        "</center>\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "hHW1XzDPVWal"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Preparing Dataset"
      ],
      "metadata": {
        "id": "Yc_NECBgRRC8"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "A86cXPNHVBg8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "outputId": "536e6c05-2e43-47c8-f6e6-f59ee153fe46"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2022-08-29 11:07:46--  https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip\n",
            "Resolving github.com (github.com)... 140.82.113.4\n",
            "Connecting to github.com (github.com)|140.82.113.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%2F20220829%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20220829T110746Z&X-Amz-Expires=300&X-Amz-Signature=6f092d131dfdca3bd5a9e354fbe8f82156cc622c79fbbe45079a2e696c0cc285&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-08-29 11:07:46--  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%2F20220829%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20220829T110746Z&X-Amz-Expires=300&X-Amz-Signature=6f092d131dfdca3bd5a9e354fbe8f82156cc622c79fbbe45079a2e696c0cc285&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: ‘/content/rockpaperscissors.zip’\n",
            "\n",
            "/content/rockpapers 100%[===================>] 307.92M  41.3MB/s    in 5.3s    \n",
            "\n",
            "2022-08-29 11:07:52 (58.2 MB/s) - ‘/content/rockpaperscissors.zip’ saved [322873683/322873683]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!wget --no-check-certificate \\\n",
        "  https://github.com/dicodingacademy/assets/releases/download/release/rockpaperscissors.zip \\\n",
        "  -O /content/rockpaperscissors.zip"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import zipfile\n",
        "import shutil as sh\n",
        "from os import remove, listdir\n",
        "\n",
        "\n",
        "# Melakukan ekstraksi pada file zip\n",
        "local_zip = '/content/rockpaperscissors.zip'\n",
        "zip_ref = zipfile.ZipFile(local_zip, 'r')\n",
        "zip_ref.extractall('/content')\n",
        "zip_ref.close()\n",
        "\n",
        "# Menghapus File yang tidak penting\n",
        "sh.rmtree('__MACOSX')\n",
        "sh.rmtree('rockpaperscissors/rps-cv-images')\n",
        "remove('rockpaperscissors/README_rpc-cv-images.txt')"
      ],
      "metadata": {
        "id": "y5T3hC_oRigb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Install library untuk split dataset\n",
        "!pip install split-folders\n",
        "import splitfolders\n",
        "\n",
        "splitfolders.ratio(\"rockpaperscissors\", \n",
        "                   output=\"/content/dataset\", \n",
        "                   seed=42, \n",
        "                   ratio=(.6, .4), \n",
        "                   group_prefix=None, \n",
        "                   move=False \n",
        "                   )\n",
        "\n",
        "# Menambahkan base path\n",
        "train_dir = '/content/dataset/train'\n",
        "val_dir = '/content/dataset/val'\n",
        "\n",
        "# Mengecek base path\n",
        "print(f'Path folder train{listdir(train_dir)}')\n",
        "print(f'Path folder val{listdir(val_dir)}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S26aSM3fBBYd",
        "outputId": "7da43241-f57c-4f11-c84b-6e18a83ed6f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting split-folders\n",
            "  Downloading split_folders-0.5.1-py3-none-any.whl (8.4 kB)\n",
            "Installing collected packages: split-folders\n",
            "Successfully installed split-folders-0.5.1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Copying files: 2188 files [00:00, 4741.46 files/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Path folder train['paper', 'scissors', 'rock']\n",
            "Path folder val['paper', 'scissors', 'rock']\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dari file rockpaperscissors kita mendapatkan total 2188 data dan dari masing masing kelas yaitu\n",
        "* Paper : 712 data\n",
        "* Rock : 726 data\n",
        "* Scissors : 750 data"
      ],
      "metadata": {
        "id": "RqqWSJaEdnw7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ls rockpaperscissors/scissors | wc -l"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XGFG386oriDO",
        "outputId": "6861e0df-e77e-4a1c-fce7-b441b6390def"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "750\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setelah itu kita bagi data tersebut menjadi train set dan test/validation set dengan ratio **(train:test; 60%:40%)**. Sehingga akan didapatkan masing masing kelas sebagai berikut\n",
        "\n",
        "> #### **Train Data** 60%\n",
        "* Paper : 427 data\n",
        "* Rock : 435 data\n",
        "* Scissors : 450 data\n",
        "\n",
        "> #### **Test Data** 40%\n",
        "* Paper : 285 data\n",
        "* Rock : 291 data\n",
        "* Scissors : 300 data"
      ],
      "metadata": {
        "id": "KmgZ7p9HeWd-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ls dataset/val/paper | wc -l"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rjuivIGnDnmh",
        "outputId": "4fd9d3d9-89b1-492b-9c3e-d574d1b3f9d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "285\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Dataset Generator\n",
        "---\n",
        "\n",
        "<center>\n",
        "\n",
        "| Parameter | Value |\n",
        "| --- | :---: |\n",
        "| rescale | 1./255 |\n",
        "| rotation_range | 20 |\n",
        "| brightness_range | (.1, .3) |\n",
        "| horizontal_flip | True |\n",
        "| vertical_flip | True |\n",
        "| shear_range | 0.2 |\n",
        "| fill_mode | nearest |\n",
        "\n",
        "</center>"
      ],
      "metadata": {
        "id": "XqZ_5HtgAPRw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Membuat Test dan Validation Generator\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "train_datagen = ImageDataGenerator(\n",
        "                    rescale=1./255,\n",
        "                    rotation_range=20,\n",
        "                    brightness_range=(.1, .3),\n",
        "                    horizontal_flip=True,\n",
        "                    vertical_flip=True,\n",
        "                    shear_range = 0.2,\n",
        "                    fill_mode = 'nearest')\n",
        "\n",
        "validation_datagen = ImageDataGenerator(\n",
        "                    rescale=1./255)"
      ],
      "metadata": {
        "id": "jtzkn8nbSEN5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Menginisialisasi Dataset Generator\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "        train_dir,  \n",
        "        target_size=(150, 150),  \n",
        "        batch_size=4)\n",
        "\n",
        "validation_generator = validation_datagen.flow_from_directory(\n",
        "        val_dir, \n",
        "        target_size=(150, 150), \n",
        "        batch_size=4)"
      ],
      "metadata": {
        "id": "1cV7vpLoSpld",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e46a0f88-03b6-49c3-912f-e9d31857c377"
      },
      "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": "markdown",
      "source": [
        "## 2. Membuat Model"
      ],
      "metadata": {
        "id": "3FUmnS7mRapK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "# Membuat Model 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.Conv2D(512, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Conv2D(1024, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(1024, activation='relu'),\n",
        "    tf.keras.layers.Dense(3, activation='softmax')\n",
        "    ])\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S_6SukCzp_en",
        "outputId": "870a062d-35ff-4db9-d406-3348d95c972d"
      },
      "execution_count": null,
      "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",
            " conv2d_3 (Conv2D)           (None, 15, 15, 512)       590336    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 7, 7, 512)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_4 (Conv2D)           (None, 5, 5, 1024)        4719616   \n",
            "                                                                 \n",
            " max_pooling2d_4 (MaxPooling  (None, 2, 2, 1024)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 4096)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1024)              4195328   \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 3)                 3075      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 9,601,603\n",
            "Trainable params: 9,601,603\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Memberikan Callback EarlyStop pada Model\n",
        "from keras.callbacks import EarlyStopping\n",
        "\n",
        "es_callback = EarlyStopping('val_loss', patience=5, verbose=1)"
      ],
      "metadata": {
        "id": "CQAJ7Q6Ncnf1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Mengkompilasi Model\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer=tf.optimizers.Adam(),\n",
        "              metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "9cWnXEzAqCiU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Melatih Model"
      ],
      "metadata": {
        "id": "A7muwfd3T-qK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "# Melatih Model\n",
        "history = model.fit(\n",
        "      train_generator,\n",
        "      steps_per_epoch=50, \n",
        "      epochs=50,\n",
        "      validation_data=validation_generator,\n",
        "      validation_steps=5, \n",
        "      verbose=2)"
      ],
      "metadata": {
        "id": "nV19KbY_TtEX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5573911a-2f31-4864-9aca-1267f32e2ab6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n",
            "50/50 - 19s - loss: 1.1133 - accuracy: 0.3450 - val_loss: 1.0932 - val_accuracy: 0.4500 - 19s/epoch - 379ms/step\n",
            "Epoch 2/50\n",
            "50/50 - 2s - loss: 1.0996 - accuracy: 0.3250 - val_loss: 1.0974 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 3/50\n",
            "50/50 - 2s - loss: 1.0986 - accuracy: 0.3650 - val_loss: 1.0958 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 4/50\n",
            "50/50 - 2s - loss: 1.1013 - accuracy: 0.3150 - val_loss: 1.0982 - val_accuracy: 0.2500 - 2s/epoch - 37ms/step\n",
            "Epoch 5/50\n",
            "50/50 - 2s - loss: 1.0974 - accuracy: 0.3600 - val_loss: 1.0935 - val_accuracy: 0.3500 - 2s/epoch - 37ms/step\n",
            "Epoch 6/50\n",
            "50/50 - 2s - loss: 1.1012 - accuracy: 0.2900 - val_loss: 1.0690 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 7/50\n",
            "50/50 - 2s - loss: 1.1040 - accuracy: 0.3500 - val_loss: 1.1034 - val_accuracy: 0.2500 - 2s/epoch - 36ms/step\n",
            "Epoch 8/50\n",
            "50/50 - 2s - loss: 1.1004 - accuracy: 0.3350 - val_loss: 1.0971 - val_accuracy: 0.4500 - 2s/epoch - 36ms/step\n",
            "Epoch 9/50\n",
            "50/50 - 2s - loss: 1.1001 - accuracy: 0.2900 - val_loss: 1.1004 - val_accuracy: 0.2500 - 2s/epoch - 37ms/step\n",
            "Epoch 10/50\n",
            "50/50 - 2s - loss: 1.0989 - accuracy: 0.3450 - val_loss: 1.0976 - val_accuracy: 0.3500 - 2s/epoch - 36ms/step\n",
            "Epoch 11/50\n",
            "50/50 - 2s - loss: 1.0992 - accuracy: 0.3350 - val_loss: 1.0972 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 12/50\n",
            "50/50 - 2s - loss: 1.1003 - accuracy: 0.2600 - val_loss: 1.0952 - val_accuracy: 0.4500 - 2s/epoch - 37ms/step\n",
            "Epoch 13/50\n",
            "50/50 - 2s - loss: 1.0986 - accuracy: 0.3150 - val_loss: 1.0973 - val_accuracy: 0.4500 - 2s/epoch - 38ms/step\n",
            "Epoch 14/50\n",
            "50/50 - 2s - loss: 1.0985 - accuracy: 0.3500 - val_loss: 1.0989 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 15/50\n",
            "50/50 - 2s - loss: 1.0986 - accuracy: 0.3500 - val_loss: 1.0955 - val_accuracy: 0.3500 - 2s/epoch - 37ms/step\n",
            "Epoch 16/50\n",
            "50/50 - 2s - loss: 1.0977 - accuracy: 0.3750 - val_loss: 1.0977 - val_accuracy: 0.3500 - 2s/epoch - 37ms/step\n",
            "Epoch 17/50\n",
            "50/50 - 2s - loss: 1.0999 - accuracy: 0.3150 - val_loss: 1.1011 - val_accuracy: 0.3000 - 2s/epoch - 37ms/step\n",
            "Epoch 18/50\n",
            "50/50 - 2s - loss: 1.0994 - accuracy: 0.3200 - val_loss: 1.1014 - val_accuracy: 0.3000 - 2s/epoch - 36ms/step\n",
            "Epoch 19/50\n",
            "50/50 - 2s - loss: 1.0971 - accuracy: 0.3900 - val_loss: 1.0995 - val_accuracy: 0.2500 - 2s/epoch - 38ms/step\n",
            "Epoch 20/50\n",
            "50/50 - 2s - loss: 1.0987 - accuracy: 0.3400 - val_loss: 1.0962 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 21/50\n",
            "50/50 - 2s - loss: 1.0986 - accuracy: 0.3450 - val_loss: 1.0969 - val_accuracy: 0.4000 - 2s/epoch - 37ms/step\n",
            "Epoch 22/50\n",
            "50/50 - 2s - loss: 1.0999 - accuracy: 0.2900 - val_loss: 1.0974 - val_accuracy: 0.3500 - 2s/epoch - 38ms/step\n",
            "Epoch 23/50\n",
            "50/50 - 2s - loss: 1.0951 - accuracy: 0.3500 - val_loss: 0.9832 - val_accuracy: 0.4000 - 2s/epoch - 38ms/step\n",
            "Epoch 24/50\n",
            "50/50 - 2s - loss: 1.0803 - accuracy: 0.4250 - val_loss: 1.4256 - val_accuracy: 0.3500 - 2s/epoch - 48ms/step\n",
            "Epoch 25/50\n",
            "50/50 - 2s - loss: 1.0077 - accuracy: 0.5400 - val_loss: 3.6246 - val_accuracy: 0.3000 - 2s/epoch - 42ms/step\n",
            "Epoch 26/50\n",
            "50/50 - 2s - loss: 0.6301 - accuracy: 0.7650 - val_loss: 0.5347 - val_accuracy: 0.8000 - 2s/epoch - 40ms/step\n",
            "Epoch 27/50\n",
            "50/50 - 2s - loss: 0.4416 - accuracy: 0.8550 - val_loss: 2.0343 - val_accuracy: 0.7000 - 2s/epoch - 38ms/step\n",
            "Epoch 28/50\n",
            "50/50 - 2s - loss: 0.2781 - accuracy: 0.8950 - val_loss: 0.1378 - val_accuracy: 0.9500 - 2s/epoch - 37ms/step\n",
            "Epoch 29/50\n",
            "50/50 - 2s - loss: 0.2951 - accuracy: 0.9150 - val_loss: 0.4909 - val_accuracy: 0.9000 - 2s/epoch - 37ms/step\n",
            "Epoch 30/50\n",
            "50/50 - 2s - loss: 0.2533 - accuracy: 0.9200 - val_loss: 0.3786 - val_accuracy: 0.9000 - 2s/epoch - 40ms/step\n",
            "Epoch 31/50\n",
            "50/50 - 2s - loss: 0.3853 - accuracy: 0.8750 - val_loss: 0.2137 - val_accuracy: 0.9500 - 2s/epoch - 38ms/step\n",
            "Epoch 32/50\n",
            "50/50 - 2s - loss: 0.3326 - accuracy: 0.9000 - val_loss: 0.2974 - val_accuracy: 0.9000 - 2s/epoch - 37ms/step\n",
            "Epoch 33/50\n",
            "50/50 - 2s - loss: 0.3476 - accuracy: 0.8900 - val_loss: 0.1486 - val_accuracy: 0.9500 - 2s/epoch - 38ms/step\n",
            "Epoch 34/50\n",
            "50/50 - 2s - loss: 0.2936 - accuracy: 0.8850 - val_loss: 0.2781 - val_accuracy: 0.9000 - 2s/epoch - 37ms/step\n",
            "Epoch 35/50\n",
            "50/50 - 2s - loss: 0.2024 - accuracy: 0.9350 - val_loss: 0.1258 - val_accuracy: 0.9500 - 2s/epoch - 39ms/step\n",
            "Epoch 36/50\n",
            "50/50 - 2s - loss: 0.2083 - accuracy: 0.9400 - val_loss: 0.5273 - val_accuracy: 0.8500 - 2s/epoch - 38ms/step\n",
            "Epoch 37/50\n",
            "50/50 - 2s - loss: 0.2652 - accuracy: 0.9200 - val_loss: 0.0757 - val_accuracy: 1.0000 - 2s/epoch - 38ms/step\n",
            "Epoch 38/50\n",
            "50/50 - 2s - loss: 0.2587 - accuracy: 0.9100 - val_loss: 0.3789 - val_accuracy: 0.9000 - 2s/epoch - 38ms/step\n",
            "Epoch 39/50\n",
            "50/50 - 2s - loss: 0.1660 - accuracy: 0.9400 - val_loss: 0.0056 - val_accuracy: 1.0000 - 2s/epoch - 38ms/step\n",
            "Epoch 40/50\n",
            "50/50 - 3s - loss: 0.2699 - accuracy: 0.9100 - val_loss: 0.4912 - val_accuracy: 0.9500 - 3s/epoch - 56ms/step\n",
            "Epoch 41/50\n",
            "50/50 - 2s - loss: 0.2334 - accuracy: 0.9350 - val_loss: 0.1597 - val_accuracy: 0.9500 - 2s/epoch - 38ms/step\n",
            "Epoch 42/50\n",
            "50/50 - 2s - loss: 0.2299 - accuracy: 0.9300 - val_loss: 0.0141 - val_accuracy: 1.0000 - 2s/epoch - 37ms/step\n",
            "Epoch 43/50\n",
            "50/50 - 2s - loss: 0.1679 - accuracy: 0.9300 - val_loss: 0.1860 - val_accuracy: 0.9500 - 2s/epoch - 37ms/step\n",
            "Epoch 44/50\n",
            "50/50 - 2s - loss: 0.1290 - accuracy: 0.9500 - val_loss: 0.0024 - val_accuracy: 1.0000 - 2s/epoch - 37ms/step\n",
            "Epoch 45/50\n",
            "50/50 - 2s - loss: 0.2492 - accuracy: 0.9200 - val_loss: 0.0182 - val_accuracy: 1.0000 - 2s/epoch - 37ms/step\n",
            "Epoch 46/50\n",
            "50/50 - 2s - loss: 0.2146 - accuracy: 0.9000 - val_loss: 0.0025 - val_accuracy: 1.0000 - 2s/epoch - 38ms/step\n",
            "Epoch 47/50\n",
            "50/50 - 2s - loss: 0.1973 - accuracy: 0.9500 - val_loss: 0.0106 - val_accuracy: 1.0000 - 2s/epoch - 37ms/step\n",
            "Epoch 48/50\n",
            "50/50 - 2s - loss: 0.1759 - accuracy: 0.9500 - val_loss: 0.0041 - val_accuracy: 1.0000 - 2s/epoch - 38ms/step\n",
            "Epoch 49/50\n",
            "50/50 - 2s - loss: 0.2052 - accuracy: 0.9450 - val_loss: 0.0086 - val_accuracy: 1.0000 - 2s/epoch - 37ms/step\n",
            "Epoch 50/50\n",
            "50/50 - 2s - loss: 0.1089 - accuracy: 0.9600 - val_loss: 0.0351 - val_accuracy: 1.0000 - 2s/epoch - 37ms/step\n",
            "CPU times: user 2min 4s, sys: 4.09 s, total: 2min 8s\n",
            "Wall time: 2min 13s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Visualisasi Hasil Latih Model"
      ],
      "metadata": {
        "id": "qBvaqxVyUEGh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# PLOTTING\n",
        "import matplotlib.pyplot as plt\n",
        "# %matplotlib inline\n",
        "\n",
        "plt.style.use('dark_background')\n",
        "\n",
        "# PLOT AKURASI\n",
        "plt.title('Model Accuracy')\n",
        "plt.plot(history.history['accuracy'], '#1f77b4')\n",
        "plt.plot(history.history['val_accuracy'], '#ff7f0e')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.legend(['Train', 'Validation'], loc='lower right')\n",
        "plt.show()\n",
        "\n",
        "# PLOT LOSS\n",
        "plt.title('Model Loss')\n",
        "plt.plot(history.history['loss'], '#1f77b4')\n",
        "plt.plot(history.history['val_loss'], '#ff7f0e')\n",
        "plt.ylabel('Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.legend(['Train', 'Validation'], loc='upper right')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "G3Eare9ATzlf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 573
        },
        "outputId": "3c4a589a-13ef-4ca6-b1b9-d20241248af3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Melihat gambar diatas kita dapat melihat progres accuracy yang kita dapat dari model kita. Dari grafik tersebut model kita **tidak overfiting ataupun underfiting**"
      ],
      "metadata": {
        "id": "yh2M-7uNb74S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Testing Model"
      ],
      "metadata": {
        "id": "UbcyxE5fUP2b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "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",
        "  # predicting images\n",
        "  path = fn\n",
        "  img = image.load_img(path, target_size=(150,150))\n",
        "\n",
        "  imgplot = plt.imshow(img)\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "  images = np.vstack([x])\n",
        "\n",
        "  classes = model.predict(images, batch_size=10)  \n",
        "  print(fn)\n",
        "  if classes[0][0]==1:\n",
        "   print('paper')\n",
        "  elif classes[0][1]==1:\n",
        "   print('rock')\n",
        "  elif classes[0][2]==1:\n",
        "   print('scissors')"
      ],
      "metadata": {
        "id": "fogFZUJUUVWU",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": "OK"
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 362
        },
        "outputId": "e4bd2438-586f-431e-d2de-2a02a8f9c889"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8883ca08-9b3e-47e2-894c-2470764e9932\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8883ca08-9b3e-47e2-894c-2470764e9932\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving paper2.jpg to paper2 (1).jpg\n",
            "paper2.jpg\n",
            "paper\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "dark"
          }
        }
      ]
    }
  ]
}