TugasAkhirFaiq_ML_klasifikasi_Gambar.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/FaiqAminuddin/ml/blob/main/TugasAkhirFaiq_ML_klasifikasi_Gambar.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gWvfGSZQLPap"
      },
      "source": [
        "# Proyek Klasifikasi Gambar: Animals\n",
        "- **Nama:** Faiq Aminuddin\n",
        "- **Email:** faiq.aminuddin.demak@gmail.com\n",
        "- **ID Dicoding:** faiqaminuddin"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PLPcg6nKWLkG"
      },
      "source": [
        "## Import Semua Packages/Library yang Digunakan"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "collapsed": true,
        "id": "mM2GGHmF6MQx"
      },
      "outputs": [],
      "source": [
        "# Import library yang diperlukan\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "import zipfile\n",
        "import os\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w_0KC7acWhXJ"
      },
      "source": [
        "## Data Preparation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9sSLXmnqWrW3"
      },
      "source": [
        "### Data Loading"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "vYMLXh9VgK3E"
      },
      "outputs": [],
      "source": [
        "\"\"\"\n",
        "versi 1\n",
        "! pip install kaggle\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "! mkdir ~/.kaggle\n",
        "! cp /content/drive/MyDrive/kaggle.json ~/.kaggle/\n",
        "! chmod 600 ~/.kaggle/kaggle.json\n",
        "\"\"\"\n",
        "#menghubungkan dengan Kaggle versi 2 (pakai key dan user name)\n",
        "!pip install -q kaggle\n",
        "os.environ[\"KAGGLE_KEY\"] ='cccdae8f025910c3006efc8880f868d0'\n",
        "os.environ[\"KAAGLE_USERNAME\"] = 'faiqaminuddin'\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w1UZyF9I7IiE",
        "outputId": "5b6512f6-8ed7-4982-918b-9e937e79d7a2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset URL: https://www.kaggle.com/datasets/borhanitrash/animal-image-classification-dataset\n",
            "License(s): MIT\n",
            "Downloading animal-image-classification-dataset.zip to /content\n",
            " 73% 28.0M/38.4M [00:00<00:00, 87.8MB/s]\n",
            "100% 38.4M/38.4M [00:00<00:00, 85.8MB/s]\n"
          ]
        }
      ],
      "source": [
        "# Download dataset\n",
        "! kaggle datasets download -d borhanitrash/animal-image-classification-dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "knoC-XV67A_D"
      },
      "outputs": [],
      "source": [
        "# Ekstrak file zip\n",
        "with zipfile.ZipFile('animal-image-classification-dataset.zip', 'r') as zip_ref:\n",
        "    zip_ref.extractall('animals')\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JO0svKkuE0FO",
        "outputId": "073a01d6-8152-4a51-9d4c-59229b600f3c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['snakes', 'cats', 'dogs']\n"
          ]
        }
      ],
      "source": [
        "# Path untuk dataset\n",
        "base_dir = 'animals/Animals'\n",
        "# Cek struktur direktori untuk memastikan path yang benar\n",
        "print(os.listdir(base_dir))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50lbvKM7WBPq"
      },
      "source": [
        "### Data Preprocessing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NnHtmTabXJqs"
      },
      "source": [
        "#### Split Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "JpDpQIIx7pPq"
      },
      "outputs": [],
      "source": [
        "# ImageDataGenerator untuk augmentasi dan preprocessing\n",
        "train_datagen = ImageDataGenerator(\n",
        "    rescale=1./255,\n",
        "    rotation_range=20,\n",
        "    width_shift_range=0.2,\n",
        "    height_shift_range=0.2,\n",
        "    shear_range=0.2,\n",
        "    zoom_range=0.2,\n",
        "    horizontal_flip=True,\n",
        "    fill_mode='nearest',\n",
        "    validation_split=0.2 # Set validation split to 20%\n",
        ")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nb_NX7HD8QGn",
        "outputId": "d045c0d4-987c-4986-95e5-ac17ed3ffc49"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 2400 images belonging to 3 classes.\n",
            "Found 600 images belonging to 3 classes.\n"
          ]
        }
      ],
      "source": [
        "# Data generator untuk training dan validation set\n",
        "train_generator = train_datagen.flow_from_directory(\n",
        "    base_dir,\n",
        "    target_size=(150, 150),\n",
        "    batch_size=32,\n",
        "    class_mode='categorical',\n",
        "    subset='training' # Set sebagai training data\n",
        ")\n",
        "\n",
        "validation_generator = train_datagen.flow_from_directory(\n",
        "    base_dir,\n",
        "    target_size=(150, 150),\n",
        "    batch_size=32,\n",
        "    class_mode='categorical',\n",
        "    subset='validation' # Set sebagai validation data\n",
        ")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GEZIahhLXPXh"
      },
      "source": [
        "## Modelling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VZWDXRaz8ftC",
        "outputId": "83c6fafe-005e-4091-95bc-f8cb228a0783"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/layers/convolutional/base_conv.py:107: 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__(activity_regularizer=activity_regularizer, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "# Membuat model Sequential\n",
        "model = Sequential([\n",
        "    Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),\n",
        "    MaxPooling2D((2, 2)),\n",
        "    Conv2D(64, (3, 3), activation='relu'),\n",
        "    MaxPooling2D((2, 2)),\n",
        "    Conv2D(128, (3, 3), activation='relu'),\n",
        "    MaxPooling2D((2, 2)),\n",
        "    Flatten(),\n",
        "    Dense(512, activation='relu'),\n",
        "    Dropout(0.5),\n",
        "    Dense(3, activation='softmax') # 3 kelas: kucing, ular, anjing\n",
        "])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "k468eyirFnhd"
      },
      "outputs": [],
      "source": [
        "# Compile model\n",
        "model.compile(loss='categorical_crossentropy',\n",
        "              optimizer=Adam(),\n",
        "              metrics=['accuracy'])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "6fl2oNpCahx_",
        "outputId": "e4d6a4e4-0a67-480f-8520-505c21bff621"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/50\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.\n",
            "  self._warn_if_super_not_called()\n"
          ]
        }
      ],
      "source": [
        "# Melatih model\n",
        "model.fit(\n",
        "      train_generator,\n",
        "      steps_per_epoch=25,  # 25 batch  pada setiap epoch\n",
        "      epochs=50, # tambahkan epochs jika akurasi model belum optimal\n",
        "      validation_data=validation_generator, # menampilkan akurasi pengujian data validasi\n",
        "      validation_steps=5,  # 5 batch dieksekusi pada setiap epoch\n",
        "      verbose=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v-CStIfuXiqE"
      },
      "source": [
        "## Evaluasi dan Visualisasi"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "yyEhO1VqFwvo"
      },
      "outputs": [],
      "source": [
        "# Evaluasi model\n",
        "scores = model.evaluate(validation_generator, verbose=1)\n",
        "print(f\"Validation Accuracy: {scores[1]*100:.2f}%\")\n",
        "\n",
        "# Akurasi minimum 85%\n",
        "if scores[1] >= 0.85:\n",
        "    print(\"Model memenuhi kriteria dengan akurasi di atas 85%.\")\n",
        "else:\n",
        "    print(\"Model belum memenuhi kriteria dengan akurasi di bawah 85%.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "Psjw06mtxM6v"
      },
      "outputs": [],
      "source": [
        "# Evaluate model\n",
        "train_loss, train_acc = model.evaluate(x_train, y_train, verbose=2)\n",
        "val_loss, val_acc = model.evaluate(x_val, y_val, verbose=2)\n",
        "test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)\n",
        "\n",
        "print(f'Training Accuracy: {train_acc}')\n",
        "print(f'Validation Accuracy: {val_acc}')\n",
        "print(f'Test Accuracy: {test_acc}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "EHOXZxumuYZG"
      },
      "outputs": [],
      "source": [
        "# Plot accuracy and loss\n",
        "plt.figure(figsize=(12, 4))\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(history.history['accuracy'], label='Accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(history.history['loss'], label='Loss')\n",
        "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZdicqpwXrPT"
      },
      "source": [
        "## Konversi Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "JX0EM7rguaci"
      },
      "outputs": [],
      "source": [
        "# Save model in SavedModel format\n",
        "model.save('model_saved/')\n",
        "\n",
        "# Convert model to TensorFlow Lite format\n",
        "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
        "tflite_model = converter.convert()\n",
        "with open('model.tflite', 'wb') as f:\n",
        "    f.write(tflite_model)\n",
        "\n",
        "# Convert model to TensorFlow.js format\n",
        "import tensorflowjs as tfjs\n",
        "tfjs.converters.save_keras_model(model, 'model_tfjs/')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W9PurAMbX2-k"
      },
      "source": [
        "## Inference (Optional)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "MG53p7-SMZjL"
      },
      "outputs": [],
      "source": [
        "# Import library yang diperlukan\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from google.colab import files\n",
        "from tensorflow.keras.preprocessing import image\n",
        "\n",
        "# Fungsi untuk memproses dan memprediksi gambar yang diunggah\n",
        "def upload_and_predict(model):\n",
        "    # Unggah gambar\n",
        "    uploaded = files.upload()\n",
        "    for fn in uploaded.keys():\n",
        "        # Load dan proses gambar\n",
        "        img_path = fn\n",
        "        img = image.load_img(img_path, target_size=(150, 150))\n",
        "        img_array = image.img_to_array(img)\n",
        "        img_array = np.expand_dims(img_array, axis=0)\n",
        "        img_array /= 255.0  # Normalisasi\n",
        "\n",
        "        # Prediksi gambar\n",
        "        predictions = model.predict(img_array)\n",
        "        predicted_class = np.argmax(predictions[0])\n",
        "\n",
        "        # Mapping kelas\n",
        "        class_labels = ['cats', 'dogs', 'snakes']\n",
        "\n",
        "        # Tampilkan hasil prediksi\n",
        "        print(f\"Prediction for {fn}: {class_labels[predicted_class]}\")\n",
        "        plt.imshow(img)\n",
        "        plt.title(f\"Prediction: {class_labels[predicted_class]}\")\n",
        "        plt.axis('off')\n",
        "        plt.show()\n",
        "\n",
        "# Panggil fungsi untuk mengunggah dan memprediksi gambar\n",
        "upload_and_predict(model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "aoiqP3qeX7Ba"
      },
      "outputs": [],
      "source": [
        " pip freeze requirements.txt"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}