EcoQuest/Assets/mnet_1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f8f04f6-045f-40ce-a3bd-07ea72478e43",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import tensorflow as tf\n",
    "import zipfile\n",
    "import numpy as np\n",
    "import shutil\n",
    "from glob import glob\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator, img_to_array, load_img, save_img\n",
    "from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout\n",
    "from tensorflow.keras.regularizers import l2\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n",
    "from tensorflow.keras.applications.mobilenet_v2 import preprocess_input\n",
    "from scipy.ndimage import rotate\n",
    "from skimage.exposure import adjust_gamma\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix, classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "71840f0b-ae56-436a-9065-925d3fd860d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------------------------------------\n",
    "# 1) Ekstrak dataset (jika belum ada folder 'dataset')\n",
    "# -------------------------------------------------\n",
    "dataset_path = 'C:/Users/FIKRI/Documents/Model/dataset.zip'\n",
    "extract_path = 'C:/Users/FIKRI/Documents/Model'\n",
    "\n",
    "if not os.path.exists(os.path.join(extract_path, 'dataset')):\n",
    "    with zipfile.ZipFile(dataset_path, 'r') as zip_ref:\n",
    "        zip_ref.extractall(extract_path)\n",
    "\n",
    "# Pastikan kita punya 3 folder kelas di:\n",
    "# [path]/dataset/anorganik\n",
    "# [path]/dataset/organik\n",
    "# [path]/dataset/bukansampah"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "91294283-684c-4294-ba11-94921326e0a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jumlah gambar di kelas anorganik: 889\n",
      "Jumlah gambar di kelas bukansampah: 3008\n",
      "Jumlah gambar di kelas organik: 345\n"
     ]
    }
   ],
   "source": [
    "dataset_dir = os.path.join(extract_path, 'dataset')\n",
    "classes = ['anorganik', 'bukansampah', 'organik']\n",
    "\n",
    "# Cek jumlah data asli di setiap kelas\n",
    "for cls in classes:\n",
    "    class_path = os.path.join(dataset_dir, cls)\n",
    "    num_images = len(os.listdir(class_path))\n",
    "    print(f\"Jumlah gambar di kelas {cls}: {num_images}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "486d3551-f716-4504-aa9d-75abb753ec82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------------------------------------\n",
    "# 2) Split data asli menjadi train & val (80:20)\n",
    "#    tanpa augmentasi apa pun\n",
    "# -------------------------------------------------\n",
    "split_dir = os.path.join(extract_path, 'splitted_data')\n",
    "train_original_dir = os.path.join(split_dir, 'train_original')\n",
    "val_original_dir   = os.path.join(split_dir, 'val_original')\n",
    "\n",
    "# Buat folder jika belum ada\n",
    "os.makedirs(train_original_dir, exist_ok=True)\n",
    "os.makedirs(val_original_dir, exist_ok=True)\n",
    "for cls in classes:\n",
    "    os.makedirs(os.path.join(train_original_dir, cls), exist_ok=True)\n",
    "    os.makedirs(os.path.join(val_original_dir, cls), exist_ok=True)\n",
    "\n",
    "# Lakukan split data\n",
    "for cls in classes:\n",
    "    input_class_dir = os.path.join(dataset_dir, cls)\n",
    "    images = os.listdir(input_class_dir)\n",
    "\n",
    "    # Split 80:20\n",
    "    train_imgs, val_imgs = train_test_split(images, test_size=0.2, random_state=42)\n",
    "\n",
    "    # Copy ke folder train_original\n",
    "    for img_name in train_imgs:\n",
    "        src = os.path.join(input_class_dir, img_name)\n",
    "        dst = os.path.join(train_original_dir, cls, img_name)\n",
    "        shutil.copy(src, dst)\n",
    "\n",
    "    # Copy ke folder val_original\n",
    "    for img_name in val_imgs:\n",
    "        src = os.path.join(input_class_dir, img_name)\n",
    "        dst = os.path.join(val_original_dir, cls, img_name)\n",
    "        shutil.copy(src, dst)\n",
    "\n",
    "print(\"Split data asli -> train_original & val_original selesai.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99c776a4-48e7-4df4-8715-e2bec5c7b19f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------------------------------------\n",
    "# 3) Augmentasi hanya untuk data train\n",
    "#    (val dibiarkan apa adanya)\n",
    "# -------------------------------------------------\n",
    "\n",
    "# Folder output augmentasi train\n",
    "aug_train_dir = os.path.join(split_dir, 'train_aug')\n",
    "os.makedirs(aug_train_dir, exist_ok=True)\n",
    "for cls in classes:\n",
    "    os.makedirs(os.path.join(aug_train_dir, cls), exist_ok=True)\n",
    "\n",
    "# Fungsi rotasi\n",
    "def custom_rotation(img_array, rotation_angles):\n",
    "    augmented_images = []\n",
    "    for angle in rotation_angles:\n",
    "        # rotate dari scipy.ndimage\n",
    "        augmented_img = rotate(img_array, angle, reshape=False, mode='constant', cval=0)\n",
    "        augmented_img = np.clip(augmented_img, 0, 255).astype('uint8')\n",
    "        augmented_images.append(augmented_img)\n",
    "    return augmented_images\n",
    "\n",
    "# Fungsi mengatur kontras\n",
    "def adjust_contrast(img_array, gamma):\n",
    "    # adjust_gamma dari skimage.exposure\n",
    "    augmented_img = adjust_gamma(img_array, gamma=gamma)\n",
    "    augmented_img = np.clip(augmented_img, 0, 255).astype('uint8')\n",
    "    return augmented_img\n",
    "\n",
    "# Fungsi augmentasi lainnya (ImageDataGenerator)\n",
    "def apply_other_augmentations(img_array, datagen, num_augmented_images=1):\n",
    "    # Tambah dimensi batch\n",
    "    img_array = img_array.reshape((1,) + img_array.shape)\n",
    "    augmented_images = []\n",
    "    for _ in range(num_augmented_images):\n",
    "        augmented_img = next(datagen.flow(img_array, batch_size=1))[0]\n",
    "        augmented_img = np.clip(augmented_img, 0, 255).astype('uint8')\n",
    "        augmented_images.append(augmented_img)\n",
    "    return augmented_images\n",
    "\n",
    "# Definisikan ImageDataGenerator khusus untuk masing-masing kelas (opsional)\n",
    "datagen_anorganik = ImageDataGenerator(\n",
    "    width_shift_range=0.1,\n",
    "    height_shift_range=0.1,\n",
    "    zoom_range=0.2,\n",
    "    horizontal_flip=True,\n",
    "    vertical_flip=True,\n",
    "    fill_mode='constant'\n",
    ")\n",
    "\n",
    "datagen_organik = ImageDataGenerator(\n",
    "    width_shift_range=0.1,\n",
    "    height_shift_range=0.1,\n",
    "    shear_range=0.1,\n",
    "    brightness_range=(0.2, 1.0),\n",
    "    zoom_range=[0.8, 0.4],\n",
    "    horizontal_flip=True,\n",
    "    vertical_flip=True,\n",
    "    fill_mode='constant'\n",
    ")\n",
    "\n",
    "datagen_bukansampah = ImageDataGenerator(\n",
    "    rotation_range=10,\n",
    "    brightness_range=(0.9, 1.1),\n",
    "    horizontal_flip=True,\n",
    "    vertical_flip=True,\n",
    "    fill_mode='constant'\n",
    ")\n",
    "\n",
    "# Parameter augmentasi\n",
    "rotation_angles = [-20, 20, -30, 30]\n",
    "gamma_values = [0.5, 1.2]\n",
    "target_size = (600, 800)  # Ukuran resize saat augmentasi\n",
    "num_aug = 2               # Berapa kali augmentasi (ImageDataGenerator) per rotasi\n",
    "\n",
    "# Loop per kelas untuk augmentasi\n",
    "for cls in classes:\n",
    "    input_path = os.path.join(train_original_dir, cls)  # folder train_original\n",
    "    output_path = os.path.join(aug_train_dir, cls)      # folder train_aug\n",
    "\n",
    "    images = os.listdir(input_path)\n",
    "\n",
    "    # Pilih generator sesuai kelas\n",
    "    if cls == \"anorganik\":\n",
    "        datagen = datagen_anorganik\n",
    "    elif cls == \"organik\":\n",
    "        datagen = datagen_organik\n",
    "    else:\n",
    "        datagen = datagen_bukansampah\n",
    "\n",
    "    for img_file in images:\n",
    "        img_path = os.path.join(input_path, img_file)\n",
    "        img = load_img(img_path, target_size=target_size)\n",
    "        img_array = img_to_array(img)\n",
    "\n",
    "        # Augmentasi rotasi manual\n",
    "        rotated_images = custom_rotation(img_array, rotation_angles)\n",
    "\n",
    "        # Kumpulkan semua augmented\n",
    "        all_augmented_images = []\n",
    "        for rotated_img in rotated_images:\n",
    "            # Augmentasi pakai ImageDataGenerator\n",
    "            augmented_images = apply_other_augmentations(rotated_img, datagen, num_aug)\n",
    "            all_augmented_images.extend(augmented_images)\n",
    "\n",
    "            # Tambahkan variasi kontras\n",
    "            for gamma in gamma_values:\n",
    "                contrast_img = adjust_contrast(rotated_img, gamma)\n",
    "                all_augmented_images.append(contrast_img)\n",
    "\n",
    "        # Simpan hasil augmentasi\n",
    "        # Juga simpan original image agar train mencakup gambar aslinya\n",
    "        # (Jika mau menyimpan aslinya di folder augmented, boleh juga)\n",
    "        # save_img(os.path.join(output_path, img_file), img_array.astype('uint8'))\n",
    "\n",
    "        # Untuk menjaga agar data augmented tidak meledak jumlahnya,\n",
    "        # kita bisa batasi sesuai kebutuhan. Di sini disimpan semua:\n",
    "        for i, augmented_img in enumerate(all_augmented_images):\n",
    "            save_path = os.path.join(output_path, f'{cls}_{img_file.split(\".\")[0]}_aug_{i+1}.jpg')\n",
    "            save_img(save_path, augmented_img)\n",
    "\n",
    "print(\"Augmentasi train selesai.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99ac457f-8891-4d4d-ac3b-5b0eb9eb7058",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------------------------------------\n",
    "# 4) Siapkan folder final train & val\n",
    "#    (Kita akan gabung: data original train + data augmented)\n",
    "# -------------------------------------------------\n",
    "final_train_dir = os.path.join(extract_path, 'train_data')\n",
    "final_val_dir   = os.path.join(extract_path, 'val_data')\n",
    "\n",
    "# Bersihkan folder jika sudah ada\n",
    "if os.path.exists(final_train_dir):\n",
    "    shutil.rmtree(final_train_dir)\n",
    "if os.path.exists(final_val_dir):\n",
    "    shutil.rmtree(final_val_dir)\n",
    "\n",
    "os.makedirs(final_train_dir, exist_ok=True)\n",
    "os.makedirs(final_val_dir, exist_ok=True)\n",
    "\n",
    "for cls in classes:\n",
    "    os.makedirs(os.path.join(final_train_dir, cls), exist_ok=True)\n",
    "    os.makedirs(os.path.join(final_val_dir, cls), exist_ok=True)\n",
    "\n",
    "# Copy data original train ke final_train_dir\n",
    "for cls in classes:\n",
    "    src_path = os.path.join(train_original_dir, cls)\n",
    "    dst_path = os.path.join(final_train_dir, cls)\n",
    "    for img_file in os.listdir(src_path):\n",
    "        shutil.copy(os.path.join(src_path, img_file), os.path.join(dst_path, img_file))\n",
    "\n",
    "# Copy data augmented train ke final_train_dir\n",
    "for cls in classes:\n",
    "    src_path = os.path.join(aug_train_dir, cls)\n",
    "    dst_path = os.path.join(final_train_dir, cls)\n",
    "    for img_file in os.listdir(src_path):\n",
    "        shutil.copy(os.path.join(src_path, img_file), os.path.join(dst_path, img_file))\n",
    "\n",
    "# Copy data val_original ke final_val_dir\n",
    "for cls in classes:\n",
    "    src_path = os.path.join(val_original_dir, cls)\n",
    "    dst_path = os.path.join(final_val_dir, cls)\n",
    "    for img_file in os.listdir(src_path):\n",
    "        shutil.copy(os.path.join(src_path, img_file), os.path.join(dst_path, img_file))\n",
    "\n",
    "print(\"Folder train_data dan val_data siap (gabungan original + augmented).\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "40354bb4-20e0-4310-8310-eef8d79c6d2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "final_train_dir = os.path.join(extract_path, 'train_data')\n",
    "final_val_dir   = os.path.join(extract_path, 'val_data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c66b99c0-53c3-40fe-950c-d2dbc1aca76e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 29300 images belonging to 3 classes.\n",
      "Found 843 images belonging to 3 classes.\n"
     ]
    }
   ],
   "source": [
    "# -------------------------------------------------\n",
    "# 5) Buat ImageDataGenerator untuk training & validasi\n",
    "# -------------------------------------------------\n",
    "train_datagen = ImageDataGenerator(\n",
    "    preprocessing_function=preprocess_input\n",
    ")\n",
    "val_datagen = ImageDataGenerator(\n",
    "    preprocessing_function=preprocess_input\n",
    ")\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "    final_train_dir,\n",
    "    target_size=(224, 224),\n",
    "    batch_size=32,\n",
    "    class_mode='categorical',\n",
    "    shuffle=True\n",
    ")\n",
    "\n",
    "val_generator = val_datagen.flow_from_directory(\n",
    "    final_val_dir,\n",
    "    target_size=(224, 224),\n",
    "    batch_size=32,\n",
    "    class_mode='categorical',\n",
    "    shuffle=False\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e7b6f9ff-43ab-4298-a101-66df72881472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " mobilenetv2_1.00_224 (Funct  (None, 7, 7, 1280)       2257984   \n",
      " ional)                                                          \n",
      "                                                                 \n",
      " global_average_pooling2d (G  (None, 1280)             0         \n",
      " lobalAveragePooling2D)                                          \n",
      "                                                                 \n",
      " dense (Dense)               (None, 256)               327936    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 128)               32896     \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 3)                 387       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2,619,203\n",
      "Trainable params: 1,567,299\n",
      "Non-trainable params: 1,051,904\n",
      "_________________________________________________________________\n",
      "Class Indices (Train): {'anorganik': 0, 'bukansampah': 1, 'organik': 2}\n"
     ]
    }
   ],
   "source": [
    "# -------------------------------------------------\n",
    "# 6) Definisikan Model (MobileNetV2 + Fine-Tuning)\n",
    "# -------------------------------------------------\n",
    "base_model = tf.keras.applications.MobileNetV2(\n",
    "    input_shape=(224, 224, 3),\n",
    "    include_top=False,\n",
    "    weights='imagenet'\n",
    ")\n",
    "\n",
    "# Fine-tuning: freeze layer kecuali 20 terakhir\n",
    "base_model.trainable = True\n",
    "for layer in base_model.layers[:-20]:\n",
    "    layer.trainable = False\n",
    "\n",
    "model = Sequential([\n",
    "    base_model,\n",
    "    GlobalAveragePooling2D(),\n",
    "    Dense(256, activation='relu'),\n",
    "    #Dropout(0.4),\n",
    "    Dense(128, activation='relu'),\n",
    "    #Dropout(0.4),\n",
    "    Dense(3, activation='softmax')\n",
    "])\n",
    "\n",
    "# Kompilasi model\n",
    "model.compile(\n",
    "    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),\n",
    "    loss='categorical_crossentropy',\n",
    "    metrics=['accuracy']\n",
    ")\n",
    "\n",
    "model.summary()\n",
    "print(\"Class Indices (Train):\", train_generator.class_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "60374dfc-8dde-4789-ba8a-d9c1c6887272",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "916/916 [==============================] - 113s 117ms/step - loss: 0.1232 - accuracy: 0.9707 - val_loss: 0.0257 - val_accuracy: 0.9905 - lr: 1.0000e-05\n",
      "Epoch 2/10\n",
      "916/916 [==============================] - 91s 99ms/step - loss: 0.0136 - accuracy: 0.9967 - val_loss: 0.0048 - val_accuracy: 1.0000 - lr: 1.0000e-05\n",
      "Epoch 3/10\n",
      "916/916 [==============================] - 98s 106ms/step - loss: 0.0058 - accuracy: 0.9990 - val_loss: 0.0027 - val_accuracy: 1.0000 - lr: 1.0000e-05\n",
      "Epoch 4/10\n",
      "916/916 [==============================] - 103s 113ms/step - loss: 0.0025 - accuracy: 0.9997 - val_loss: 0.0030 - val_accuracy: 0.9988 - lr: 1.0000e-05\n",
      "Epoch 5/10\n",
      "916/916 [==============================] - 95s 104ms/step - loss: 0.0018 - accuracy: 0.9997 - val_loss: 0.0025 - val_accuracy: 0.9988 - lr: 1.0000e-05\n",
      "Epoch 6/10\n",
      "916/916 [==============================] - 92s 101ms/step - loss: 0.0016 - accuracy: 0.9996 - val_loss: 0.0017 - val_accuracy: 1.0000 - lr: 1.0000e-05\n",
      "Epoch 7/10\n",
      "916/916 [==============================] - 92s 100ms/step - loss: 8.7582e-04 - accuracy: 1.0000 - val_loss: 0.0019 - val_accuracy: 1.0000 - lr: 1.0000e-05\n",
      "Epoch 8/10\n",
      "916/916 [==============================] - 92s 100ms/step - loss: 6.9067e-04 - accuracy: 0.9999 - val_loss: 0.0023 - val_accuracy: 1.0000 - lr: 1.0000e-05\n",
      "Epoch 9/10\n",
      "916/916 [==============================] - 92s 101ms/step - loss: 5.1801e-04 - accuracy: 0.9999 - val_loss: 0.0019 - val_accuracy: 1.0000 - lr: 2.0000e-06\n",
      "Epoch 10/10\n",
      "916/916 [==============================] - 92s 100ms/step - loss: 2.4760e-04 - accuracy: 1.0000 - val_loss: 0.0018 - val_accuracy: 1.0000 - lr: 2.0000e-06\n"
     ]
    }
   ],
   "source": [
    "# -------------------------------------------------\n",
    "# 7) Training\n",
    "# -------------------------------------------------\n",
    "callbacks = [\n",
    "    EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True),\n",
    "    ModelCheckpoint('model_test.h5', save_best_only=True),\n",
    "    ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=2, min_lr=1e-6)\n",
    "]\n",
    "\n",
    "history = model.fit(\n",
    "    train_generator,\n",
    "    epochs=10,\n",
    "    validation_data=val_generator,\n",
    "    callbacks=callbacks\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2237bfbd-872c-420d-99ab-33cc1149fc50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27/27 [==============================] - 4s 161ms/step - loss: 0.0018 - accuracy: 1.0000\n",
      "Akurasi pada data validasi: 1.00\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27/27 [==============================] - 5s 154ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "   anorganik       1.00      1.00      1.00       178\n",
      " bukansampah       1.00      1.00      1.00       602\n",
      "     organik       1.00      1.00      1.00        63\n",
      "\n",
      "    accuracy                           1.00       843\n",
      "   macro avg       1.00      1.00      1.00       843\n",
      "weighted avg       1.00      1.00      1.00       843\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# -------------------------------------------------\n",
    "# 8) Evaluasi Model & Confusion Matrix\n",
    "# -------------------------------------------------\n",
    "loss, accuracy = model.evaluate(val_generator)\n",
    "print(f\"Akurasi pada data validasi: {accuracy:.2f}\")\n",
    "\n",
    "# Plot Akurasi\n",
    "plt.figure()\n",
    "plt.plot(history.history['accuracy'], label='Training Accuracy')\n",
    "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.title('Training vs Validation Accuracy')\n",
    "plt.show()\n",
    "\n",
    "# Plot Loss\n",
    "plt.figure()\n",
    "plt.plot(history.history['loss'], label='Training Loss')\n",
    "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "plt.title('Training vs Validation Loss')\n",
    "plt.show()\n",
    "\n",
    "# Confusion Matrix\n",
    "Y_pred = model.predict(val_generator, steps=val_generator.samples // val_generator.batch_size + 1)\n",
    "y_pred = np.argmax(Y_pred, axis=1)\n",
    "y_true = val_generator.classes\n",
    "\n",
    "cm = confusion_matrix(y_true, y_pred)\n",
    "plt.figure(figsize=(6, 5))\n",
    "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\",\n",
    "            xticklabels=list(val_generator.class_indices.keys()),\n",
    "            yticklabels=list(val_generator.class_indices.keys()))\n",
    "plt.xlabel(\"Prediksi\")\n",
    "plt.ylabel(\"Asli\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n",
    "\n",
    "# Classification Report\n",
    "print(\"\\nClassification Report:\")\n",
    "print(classification_report(y_true, y_pred, target_names=val_generator.class_indices.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc41ecb1-39fd-40b7-a1c2-6ce531fc4b40",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------------------------------------\n",
    "# 9) Konversi model ke .onnx\n",
    "# -------------------------------------------------\n",
    "import tf2onnx\n",
    "onnx_model_path = \"mobilenetv2.onnx\"\n",
    "spec = (tf.TensorSpec((None, 224, 224, 3), tf.float32, name=\"input\"),)\n",
    "onnx_model, _ = tf2onnx.convert.from_keras(model, input_signature=spec, opset=13)\n",
    "with open(onnx_model_path, \"wb\") as f:\n",
    "    f.write(onnx_model.SerializeToString())\n",
    "\n",
    "print(f\"Model berhasil dikonversi ke ONNX: {onnx_model_path}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a882142-7198-4cff-a479-31c832696d41",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}