4_Convolutional_Neural_Network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "4. Convolutional Neural Network.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/badrus123/compression-dl/blob/master/4_Convolutional_Neural_Network.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4aGyNYJzZ15K",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://anvaqta.id/headerai.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FC2GTCP97QOU",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "# Convolutional Neural Network (CNN)\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PI-kUeIUAUIp",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Kelemahan Multi Layer Perceptron\n",
        "Data MNIST diatas terdiri dari nilai 0–255 untuk setiap pixel yang ada. Kita bisa saja menggunakan MLP untuk melakukan klasifikasi untuk semua digit dengan hasil yang cukup baik karena sebagian besar data pada MNIST, object yang akan dikenali berada ditengah-tengah gambar.\n",
        "\n",
        "![alt text](https://miro.medium.com/max/761/1*wPvGyzWJRHO-yxbI57p2zg.png)\n",
        "\n",
        "Lalu bagaima jika object yang akan dikenali tidak berada ditengah-tengah gambar? Disinilah kelemahan dari MLP. Angka 6 yang berada ditengah-tengah gambar akan berhasil dikenali, tetapi angka 6 yang berada dipojok kiri mungkin tidak akan dikenali.\n",
        "\n",
        "Kita bisa menggunakan data yang sangat banyak dengan tiap digit berada pada lokasi yang berbeda, namun ini bukan cara yang efisien untuk mengatasi permasalahan tersebut."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H6pxtDTEAomL",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Convolutional Neural Network (CNN)\n",
        "***Convolutional Neural Network (CNN)*** adalah salah satu jenis neural network yang biasa digunakan pada data image. CNN bisa digunakan untuk mendeteksi dan mengenali object pada sebuah image.\n",
        "\n",
        "Secara garis besar CNN tidak jauh beda dengan neural network biasanya. CNN terdiri dari neuron yang memiliki weight, bias dan activation function seperti yang sudah kita pelajari pada part sebelumnya.\n",
        "\n",
        "Lalu apa yang membedakan? Arsitektur dari CNN bekerja dengan cara mengkonvolusi tiap pixel pada gambar yang setelahnya dilanjutkan oleh MLP\n",
        "\n",
        "![alt text](https://miro.medium.com/max/772/1*kkyW7BR5FZJq4_oBTx3OPQ.png)\n",
        "\n",
        "Secara garis besar CNN memiliki ***3 Layer Utama*** yaitu ***Convolution Layer, Pooling Layer, dan Fully Connected (MLP)***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fe2HFlNO7QOc",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Convolution Layer\n",
        "![alt text](https://miro.medium.com/max/550/1*15yDvGKV47a0nkf5qLKOOQ.png)\n",
        "\n",
        "\n",
        "Gambar diatas adalah RGB (Red, Green, Blue) image berukuran 4x4 pixels yang sebenarnya adalah multidimensional array dengan ukuran 4x4x3 (3 adalah jumlah channel).\n",
        "\n",
        "Convolutional layer terdiri kumpulan neuron yang tersusun sehingga membentuk suatu gambar dengan channel tertentu. Untuk melakukan konvolusi diperlukan sebuah filter dengan ukuran tertentu, tiap channel pada gambar input akan dikonvolusi menggunakan filter\n",
        "\n",
        "![alt text](https://miro.medium.com/max/526/1*GcI7G-JLAQiEoCON7xFbhg.gif)\n",
        "\n",
        "Pada gambar demonstrasi konvolusi diatas, area hijau adalah ***input image berukuran 5x5x1***, dan area kuning adalah area yang sedang dilakukan konvolusi dengan ***filter/kernel berukuran 3x3x1***\n",
        "\n",
        "Pada gambar yang memiliki 3 channel (RGB), akan memiliki ***3 filter***. Ketiga filter ini akan digeser keseluruh bagian dari gambar. Setiap pergeseran akan dilakukan operasi “dot” antara input dan nilai dari filter tersebut sehingga menghasilkan sebuah output atau biasa disebut sebagai activation map atau feature map.\n",
        "\n",
        "\n",
        "![alt text](https://miro.medium.com/max/1280/1*ciDgQEjViWLnCbmX-EeSrA.gif)\n",
        "\n",
        "Jika ketika channel tersebut ditumpuk akan menjadi seperti berikut\n",
        "\n",
        "![alt text](https://miro.medium.com/max/326/1*NsiYxt8tPDQyjyH3C08PVA@2x.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Arlb2m6vClQ5",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "### Stride\n",
        "Stride adalah parameter yang menentukan berapa jumlah pergeseran filter. Jika nilai stride adalah 1, maka conv. filter akan bergeser sebanyak 1 pixels secara horizontal lalu vertical. Pada ilustrasi diatas, stride yang digunakan adalah 2.\n",
        "\n",
        "Semakin kecil stride maka akan semakin detail informasi yang kita dapatkan dari sebuah input, namun membutuhkan komputasi yang lebih jika dibandingkan dengan stride yang besar.\n",
        "\n",
        "Namun perlu diperhatikan bahwa dengan menggunakan stride yang kecil kita tidak selalu akan mendapatkan performa yang bagus.\n",
        "\n",
        "Tujuan dilakukanya padding adalah agar ***Dimensi Gambar Tidak Berubah*** dan meningkatkan performa karena ***filter akan berfokus pada informasi yang sebenarnya***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uo7ZKhL_Cs7x",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "### Padding\n",
        "Sedangkan Padding atau Zero Padding adalah parameter yang menentukan jumlah pixels (berisi nilai 0) yang akan ditambahkan di setiap sisi dari input. Hal ini digunakan dengan tujuan untuk memanipulasi dimensi output dari conv. layer (Feature Map)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jcnqIlGkDdyN",
        "colab_type": "text"
      },
      "source": [
        "Untuk menghitung dimensi output, kita bisa menggunakan persamaan berikut\n",
        "\n",
        "\n",
        "$output = \\frac{W - N + 2P}{S}+1$\n",
        "\n",
        "W = Panjang/Tinggi input<br>\n",
        "N = Panjang/Tinggi filter<br>\n",
        "P = Zero Padding<br>\n",
        "S = Stride<br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3s7b5bP87QOf",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Pooling Layer\n",
        "Pooling layer biasanya berada setelah conv. layer. Pada prinsipnya pooling layer terdiri dari sebuah filter dengan ukuran dan stride tertentu yang akan bergeser pada seluruh area feature map.\n",
        "\n",
        "\n",
        "Pooling yang biasa digunakan adalah Max Pooling dan Average Pooling. Sebagai contoh jika kita menggunakan Max Pooling 3x3 dengan stride 1, maka pada setiap pergeseran filter, nilai maximum pada area 3x3 pixel tersebut yang akan dipilih, sedangkan Average Pooling akan memilih nilai rata-ratanya.\n",
        "\n",
        "![alt text](https://miro.medium.com/max/396/1*uoWYsCV5vBU8SHFPAPao-w.gif)\n",
        "\n",
        "Contoh MaxPooling dan AveragePooling dengan ukuran 3x3 dan stride 2\n",
        "\n",
        "![alt text](https://miro.medium.com/max/596/1*KQIEqhxzICU7thjaQBfPBQ.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-WpRAgKFJhwU",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Fully Connected Layer\n",
        "![alt text](https://miro.medium.com/max/802/1*kToStLowjokojIQ7pY2ynQ.jpeg)\n",
        "\n",
        "Fully connected layer bertugas sebagai ***eksekutor*** yang bertugas untuk menentukan apa label yang harus dioutputkan"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_kYvPUjVKG9E",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Backpropagation di Convolution Layer\n",
        "Terdapat 2 metode, yaotu Cross-Correlation dan Convolution\n",
        "\n",
        "\n",
        "misalkan terdapat gambar ***I*** dan sebuah kernel (filter) ***F*** dengan ukuran **[k x k]**\n",
        "\n",
        "#### Cross-Correlation\n",
        "$C = I \\oplus F$\n",
        "\n",
        "$C(x,y) = \\sum^{k-1}_{a=0}\\sum^{k-1}_{b=0} I (x+a, y+b)*F(a,b)$\n",
        "\n",
        "#### Convolution\n",
        "$C=I*F$\n",
        "\n",
        "$C(x,y) = \\sum^{k-1}_{a=0}\\sum^{k-1}_{b=0} I (x-a, y-b)*F(a,b)$\n",
        "\n",
        "Convolution sama seperti Cross-Correlation, hanya saja filternya di flip **horizontal dan vertical**\n",
        "\n",
        "Kebanyakan library machine learning menggunakan metode Cross-Correlation, tapi disebutnya Convolution\n",
        "\n",
        "Penjelasan lebih lanjut bisa baca artikel [berikut](https://www.jefkine.com/general/2016/09/05/backpropagation-in-convolutional-neural-networks/?source=post_page-----b003b477dc94----------------------)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eC6CWcwEMiBK",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "# Klasifikasi MNIST-Digit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dPSEUHztPHIf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install tensorflow-gpu==2.0.0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n4XN5PJsPNXO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import tensorflow as tf\n",
        "tf.__version__"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QxIOWWY6MzB1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras.datasets import mnist\n",
        "from tensorflow.keras.layers import Conv2D, Dense, MaxPooling2D, Flatten\n",
        "from tensorflow.keras.models import Sequential\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "np.set_printoptions(precision=7)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t7FffH5FMpNj",
        "colab_type": "text"
      },
      "source": [
        "## Load Dataset MNIST-Digit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j9JxRooXMsc6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "(X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
        "\n",
        "X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1)\n",
        "X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], X_test.shape[2], 1)\n",
        "\n",
        "print('X_train.shape =',X_train.shape)\n",
        "print('y_train.shape =',y_train.shape)\n",
        "print('X_test.shape  =',X_test.shape)\n",
        "print('y_test.shape  =',y_test.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ROsLel6JNPCp",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Visualisasi MNIST-Digit"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aYuYf385Nels",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "fig, ax = plt.subplots(2,10,figsize=(15,4.5))\n",
        "fig.subplots_adjust(hspace=0.1, wspace=0.1)\n",
        "for j in range(0,2):\n",
        "    for i in range(0, 10):\n",
        "        ax[j,i].imshow(X_train[i+j*10].reshape(28,28), cmap='gray')\n",
        "        ax[j,i].set_title(y_train[i+j*10])\n",
        "        ax[j,i].axis('off')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e1dM4j3bNinP",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Bagi Data Validasi dan Data Train"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HYD9AYMZNh6A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_val = X_train[-10000:,:]\n",
        "y_val = y_train[-10000:]\n",
        "\n",
        "X_train = X_train[:-10000, :]\n",
        "y_train = y_train[:-10000]\n",
        "\n",
        "print('X_val.shape   =',X_val.shape)\n",
        "print('y_val.shape   =',y_val.shape)\n",
        "print('X_train.shape =',X_train.shape)\n",
        "print('y_train.shape =',y_train.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7MFQpMCTNm4I",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## One hot matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5kMFKSaCNo9S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "# ubah label menjadi one hot matrix dengan memanggil fungsi to_categorical 10\n",
        "y_train_hot = ??\n",
        "y_val_hot = ??\n",
        "y_test_hot = ??\n",
        "\n",
        "print('y_train_hot.shape =',y_train_hot.shape)\n",
        "print('y_val_hot.shape   =',y_val_hot.shape)\n",
        "print('y_test_hot.shape  =',y_test_hot.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXfCyiWxNy03",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Buat Model CNN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TYnqtPgBOMfK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = Sequential([\n",
        "          # Buat Layer Conv2D dengan parameter (64, kernel_size=(3,3), strides=(1,1), input_shape=(28,28,1) dan activation='relu')\n",
        "          ??\n",
        "          # Buat Layer MaxPooling2D\n",
        "          ??\n",
        "          # Tambahkan Layer Flatten\n",
        "          ??\n",
        "          # Tambahkan Layer Dense dengan 128 layer dan activation relu\n",
        "          ??\n",
        "          # Tambahkan Layer Dense dengan 10 layer output dengan activation softmax\n",
        "          ??\n",
        "])\n",
        "model.summary()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "piU1rvxARKuH",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Train MNIST Classifier\n",
        "Mari kita train model kita sebanyak `5 epochs` dengan loss `categorical_crossentropy`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HDZoyajzROeP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "epochs = ??\n",
        "model.compile(optimizer='adam', loss=??, metrics=['accuracy'])\n",
        "model.fit(X_train, y_train_hot,\n",
        "          validation_data=(X_val, y_val_hot),\n",
        "          epochs=epochs,\n",
        "          verbose=2)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CoErxwoeR2YT",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Evaluasi Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JVjFmVvsR51H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "scores = model.evaluate(X_test, y_test_hot, verbose=1)\n",
        "print(\"\\nModel Accuracy: %.2f%%\" % (scores[1]*100))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bYVkrSToR7mL",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Testing Dengan Data Baru\n",
        "Sekarang mari kita coba model yang sudah dilatih dengan data baru menggunakan data test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UGxv0Mj2SJg1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "predictions = model.predict(X_test.astype('float32'))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D7jFn5ZwSoDE",
        "colab_type": "text"
      },
      "source": [
        "Kita tampilkan hasil prediksi pada 20 gambar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZ0XV4ZSSro1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "fig, ax = plt.subplots(2,10,figsize=(15,4.5))\n",
        "fig.subplots_adjust(hspace=0.1, wspace=0.1)\n",
        "for j in range(0,2):\n",
        "    for i in range(0, 10):\n",
        "        ax[j,i].imshow(X_test[i+j*10].reshape(28,28), cmap='gray')\n",
        "        ax[j,i].set_title(np.argmax(predictions[i+j*10]))\n",
        "        ax[j,i].axis('off')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1uExA10LS0Ki",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Test Dengan Gambar Manual Menggunakan Canvas\n",
        "kita akan bangun fungsi untuk bisa menggambar di Google Colab ini dan memasukkan input gambar baru ke model\n",
        "\n",
        "Jalankan cell di bawah untuk membangun fungsi menggambar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "22ceki6HS9QL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from IPython.display import HTML, Image\n",
        "from google.colab.output import eval_js\n",
        "from base64 import b64decode\n",
        "\n",
        "canvas_html = \"\"\"\n",
        "<canvas width=%d height=%d style=\"border:1px solid #000000;\"></canvas>\n",
        "<button>Finish</button>\n",
        "<script>\n",
        "var canvas = document.querySelector('canvas')\n",
        "var ctx = canvas.getContext('2d')\n",
        "ctx.lineWidth = %d\n",
        "var button = document.querySelector('button')\n",
        "var mouse = {x: 0, y: 0}\n",
        "canvas.addEventListener('mousemove', function(e) {\n",
        "  mouse.x = e.pageX - this.offsetLeft\n",
        "  mouse.y = e.pageY - this.offsetTop\n",
        "})\n",
        "canvas.onmousedown = ()=>{\n",
        "  ctx.beginPath()\n",
        "  ctx.moveTo(mouse.x, mouse.y)\n",
        "  canvas.addEventListener('mousemove', onPaint)\n",
        "}\n",
        "canvas.onmouseup = ()=>{\n",
        "  canvas.removeEventListener('mousemove', onPaint)\n",
        "}\n",
        "var onPaint = ()=>{\n",
        "  ctx.lineTo(mouse.x, mouse.y)\n",
        "  ctx.stroke()\n",
        "}\n",
        "var data = new Promise(resolve=>{\n",
        "  button.onclick = ()=>{\n",
        "    resolve(canvas.toDataURL('image/png'))\n",
        "  }\n",
        "})\n",
        "</script>\n",
        "\"\"\"\n",
        "\n",
        "def draw(filename='drawing.jpg', w=300, h=300, line_width=20):\n",
        "  display(HTML(canvas_html % (w, h, line_width)))\n",
        "  data = eval_js(\"data\")\n",
        "  binary = b64decode(data.split(',')[1])\n",
        "  with open(filename, 'wb') as f:\n",
        "    f.write(binary)\n",
        "  print('gambar baru diterima')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P5nzgCOGS_x7",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Input Gambar Baru\n",
        "Sekarang, jalankan cell di bawah, lalu coba gambar (tuliskan) input angka baru\n",
        "\n",
        "setelah selesai, klik tombol `Finish`\n",
        "\n",
        "usahakan gambar angka cukup besar, namun tidak menyentuh garis tepi"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D0PW0ByRTFRL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "draw()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rYefbiZVTIo3",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Resize Gambar\n",
        "Sekarang, ubah data menjadi Grayscale, dan resize data menjadi ukuran yang sama dengan data latih, yaitu `28x28`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0uU1eErwVbUc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from PIL import Image\n",
        "import cv2 as cv\n",
        "\n",
        "new_img = Image.open('drawing.jpg')\n",
        "new_img = np.array(new_img)[:,:,3]\n",
        "print('ukuran awal = ',new_img.shape)\n",
        "\n",
        "new_img2 = cv.resize(new_img, (28, 28),interpolation = cv.INTER_AREA) \n",
        "print('ukuran baru = ',new_img2.shape)\n",
        "\n",
        "plt.imshow(new_img2, cmap='gray')\n",
        "plt.show()\n",
        "new_img2 = new_img2.astype('float32')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qlIL9XahVep0",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Prediksi Gambar\n",
        "Sekarang kita tinggal memprediksi data baru tersebut\n",
        "\n",
        "Coba lihat, apakah model sudah pintar\n",
        "\n",
        "jika belum, lanjutkan proses pelatihan dengan menjalankan cell yang memanggil fungsi `fit`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jlpggrpRVeG8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_pred = model.predict(new_img2.reshape((1,28,28,1)))\n",
        "\n",
        "print(\"Prediksi data baru: y = \" + str(np.argmax(y_pred[0])))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Kdq4txp6In1H"
      },
      "source": [
        "---\n",
        "# Klasifikasi CIFAR-10\n",
        "\n",
        "\n",
        "Jangan lupa, pastikan Colab ini berjalan dengan GPU\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "za1yHV5VXc78",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Load Dataset CIFAR-10"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "e9lcWKk9In1U",
        "colab": {}
      },
      "source": [
        "(X_train, y_train), (X_test, y_test) = tf.keras.datasets.cifar10.load_data()\n",
        "\n",
        "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
        "\n",
        "print('X_train.shape =',X_train.shape)\n",
        "print('y_train.shape =',y_train.shape)\n",
        "print('X_test.shape  =',X_test.shape)\n",
        "print('y_test.shape  =',y_test.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "9rhC32AWIn1Z"
      },
      "source": [
        "---\n",
        "## Visualisasi Data CIFAR-10\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Zk4QVV87In1b",
        "colab": {}
      },
      "source": [
        "fig, ax = plt.subplots(2,10,figsize=(15,4.5))\n",
        "fig.subplots_adjust(hspace=0.1, wspace=0.1)\n",
        "for j in range(0,2):\n",
        "    for i in range(0, 10):\n",
        "        ax[j,i].imshow(X_train[i+j*10])\n",
        "        ax[j,i].set_title(classes[y_train[i+j*10,0]])\n",
        "        ax[j,i].axis('off')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "uhUO9G5MIn1g"
      },
      "source": [
        "---\n",
        "## Bagi Data Validasi\n",
        "Ambil 10,000 data terakhir dari data latih menjadi data Validasi di dalam matrix `X_val` dan `y_val`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "oCSjAqPzIn1i",
        "colab": {}
      },
      "source": [
        "X_val = X_train[-10000:,:]\n",
        "y_val = y_train[-10000:]\n",
        "\n",
        "X_train = X_train[:-10000, :]\n",
        "y_train = y_train[:-10000]\n",
        "\n",
        "print('X_val.shape   =',X_val.shape)\n",
        "print('y_val.shape   =',y_val.shape)\n",
        "print('X_train.shape =',X_train.shape)\n",
        "print('y_train.shape =',y_train.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ZonG85IOIn1o"
      },
      "source": [
        "---\n",
        "## Normalizing Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "yfEl2gZJIn1p",
        "colab": {}
      },
      "source": [
        "X_train = X_train.astype('float32')\n",
        "X_val = X_val.astype('float32')\n",
        "X_test = X_test.astype('float32')\n",
        "\n",
        "mean_image = np.mean(X_train, axis = 0)\n",
        "X_train -= mean_image\n",
        "X_val -= mean_image\n",
        "X_test -= mean_image\n",
        "\n",
        "print('X_train.shape =',X_train.shape)\n",
        "print('X_val.shape   =',X_val.shape)\n",
        "print('X_test.shape  =',X_test.shape)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "rQohd54TIn1x"
      },
      "source": [
        "---\n",
        "## One Hot Matrix\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "kveJWXJYIn14"
      },
      "source": [
        " Ubah vektor target `y_train`, `y_val`, dan `y_test` menjadi bentuk One-Hot Matrix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "neQU8KqDIn1_",
        "colab": {}
      },
      "source": [
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "# jadingan label menjadi one hot matrix dengan menggunakan fungsi to_categorical\n",
        "y_train_hot = ??\n",
        "y_val_hot = ??\n",
        "y_test_hot = ??\n",
        "\n",
        "print('y_train_hot.shape =',y_train_hot.shape)\n",
        "print('y_val_hot.shape   =',y_val_hot.shape)\n",
        "print('y_test_hot.shape  =',y_test_hot.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "34l5N13yIn5O"
      },
      "source": [
        "---\n",
        "## Inisialisasi Parameter\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "k98ABsZD_q5w",
        "colab": {}
      },
      "source": [
        "num_data    = X_train.shape[0]\n",
        "X_dim       = X_train.shape[1]\n",
        "num_classes = y_train_hot.shape[1]\n",
        "num_epochs = 15\n",
        "batch_size = 1000"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7rAtpk9isRKR",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Kita Coba Bandingkan MLP dan CNN\n",
        "mari kita coba bandingkan MLP dan CNN, jadi mari buat kedua model tersebut"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "quiLO8HHZl0U",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "## Buat Model MLP"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aACPUx1fZoYs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model_ann = Sequential([\n",
        "    # Buat layer Flatten dengan input shape (32,32,3)\n",
        "    ??\n",
        "    # Buat layer Dense dengan 500 neuron dan fungsi aktivasi relu\n",
        "    ??\n",
        "    # Buat layer Dense dengan 200 neuron dan fungsi aktivasi relu\n",
        "    ??\n",
        "    # Buat layer output Dense dengan neuron sebanyak num_classes output dan fungsi aktivasi softmax\n",
        "    ??\n",
        "])\n",
        "\n",
        "model_ann.summary()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "49EFaKVVZ0vh",
        "colab_type": "text"
      },
      "source": [
        "### Latih Model MLP"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EALrKFO4Z3bZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model_ann.compile(loss='categorical_crossentropy', \n",
        "              optimizer='adam', metrics=['accuracy'])\n",
        "\n",
        "hist_ann = model_ann.fit(X_train, y_train_hot, \n",
        "          validation_data=(X_val, y_val_hot),\n",
        "          epochs=num_epochs,\n",
        "          batch_size=batch_size,\n",
        "          verbose=2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wElcpSCg_q5v"
      },
      "source": [
        "---\n",
        "## Buat Model CNN\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "R0xzjgWQ_q56",
        "colab": {}
      },
      "source": [
        "# create model compact sequential\n",
        "\n",
        "model_cnn = Sequential([\n",
        "    # Buat layer Conv2D dengan parameter (32, (3,3), input_shape=(32,32,3) dan activation='relu')\n",
        "    ??\n",
        "    # Buat layer MaxPooling2D\n",
        "    ??\n",
        "    # Buat layer Conv2D dengan parameter (64, (3,3) dan activation='relu')\n",
        "    ??\n",
        "    # Buat Layer MaxPooling2D\n",
        "    ??\n",
        "    # Buat Layer Conv2D dengan 64, (3,3),= dan activation='relu'\n",
        "    ??\n",
        "    # Buat layer MaxPoolin2D\n",
        "    ??\n",
        "    # Buat Layer Flatten\n",
        "    ??\n",
        "    # Buat Layer Dense dengan 64 neuron dan fungsi aktivasi relu\n",
        "    ??\n",
        "    # Buat layer output Dense dengan neuron sejumlah num_classes dengan fungsi aktivasi softmax\n",
        "    ??\n",
        "])\n",
        "\n",
        "model_cnn.summary()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "pmDso_8jIn5V"
      },
      "source": [
        "---\n",
        "## Melatih Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "lR9WhzsFIn5V",
        "colab": {}
      },
      "source": [
        "# Compile model\n",
        "model_cnn.compile(loss='categorical_crossentropy', \n",
        "              optimizer='adam', metrics=['accuracy'])\n",
        "\n",
        "\n",
        "num_epochs = 15\n",
        "batch_size = 1000\n",
        "\n",
        "hist_cnn = model_cnn.fit(X_train, y_train_hot, \n",
        "          validation_data=(X_val, y_val_hot),\n",
        "          epochs=num_epochs,\n",
        "          batch_size=batch_size,\n",
        "          verbose=2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "3ibLtwIAIn5V"
      },
      "source": [
        "---\n",
        "## Evaluasi Model\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "VTD6WFU2In5W",
        "colab": {}
      },
      "source": [
        "scores_ann = model_ann.evaluate(X_test, y_test_hot, verbose=1)\n",
        "print(\"\\nModel Accuracy: %.2f%%\" % (scores_ann[1]*100))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "lAmucgajolXt",
        "colab": {}
      },
      "source": [
        "scores_cnn = model_cnn.evaluate(X_test, y_test_hot, verbose=1)\n",
        "print(\"\\nModel Accuracy: %.2f%%\" % (scores_cnn[1]*100))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "NnkdHf-gsn3R"
      },
      "source": [
        "---\n",
        "# Perbandingan MLP dan CNN\n",
        "\n",
        "Sekarang, mari kita investigasi performa MLP dan CNN"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "_HIuWVyzssQ-"
      },
      "source": [
        "---\n",
        "## Jumlah Parameter"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "rucd-dstsrBF",
        "colab": {}
      },
      "source": [
        "print('model MLP:')\n",
        "model_ann.summary()\n",
        "\n",
        "print('\\n\\nmodel CNN:')\n",
        "model_cnn.summary()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "cJph5BbhszSz",
        "colab": {}
      },
      "source": [
        "print('total parameter MLP:', f'{ model_ann.count_params():,}')\n",
        "print('total parameter CNN:', f'{ model_cnn.count_params():,}')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "AAdNRfYCuJVB"
      },
      "source": [
        "---\n",
        "## Grafik Hasil Pelatihan"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "j6M2Nzr3uJ1S",
        "colab": {}
      },
      "source": [
        "fig, ax = plt.subplots(1,3,figsize=(18,3))\n",
        "\n",
        "ax[0].plot(hist_ann.history['loss'])\n",
        "ax[0].plot(hist_cnn.history['loss'])\n",
        "ax[0].set_title('Train Loss')\n",
        "ax[0].set_ylabel('Loss')\n",
        "ax[0].set_xlabel('Epoch')\n",
        "ax[0].legend(['MLP', 'CNN'], loc='upper right')\n",
        "\n",
        "ax[1].plot(hist_ann.history['accuracy'])\n",
        "ax[1].plot(hist_cnn.history['accuracy'])\n",
        "ax[1].set_title('Train Accuracy')\n",
        "ax[1].set_ylabel('Accuracy')\n",
        "ax[1].set_xlabel('Epoch')\n",
        "# ax[1].set_ylim(bottom=.7)\n",
        "ax[1].legend(['MLP', 'CNN'], loc='lower right')\n",
        "\n",
        "ax[2].plot(hist_ann.history['val_accuracy'])\n",
        "ax[2].plot(hist_cnn.history['val_accuracy'])\n",
        "ax[2].set_title('Validation Accuracy')\n",
        "ax[2].set_ylabel('Accuracy')\n",
        "ax[2].set_xlabel('Epoch')\n",
        "# ax[2].set_ylim(bottom=.7)\n",
        "ax[2].legend(['MLP', 'CNN'], loc='lower right')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "UiN4exlAtfly"
      },
      "source": [
        "---\n",
        "## Akurasi Data Uji"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "RAbAilYSt0pD",
        "colab": {}
      },
      "source": [
        "print(\"Akurasi MLP: %.2f%%\" % (scores_ann[1]*100))\n",
        "print(\"Akurasi CNN: %.2f%%\" % (scores_cnn[1]*100))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "NfOgnKWBzs1L"
      },
      "source": [
        "---\n",
        "## Pengecekan Overfitting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "_B364ZEqzNw2",
        "colab": {}
      },
      "source": [
        "fig, ax = plt.subplots(1,2,figsize=(10,3))\n",
        "\n",
        "ax[0].plot(hist_ann.history['accuracy'])\n",
        "ax[0].plot(hist_ann.history['val_accuracy'])\n",
        "ax[0].set_title('ANN Accuracy')\n",
        "ax[0].set_ylabel('Accuracy')\n",
        "ax[0].set_xlabel('Epoch')\n",
        "ax[0].set_ylim(bottom=.1)\n",
        "ax[0].set_ylim(top=.55)\n",
        "ax[0].legend(['train', 'val'], loc='lower right')\n",
        "\n",
        "ax[1].plot(hist_cnn.history['accuracy'])\n",
        "ax[1].plot(hist_cnn.history['val_accuracy'])\n",
        "ax[1].set_title('CNN Accuracy')\n",
        "ax[1].set_ylabel('Accuracy')\n",
        "ax[1].set_xlabel('Epoch')\n",
        "ax[1].set_ylim(bottom=.1)\n",
        "ax[1].set_ylim(top=.55)\n",
        "ax[1].legend(['train', 'val'], loc='lower right')\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "IpkbQSTG9Eg4"
      },
      "source": [
        "Makin besar gap antara akurasi training dan validasi menandakan makin rentan terhadap overfitting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "VI0QLlzQ291a"
      },
      "source": [
        "---\n",
        "# Kesimpulan\n",
        "* CNN memiliki parameter yang jauh lebih sedikit dari ANN, namun memiliki akurasi akhir yang lebih baik\n",
        "* CNN Lebih tangguh terhadap *Overfitting*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "46FJspL2Fq0q"
      },
      "source": [
        "# Menguji Pada Image Dari Internet\n",
        "* Search Gambar di Internet (Google Image)\n",
        "* Copy Image Address\n",
        "* Paste Image Address ke cell di bawah"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "CkFlqQoIF0YD",
        "colab": {}
      },
      "source": [
        "!wget -O 'test.jpg' 'https://ewscripps.brightspotcdn.com/dims4/default/7cab7a4/2147483647/strip/true/crop/1000x563+0+0/resize/1280x720!/quality/90/?url=https%3A%2F%2Fewscripps.brightspotcdn.com%2Fd1%2F07%2Feadcd0684ba29e1b4ab58c4e9ff8%2Fnot-tippy-cat-000.png'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "gxfz7pGFGa1o"
      },
      "source": [
        "## Load Image"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "OBaJnd2gF6X_",
        "colab": {}
      },
      "source": [
        "from PIL import Image\n",
        "import cv2 as cv\n",
        "\n",
        "new_img = Image.open('test.jpg')\n",
        "new_img = np.array(new_img)\n",
        "plt.imshow(new_img)\n",
        "plt.show"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "V9i3hOXSGrn_"
      },
      "source": [
        "## Resize Image"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "epsUsupMF8km",
        "colab": {}
      },
      "source": [
        "new_img2 = cv.resize(new_img, (32,32), interpolation=cv.INTER_AREA)\n",
        "plt.imshow(new_img2)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "tsErSYdrF8bg",
        "colab": {}
      },
      "source": [
        "print(new_img2.shape)\n",
        "new_img2 = np.expand_dims(new_img2,0)\n",
        "print(new_img2.shape)\n",
        "new_img2 = new_img2.astype('float32')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "FkRPK7PGGu6n"
      },
      "source": [
        "## View Prediction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "3KxFtIOSF_fS",
        "colab": {}
      },
      "source": [
        "pred = model_cnn.predict(new_img2.reshape(1, 32,32,3))\n",
        "class_id = np.argmax(pred)\n",
        "print(class_id)\n",
        "print('kelas prediksi', classes[class_id])"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}