Python_Learning_Day_4_404_error.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMNkpMMiEAJtjwzJ1cxkhd1",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/4zmyyy/Belajarpyhton/blob/main/Python_Learning_Day_4_404_error.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i_11TLijkcBz",
        "outputId": "ae8295d2-1a02-4de8-aa04-3b7306feee6e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\r0% [Working]\r            \rHit:1 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64  InRelease\n",
            "Hit:2 https://cloud.r-project.org/bin/linux/ubuntu jammy-cran40/ InRelease\n",
            "Hit:3 https://r2u.stat.illinois.edu/ubuntu jammy InRelease\n",
            "Hit:4 https://ppa.launchpadcontent.net/deadsnakes/ppa/ubuntu jammy InRelease\n",
            "Hit:5 https://ppa.launchpadcontent.net/graphics-drivers/ppa/ubuntu jammy InRelease\n",
            "Hit:6 https://ppa.launchpadcontent.net/ubuntugis/ppa/ubuntu jammy InRelease\n",
            "Hit:7 http://archive.ubuntu.com/ubuntu jammy InRelease\n",
            "Hit:8 http://archive.ubuntu.com/ubuntu jammy-updates InRelease\n",
            "Hit:9 http://archive.ubuntu.com/ubuntu jammy-backports InRelease\n",
            "Hit:10 http://security.ubuntu.com/ubuntu jammy-security InRelease\n",
            "Reading package lists... Done\n",
            "W: Skipping acquire of configured file 'main/source/Sources' as repository 'https://r2u.stat.illinois.edu/ubuntu jammy InRelease' does not seem to provide it (sources.list entry misspelt?)\n",
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "imagemagick is already the newest version (8:6.9.11.60+dfsg-1.3ubuntu0.22.04.5).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 25 not upgraded.\n"
          ]
        }
      ],
      "source": [
        "# Install imagemagick untuk trial visualisasi sederhana\n",
        "!apt-get update\n",
        "!apt-get install imagemagick"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Re-check Image magick version untuk aplikasinya\n",
        "!convert --version"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l784UbLxlTlK",
        "outputId": "886981f2-5c34-45d3-ef95-6600073585f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Version: ImageMagick 6.9.11-60 Q16 x86_64 2021-01-25 https://imagemagick.org\n",
            "Copyright: (C) 1999-2021 ImageMagick Studio LLC\n",
            "License: https://imagemagick.org/script/license.php\n",
            "Features: Cipher DPC Modules OpenMP(4.5) \n",
            "Delegates (built-in): bzlib djvu fftw fontconfig freetype heic jbig jng jp2 jpeg lcms lqr ltdl lzma openexr pangocairo png tiff webp wmf x xml zlib\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib\n",
        "matplotlib.rcParams['animation.writer'] = 'imagemagick'"
      ],
      "metadata": {
        "id": "GIUnLjJ3lWdw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "Step by step: visualisasi neural network sederhana\n",
        "# Install library Tensorflow & Matplotlib\n",
        "!pip install tensorflow matplotlib\n",
        "\n",
        "# Import library Tensorflow keras, Matplotlib pyplot dan Numpy untuk sub-aplikasi kode\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers, models\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Kemudian, Load dataset MNIST untuk training sederhana\n",
        "mnist = tf.keras.datasets.mnist\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "\n",
        "# Lakukan Cek dan Normalisasi data agar nilai piksel berada di rentang sesuai [0, 1]\n",
        "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
        "\n",
        "# Membuat model Neural Network sederhana\n",
        "model = models.Sequential([\n",
        "    layers.Flatten(input_shape=(28, 28)),  # Meluruskan gambar 28x28 menjadi vektor 1D\n",
        "    layers.Dense(128, activation='relu'),  # Layer tersembunyi dengan 128 neuron dan aktivasi ReLU\n",
        "    layers.Dropout(0.2),                   # Dropout untuk mengurangi overfitting\n",
        "    layers.Dense(10, activation='softmax') # Output layer dengan 10 kelas (angka 0-9)\n",
        "])\n",
        "\n",
        "# Optimalisasi Compile model\n",
        "model.compile(optimizer='adam',\n",
        "              loss='sparse_categorical_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "# Percobaan Visualisasi arsitektur model\n",
        "model.summary()\n",
        "\n",
        "# Percobaan training model sederhana\n",
        "history = model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))\n",
        "\n",
        "# Cek dan evaluasi model\n",
        "test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)\n",
        "print(f\"\\nAkurasi pada data uji: {test_acc:.2f}\")\n",
        "\n",
        "# Percobaan Visualisasi hasil Training\n",
        "plt.figure(figsize=(12, 4))\n",
        "\n",
        "# Penyesuaian plot akurasi\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(history.history['accuracy'], label='Akurasi Pelatihan')\n",
        "plt.plot(history.history['val_accuracy'], label='Akurasi Validasi')\n",
        "plt.title('Akurasi Model')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Akurasi')\n",
        "plt.legend()\n",
        "\n",
        "# Penyesuaian plot loss\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(history.history['loss'], label='Loss Pelatihan')\n",
        "plt.plot(history.history['val_loss'], label='Loss Validasi')\n",
        "plt.title('Loss Model')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()\n",
        "\n",
        "# Analisa prediksi & visualisasi model\n",
        "predictions = model.predict(x_test)\n",
        "\n",
        "def plot_image(i, predictions_array, true_label, img):\n",
        "    \"\"\"Fungsi untuk menampilkan gambar dan prediksi.\"\"\"\n",
        "    predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]\n",
        "    plt.grid(False)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "\n",
        "    plt.imshow(img, cmap=plt.cm.binary)\n",
        "\n",
        "    predicted_label = np.argmax(predictions_array)\n",
        "    if predicted_label == true_label:\n",
        "        color = 'blue'\n",
        "    else:\n",
        "        color = 'red'\n",
        "\n",
        "    plt.xlabel(f\"Pred: {predicted_label} (True: {true_label})\", color=color)\n",
        "\n",
        "def plot_value_array(i, predictions_array, true_label):\n",
        "    \"\"\"Fungsi untuk menampilkan diagram batang probabilitas prediksi.\"\"\"\n",
        "    predictions_array, true_label = predictions_array[i], true_label[i]\n",
        "    plt.grid(False)\n",
        "    plt.xticks(range(10))\n",
        "    plt.yticks([])\n",
        "    thisplot = plt.bar(range(10), predictions_array, color=\"#777777\")\n",
        "    plt.ylim([0, 1])\n",
        "    predicted_label = np.argmax(predictions_array)\n",
        "\n",
        "    thisplot[predicted_label].set_color('red')\n",
        "    thisplot[true_label].set_color('blue')\n",
        "\n",
        "# Menampilkan beberapa hasil prediksi\n",
        "num_rows = 5\n",
        "num_cols = 3\n",
        "num_images = num_rows * num_cols\n",
        "plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))\n",
        "for i in range(num_images):\n",
        "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)\n",
        "    plot_image(i, predictions, y_test, x_test)\n",
        "    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)\n",
        "    plot_value_array(i, predictions, y_test)\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "-EeEISt6lagQ",
        "outputId": "e69cb154-1e38-4aba-e6f7-3a0dc940d25e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.25.6)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.5.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.12.2)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.70.0)\n",
            "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n",
            "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: numpy<2.1.0,>=1.26.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.26.4)\n",
            "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.12.1)\n",
            "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.56.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n",
            "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
            "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
            "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.1.31)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (3.0.2)\n",
            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.18.0)\n",
            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "\u001b[1m11490434/11490434\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 0us/step\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/reshaping/flatten.py:37: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(**kwargs)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1mModel: \"sequential\"\u001b[0m\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                        \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape               \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m        Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ flatten (\u001b[38;5;33mFlatten\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m784\u001b[0m)                 │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense (\u001b[38;5;33mDense\u001b[0m)                        │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m)                 │         \u001b[38;5;34m100,480\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dropout (\u001b[38;5;33mDropout\u001b[0m)                    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m)                 │               \u001b[38;5;34m0\u001b[0m │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_1 (\u001b[38;5;33mDense\u001b[0m)                      │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m)                  │           \u001b[38;5;34m1,290\u001b[0m │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓\n",
              "┃<span style=\"font-weight: bold\"> Layer (type)                         </span>┃<span style=\"font-weight: bold\"> Output Shape                </span>┃<span style=\"font-weight: bold\">         Param # </span>┃\n",
              "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩\n",
              "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">784</span>)                 │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                        │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)                 │         <span style=\"color: #00af00; text-decoration-color: #00af00\">100,480</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)                    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)                 │               <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
              "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n",
              "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                      │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>)                  │           <span style=\"color: #00af00; text-decoration-color: #00af00\">1,290</span> │\n",
              "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m101,770\u001b[0m (397.54 KB)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">101,770</span> (397.54 KB)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m101,770\u001b[0m (397.54 KB)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">101,770</span> (397.54 KB)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
            ],
            "text/html": [
              "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
              "</pre>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 5ms/step - accuracy: 0.8574 - loss: 0.4838 - val_accuracy: 0.9576 - val_loss: 0.1420\n",
            "Epoch 2/5\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 4ms/step - accuracy: 0.9550 - loss: 0.1539 - val_accuracy: 0.9693 - val_loss: 0.0991\n",
            "Epoch 3/5\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 4ms/step - accuracy: 0.9661 - loss: 0.1109 - val_accuracy: 0.9724 - val_loss: 0.0875\n",
            "Epoch 4/5\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 4ms/step - accuracy: 0.9727 - loss: 0.0893 - val_accuracy: 0.9761 - val_loss: 0.0763\n",
            "Epoch 5/5\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 5ms/step - accuracy: 0.9778 - loss: 0.0715 - val_accuracy: 0.9773 - val_loss: 0.0708\n",
            "313/313 - 1s - 2ms/step - accuracy: 0.9773 - loss: 0.0708\n",
            "\n",
            "Akurasi pada data uji: 0.98\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x400 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 2ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1000 with 30 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Install library Tensorflow, Matplotlib\n",
        "!pip install tensorflow matplotlib\n",
        "\n",
        "# Import library\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers, models\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from matplotlib.animation import FuncAnimation\n",
        "\n",
        "# Load dataset MNIST\n",
        "mnist = tf.keras.datasets.mnist\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "\n",
        "# Normalisasi data\n",
        "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
        "\n",
        "# Membuat model Neural Network sederhana\n",
        "model = models.Sequential([\n",
        "    layers.Flatten(input_shape=(28, 28)),\n",
        "    layers.Dense(128, activation='relu'),\n",
        "    layers.Dropout(0.2),\n",
        "    layers.Dense(10, activation='softmax')\n",
        "])\n",
        "\n",
        "# Compile model\n",
        "model.compile(optimizer='adam',\n",
        "              loss='sparse_categorical_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "\n",
        "# Fungsi untuk melatih model dan menyimpan sejarah pelatihan\n",
        "class TrainingHistory:\n",
        "    def __init__(self):\n",
        "        self.accuracy = []\n",
        "        self.loss = []\n",
        "\n",
        "    def on_epoch_end(self, epoch, logs):\n",
        "        self.accuracy.append(logs['accuracy'])\n",
        "        self.loss.append(logs['loss'])\n",
        "\n",
        "# Inisialisasi objek untuk menyimpan record training\n",
        "history = TrainingHistory()\n",
        "\n",
        "# Training model dengan callback untuk menyimpan record training sebelumnya\n",
        "model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test),\n",
        "          callbacks=[tf.keras.callbacks.LambdaCallback(on_epoch_end=history.on_epoch_end)])\n",
        "\n",
        "# Visualisasi animasi\n",
        "fig, ax = plt.subplots(figsize=(8, 4))\n",
        "ax.set_xlim(0, 10)\n",
        "ax.set_ylim(0, 1)\n",
        "line_accuracy, = ax.plot([], [], lw=2, label='Akurasi Pelatihan')\n",
        "line_loss, = ax.plot([], [], lw=2, label='Loss Pelatihan')\n",
        "ax.legend()\n",
        "\n",
        "# Cek fungsi inisialisasi untuk animasi\n",
        "def init():\n",
        "    line_accuracy.set_data([], [])\n",
        "    line_loss.set_data([], [])\n",
        "    return line_accuracy, line_loss\n",
        "\n",
        "# Cek fungsi, akurasi update untuk animasi\n",
        "def update(frame):\n",
        "    x = list(range(1, frame + 2))  # Epoch ke-n\n",
        "    y_accuracy = history.accuracy[:frame + 1]\n",
        "    y_loss = history.loss[:frame + 1]\n",
        "    line_accuracy.set_data(x, y_accuracy)\n",
        "    line_loss.set_data(x, y_loss)\n",
        "    return line_accuracy, line_loss\n",
        "\n",
        "# Pembuatan animasi\n",
        "ani = FuncAnimation(fig, update, frames=10, init_func=init, blit=True)\n",
        "\n",
        "# Simpan animasi sebagai GIF\n",
        "ani.save('neural_network_training.gif', writer='imagemagick', fps=2)\n",
        "\n",
        "# Tampilkan animasi di notebook\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "JfTRcJfdl0IJ",
        "outputId": "652d5065-b3df-492c-b069-353c69af75e6"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.25.6)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.5.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.12.2)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.70.0)\n",
            "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n",
            "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: numpy<2.1.0,>=1.26.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.26.4)\n",
            "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.12.1)\n",
            "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.56.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n",
            "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
            "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
            "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.1.31)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (3.0.2)\n",
            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.18.0)\n",
            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
            "\u001b[1m11490434/11490434\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 0us/step\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.11/dist-packages/keras/src/layers/reshaping/flatten.py:37: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
            "  super().__init__(**kwargs)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 4ms/step - accuracy: 0.8613 - loss: 0.4795 - val_accuracy: 0.9574 - val_loss: 0.1373\n",
            "Epoch 2/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 9ms/step - accuracy: 0.9536 - loss: 0.1551 - val_accuracy: 0.9686 - val_loss: 0.1031\n",
            "Epoch 3/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 8ms/step - accuracy: 0.9666 - loss: 0.1077 - val_accuracy: 0.9707 - val_loss: 0.0923\n",
            "Epoch 4/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 4ms/step - accuracy: 0.9740 - loss: 0.0852 - val_accuracy: 0.9770 - val_loss: 0.0752\n",
            "Epoch 5/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 4ms/step - accuracy: 0.9779 - loss: 0.0712 - val_accuracy: 0.9782 - val_loss: 0.0715\n",
            "Epoch 6/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 4ms/step - accuracy: 0.9798 - loss: 0.0634 - val_accuracy: 0.9794 - val_loss: 0.0674\n",
            "Epoch 7/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 4ms/step - accuracy: 0.9830 - loss: 0.0529 - val_accuracy: 0.9797 - val_loss: 0.0702\n",
            "Epoch 8/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 5ms/step - accuracy: 0.9845 - loss: 0.0476 - val_accuracy: 0.9793 - val_loss: 0.0724\n",
            "Epoch 9/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 4ms/step - accuracy: 0.9840 - loss: 0.0480 - val_accuracy: 0.9801 - val_loss: 0.0710\n",
            "Epoch 10/10\n",
            "\u001b[1m1875/1875\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 4ms/step - accuracy: 0.9863 - loss: 0.0402 - val_accuracy: 0.9818 - val_loss: 0.0711\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.animation:MovieWriter imagemagick unavailable; using Pillow instead.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Install library yang diperlukan\n",
        "!pip install tensorflow matplotlib numpy\n",
        "\n",
        "# Import library\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import MultiHeadAttention, Dense, LayerNormalization\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from matplotlib.animation import FuncAnimation\n",
        "\n",
        "# Simulasi input data\n",
        "sequence_length = 10  # Panjang urutan (misalnya kalimat dengan 10 kata)\n",
        "embedding_dim = 8     # Dimensi embedding (fitur per kata)\n",
        "\n",
        "# Buat input dummy\n",
        "x = tf.random.uniform((1, sequence_length, embedding_dim))  # Batch size 1\n",
        "\n",
        "# Membuat layer MultiHeadAttention\n",
        "multi_head_attention = MultiHeadAttention(num_heads=2, key_dim=embedding_dim)\n",
        "\n",
        "# Forward pass untuk mendapatkan attention weights\n",
        "output, attention_weights = multi_head_attention(x, x, return_attention_scores=True)\n",
        "\n",
        "# Ekstrak attention weights\n",
        "attention_weights = attention_weights.numpy().squeeze()  # Shape: (num_heads, seq_len, seq_len)\n",
        "\n",
        "# Visualisasi animasi attention weights\n",
        "fig, ax = plt.subplots(figsize=(6, 6))\n",
        "im = ax.imshow(attention_weights[0], cmap='viridis', interpolation='nearest')\n",
        "ax.set_title(\"Attention Weights (Head 1)\")\n",
        "cbar = fig.colorbar(im)\n",
        "\n",
        "# Fungsi inisialisasi untuk animasi\n",
        "def init():\n",
        "    im.set_data(np.zeros_like(attention_weights[0]))\n",
        "    return [im]\n",
        "\n",
        "# Fungsi update untuk animasi\n",
        "def update(frame):\n",
        "    im.set_data(attention_weights[frame % len(attention_weights)])  # Loop melalui setiap head\n",
        "    ax.set_title(f\"Attention Weights (Head {frame % len(attention_weights) + 1})\")\n",
        "    return [im]\n",
        "\n",
        "# Buat animasi\n",
        "ani = FuncAnimation(fig, update, frames=len(attention_weights) * 3, init_func=init, blit=True, interval=1000)\n",
        "\n",
        "# Simpan animasi sebagai GIF\n",
        "ani.save('transformer_attention.gif', writer='imagemagick', fps=1)\n",
        "\n",
        "# Tampilkan animasi di notebook\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "Q_kUAVYimqJZ",
        "outputId": "21fb372e-0ce1-4934-80c2-ce5b1ddfa331"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (1.26.4)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.25.6)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.5.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.12.2)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.70.0)\n",
            "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n",
            "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.12.1)\n",
            "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.56.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n",
            "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
            "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
            "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.1.31)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (3.0.2)\n",
            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.18.0)\n",
            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Install library\n",
        "!pip install tensorflow matplotlib numpy\n",
        "\n",
        "# Install imagemagick\n",
        "!apt-get update\n",
        "!apt-get install imagemagick\n",
        "\n",
        "# Import library & percobaan MLA\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import MultiHeadAttention, Dense, LayerNormalization\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from matplotlib.animation import FuncAnimation\n",
        "\n",
        "# Simulasi input data\n",
        "sequence_length = 10  # Panjang urutan (misalnya kalimat dengan 10 kata)\n",
        "embedding_dim = 8     # Dimensi embedding (fitur per kata)\n",
        "\n",
        "# Buat input dummy\n",
        "x = tf.random.uniform((1, sequence_length, embedding_dim))  # Batch size 1\n",
        "\n",
        "# Membuat layer MultiHeadAttention\n",
        "multi_head_attention = MultiHeadAttention(num_heads=2, key_dim=embedding_dim)\n",
        "\n",
        "# Forward pass untuk mendapatkan attention weights\n",
        "output, attention_weights = multi_head_attention(x, x, return_attention_scores=True)\n",
        "\n",
        "# Ekstrak attention weights\n",
        "attention_weights = attention_weights.numpy().squeeze()  # Shape: (num_heads, seq_len, seq_len)\n",
        "\n",
        "# Visualisasi animasi attention weights\n",
        "fig, ax = plt.subplots(figsize=(6, 6))\n",
        "im = ax.imshow(attention_weights[0], cmap='viridis', interpolation='nearest')\n",
        "ax.set_title(\"Attention Weights (Head 1)\")\n",
        "cbar = fig.colorbar(im)\n",
        "\n",
        "# Fungsi inisialisasi untuk animasi\n",
        "def init():\n",
        "    im.set_data(np.zeros_like(attention_weights[0]))\n",
        "    return [im]\n",
        "\n",
        "# Fungsi update untuk animasi\n",
        "def update(frame):\n",
        "    im.set_data(attention_weights[frame % len(attention_weights)])  # Loop melalui setiap head\n",
        "    ax.set_title(f\"Attention Weights (Head {frame % len(attention_weights) + 1})\")\n",
        "    return [im]\n",
        "\n",
        "# Konfigurasi matplotlib untuk menggunakan imagemagick\n",
        "import matplotlib\n",
        "matplotlib.rcParams['animation.writer'] = 'imagemagick'\n",
        "\n",
        "# Buat animasi\n",
        "ani = FuncAnimation(fig, update, frames=len(attention_weights) * 3, init_func=init, blit=True, interval=1000)\n",
        "\n",
        "# Simpan animasi sebagai GIF\n",
        "ani.save('transformer_attention.gif', writer='imagemagick', fps=1)\n",
        "\n",
        "# Tampilkan animasi di notebook\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "UTToTsKxnrPp",
        "outputId": "507d4d15-77af-438d-9ba8-23954ef98346"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (1.26.4)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.25.6)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.5.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.12.2)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.70.0)\n",
            "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n",
            "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.12.1)\n",
            "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.56.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n",
            "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
            "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
            "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.1.31)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (3.0.2)\n",
            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.18.0)\n",
            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
            "Get:1 http://security.ubuntu.com/ubuntu jammy-security InRelease [129 kB]\n",
            "Hit:2 https://cloud.r-project.org/bin/linux/ubuntu jammy-cran40/ InRelease\n",
            "Hit:3 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64  InRelease\n",
            "Hit:4 https://ppa.launchpadcontent.net/deadsnakes/ppa/ubuntu jammy InRelease\n",
            "Hit:5 https://ppa.launchpadcontent.net/graphics-drivers/ppa/ubuntu jammy InRelease\n",
            "Hit:6 https://ppa.launchpadcontent.net/ubuntugis/ppa/ubuntu jammy InRelease\n",
            "Hit:7 http://archive.ubuntu.com/ubuntu jammy InRelease\n",
            "Hit:8 http://archive.ubuntu.com/ubuntu jammy-updates InRelease\n",
            "Hit:9 http://archive.ubuntu.com/ubuntu jammy-backports InRelease\n",
            "Hit:10 https://r2u.stat.illinois.edu/ubuntu jammy InRelease\n",
            "Fetched 129 kB in 1s (88.2 kB/s)\n",
            "Reading package lists... Done\n",
            "W: Skipping acquire of configured file 'main/source/Sources' as repository 'https://r2u.stat.illinois.edu/ubuntu jammy InRelease' does not seem to provide it (sources.list entry misspelt?)\n",
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "imagemagick is already the newest version (8:6.9.11.60+dfsg-1.3ubuntu0.22.04.5).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 25 not upgraded.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib\n",
        "print(matplotlib.animation.writers.list())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T1ZOPgF-nzYn",
        "outputId": "3226a021-8648-4f39-d3f5-5b1ba4e02e41"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['pillow', 'ffmpeg', 'ffmpeg_file', 'imagemagick', 'imagemagick_file', 'html']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ani.save('transformer_attention.mp4', writer='ffmpeg', fps=1)"
      ],
      "metadata": {
        "id": "6BPetKhwn36g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!apt-get install ffmpeg"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sn_mjagAn69w",
        "outputId": "d02863fc-fa23-4556-d7c9-317af4ff48b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "ffmpeg is already the newest version (7:4.4.2-0ubuntu0.22.04.1).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 25 not upgraded.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Install library yang diperlukan\n",
        "!pip install tensorflow matplotlib numpy\n",
        "\n",
        "# Install imagemagick\n",
        "!apt-get update\n",
        "!apt-get install imagemagick\n",
        "\n",
        "# Import library\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.layers import MultiHeadAttention, Dense, LayerNormalization\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from matplotlib.animation import FuncAnimation\n",
        "\n",
        "# Simulasi input data\n",
        "sequence_length = 10  # Panjang urutan (misalnya kalimat dengan 10 kata)\n",
        "embedding_dim = 8     # Dimensi embedding (fitur per kata)\n",
        "\n",
        "# Buat input dummy\n",
        "x = tf.random.uniform((1, sequence_length, embedding_dim))  # Batch size 1\n",
        "\n",
        "# Membuat layer MultiHeadAttention\n",
        "multi_head_attention = MultiHeadAttention(num_heads=2, key_dim=embedding_dim)\n",
        "\n",
        "# Forward pass untuk mendapatkan attention weights\n",
        "output, attention_weights = multi_head_attention(x, x, return_attention_scores=True)\n",
        "\n",
        "# Ekstrak attention weights\n",
        "attention_weights = attention_weights.numpy().squeeze()  # Shape: (num_heads, seq_len, seq_len)\n",
        "\n",
        "# Visualisasi animasi attention weights\n",
        "fig, ax = plt.subplots(figsize=(6, 6))\n",
        "im = ax.imshow(attention_weights[0], cmap='viridis', interpolation='nearest')\n",
        "ax.set_title(\"Attention Weights (Head 1)\")\n",
        "cbar = fig.colorbar(im)\n",
        "\n",
        "# Fungsi inisialisasi untuk animasi\n",
        "def init():\n",
        "    im.set_data(np.zeros_like(attention_weights[0]))\n",
        "    return [im]\n",
        "\n",
        "# Fungsi update untuk animasi\n",
        "def update(frame):\n",
        "    im.set_data(attention_weights[frame % len(attention_weights)])  # Loop melalui setiap head\n",
        "    ax.set_title(f\"Attention Weights (Head {frame % len(attention_weights) + 1})\")\n",
        "    return [im]\n",
        "\n",
        "# Konfigurasi matplotlib untuk menggunakan imagemagick\n",
        "import matplotlib\n",
        "matplotlib.rcParams['animation.writer'] = 'imagemagick'\n",
        "\n",
        "# Buat animasi\n",
        "ani = FuncAnimation(fig, update, frames=len(attention_weights) * 3, init_func=init, blit=True, interval=1000)\n",
        "\n",
        "# Simpan animasi sebagai GIF\n",
        "ani.save('transformer_attention.gif', writer='imagemagick', fps=1)\n",
        "\n",
        "# Tampilkan animasi di notebook\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0YPQc8-Qn_BX",
        "outputId": "048f37f2-6490-40ef-d490-0eed4bd27a7f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.11/dist-packages (2.18.0)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (1.26.4)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.4.0)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: flatbuffers>=24.3.25 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (25.2.10)\n",
            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.6.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (18.1.1)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from tensorflow) (24.2)\n",
            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<6.0.0dev,>=3.20.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.25.6)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.32.3)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from tensorflow) (75.1.0)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.5.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (4.12.2)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.17.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (1.70.0)\n",
            "Requirement already satisfied: tensorboard<2.19,>=2.18 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (2.18.0)\n",
            "Requirement already satisfied: keras>=3.5.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.8.0)\n",
            "Requirement already satisfied: h5py>=3.11.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (3.12.1)\n",
            "Requirement already satisfied: ml-dtypes<0.5.0,>=0.4.0 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.4.1)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.11/dist-packages (from tensorflow) (0.37.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.56.0)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (11.1.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.11/dist-packages (from astunparse>=1.6.0->tensorflow) (0.45.1)\n",
            "Requirement already satisfied: rich in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (13.9.4)\n",
            "Requirement already satisfied: namex in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.0.8)\n",
            "Requirement already satisfied: optree in /usr/local/lib/python3.11/dist-packages (from keras>=3.5.0->tensorflow) (0.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2.3.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests<3,>=2.21.0->tensorflow) (2025.1.31)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.7)\n",
            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (0.7.2)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from tensorboard<2.19,>=2.18->tensorflow) (3.1.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.11/dist-packages (from werkzeug>=1.0.1->tensorboard<2.19,>=2.18->tensorflow) (3.0.2)\n",
            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (3.0.0)\n",
            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.11/dist-packages (from rich->keras>=3.5.0->tensorflow) (2.18.0)\n",
            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.11/dist-packages (from markdown-it-py>=2.2.0->rich->keras>=3.5.0->tensorflow) (0.1.2)\n",
            "Get:1 http://security.ubuntu.com/ubuntu jammy-security InRelease [129 kB]\n",
            "Get:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64  InRelease [1,581 B]\n",
            "Hit:3 http://archive.ubuntu.com/ubuntu jammy InRelease\n",
            "Get:4 http://archive.ubuntu.com/ubuntu jammy-updates InRelease [128 kB]\n",
            "Get:5 https://cloud.r-project.org/bin/linux/ubuntu jammy-cran40/ InRelease [3,632 B]\n",
            "Get:6 https://r2u.stat.illinois.edu/ubuntu jammy InRelease [6,555 B]\n",
            "Get:7 http://archive.ubuntu.com/ubuntu jammy-backports InRelease [127 kB]\n",
            "Get:8 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64  Packages [1,317 kB]\n",
            "Hit:9 https://ppa.launchpadcontent.net/deadsnakes/ppa/ubuntu jammy InRelease\n",
            "Hit:10 https://ppa.launchpadcontent.net/graphics-drivers/ppa/ubuntu jammy InRelease\n",
            "Hit:11 https://ppa.launchpadcontent.net/ubuntugis/ppa/ubuntu jammy InRelease\n",
            "Get:12 http://security.ubuntu.com/ubuntu jammy-security/main amd64 Packages [2,610 kB]\n",
            "Get:13 http://security.ubuntu.com/ubuntu jammy-security/universe amd64 Packages [1,230 kB]\n",
            "Get:14 https://r2u.stat.illinois.edu/ubuntu jammy/main amd64 Packages [2,660 kB]\n",
            "Get:15 https://r2u.stat.illinois.edu/ubuntu jammy/main all Packages [8,687 kB]\n",
            "Get:16 http://archive.ubuntu.com/ubuntu jammy-updates/main amd64 Packages [2,939 kB]\n",
            "Get:17 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 Packages [1,526 kB]\n",
            "Get:18 http://archive.ubuntu.com/ubuntu jammy-updates/restricted amd64 Packages [3,793 kB]\n",
            "0% [16 Packages store 0 B]"
          ]
        }
      ]
    }
  ]
}