final-testing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import tensorflow as tf\n",
    "\n",
    "from PIL import Image\n",
    "from numpy import asarray\n",
    "\n",
    "from tensorflow import keras\n",
    "from keras.utils import np_utils\n",
    "from tensorflow.keras import datasets,layers, models"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CONNECT DENGAN DIRECTORY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_dir = \"blobs.rect\"\n",
    "latih =  \"latih\"\n",
    "validasi = \"validasi\"\n",
    "!ls \"D:\\TUGAS\\Kuliah\\Semester8\\SourcesCode\\SimulasiCNN\\blobs.rect\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bahan_dir = os.path.join(base_dir)\n",
    "train_dir = os.path.join(latih)\n",
    "valid_dir = os.path.join(validasi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradeA_dir = os.path.join(bahan_dir, 'gradeA/')\n",
    "gradeB_dir = os.path.join(bahan_dir, 'gradeB/')\n",
    "gradeC_dir = os.path.join(bahan_dir, 'gradeC/')\n",
    "\n",
    "print(\"Jumlah data tiap kelas\")\n",
    "print(\"Jumlah gambar grade  A : \", len(os.listdir(gradeA_dir)))\n",
    "print(\"Jumlah gambar grade  B : \", len(os.listdir(gradeB_dir)))\n",
    "print(\"Jumlah gambar grade  C : \", len(os.listdir(gradeC_dir)))\n",
    "print(\"Total dataset : \", len(os.listdir(gradeA_dir)) + len(os.listdir(gradeB_dir)) + len(os.listdir(gradeC_dir)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# direktori isi latih/training\n",
    "train_gradeA = os.path.join(train_dir, 'gradeA/')\n",
    "train_gradeB = os.path.join(train_dir, 'gradeB/')\n",
    "train_gradeC = os.path.join(train_dir, 'gradeC/')\n",
    "\n",
    "# direktori isi validasi\n",
    "valid_gradeA = os.path.join(valid_dir, 'gradeA/')\n",
    "valid_gradeB = os.path.join(valid_dir, 'gradeB/')\n",
    "valid_gradeC = os.path.join(valid_dir, 'gradeC/')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MEMBAGI DATASET MENJADI DATA TRAINING DAN DATA VALIDATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from shutil import copyfile\n",
    "\n",
    "def train_val_split(source, train, val, train_ratio):\n",
    "  total_size = len(os.listdir(source))\n",
    "  train_size = int(train_ratio * total_size)\n",
    "  val_size = total_size - train_size\n",
    "\n",
    "  randomized  = random.sample(os.listdir(source), total_size)\n",
    "  train_files = randomized[0:train_size]\n",
    "  val_files   = randomized[train_size:total_size]\n",
    "\n",
    "  for i in train_files:\n",
    "    i_file = source + i\n",
    "    destination = train + i\n",
    "    copyfile(i_file, destination)\n",
    "\n",
    "  for i in val_files:\n",
    "    i_file = source + i\n",
    "    destination = val + i\n",
    "    copyfile(i_file, destination)\n",
    "\n",
    "# jumlah pembagian data training dan testing\n",
    "train_ratio = 0.9\n",
    "\n",
    "#pembagian training dan validasi \n",
    "#gradeA\n",
    "source_00 = gradeA_dir\n",
    "train_00  = train_gradeA\n",
    "val_00    = valid_gradeA\n",
    "train_val_split(source_00, train_00, val_00, train_ratio)\n",
    "\n",
    "#gradeB\n",
    "source_01 = gradeB_dir\n",
    "train_01  = train_gradeB\n",
    "val_01    = valid_gradeB\n",
    "train_val_split(source_01, train_01, val_01, train_ratio)\n",
    "\n",
    "#gradeC\n",
    "source_02 = gradeC_dir\n",
    "train_02  = train_gradeC\n",
    "val_02    = valid_gradeC\n",
    "train_val_split(source_02, train_02, val_02, train_ratio)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Jumlah all grade A   : \", len(os.listdir(gradeA_dir)))\n",
    "print(\"Jumlah train grade A : \", len(os.listdir(train_gradeA)))\n",
    "print(\"Jumlah val grade A   : \", len(os.listdir(valid_gradeA)))\n",
    "\n",
    "print(\"\\nJumlah all grade B   : \", len(os.listdir(gradeB_dir)))\n",
    "print(\"Jumlah train grade B : \", len(os.listdir(train_gradeB)))\n",
    "print(\"Jumlah val grade B   : \", len(os.listdir(valid_gradeB)))\n",
    "\n",
    "print(\"\\nJumlah all grade C   : \", len(os.listdir(gradeC_dir)))\n",
    "print(\"Jumlah train grade C : \", len(os.listdir(train_gradeC)))\n",
    "print(\"Jumlah val grade C   : \", len(os.listdir(valid_gradeC)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MOBILENET V2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "train_datagen       = ImageDataGenerator(\n",
    "    rescale         = 1./255,\n",
    "    rotation_range  = 30,\n",
    "    horizontal_flip = True,\n",
    "    shear_range     = 0.3,\n",
    "    fill_mode       = 'nearest',\n",
    ")\n",
    "\n",
    "val_datagen = ImageDataGenerator(\n",
    "    rescale         = 1./255,\n",
    "    rotation_range  = 30,\n",
    "    horizontal_flip = True,\n",
    "    shear_range     = 0.3,\n",
    "    fill_mode       = 'nearest',\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMG_SIZE = (128,128)\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "# train_dir = os.path.join(base_dir, 'latih')\n",
    "# validation_dir = os.path.join(base_dir, 'validasi')\n",
    "\n",
    "# train_dataset = tf.keras.utils.image_dataset_from_directory(train_dir, shuffle=True, batch_size=BATCH_SIZE, image_size=IMG_SIZE, class_mode= 'categorical')\n",
    "# validation_dataset = tf.keras.utils.image_dataset_from_directory(validation_dir, shuffle=True, batch_size=BATCH_SIZE, image_size=IMG_SIZE, class_mode= 'categorical')\n",
    "\n",
    "train_dataset = train_datagen.flow_from_directory(\n",
    "    train_dir,\n",
    "    target_size = IMG_SIZE,\n",
    "    batch_size = BATCH_SIZE,\n",
    "    class_mode = 'categorical',\n",
    "    color_mode = 'rgb'\n",
    ")\n",
    "valid_dataset = val_datagen.flow_from_directory(\n",
    "    valid_dir,\n",
    "    target_size = IMG_SIZE,\n",
    "    batch_size = BATCH_SIZE,\n",
    "    class_mode = 'categorical',\n",
    "    color_mode = 'rgb'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMG_SHAPE = IMG_SIZE + (3,)\n",
    "MobileNetV2 = tf.keras.applications.MobileNetV2(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')\n",
    "\n",
    "for layer in MobileNetV2.layers:\n",
    "    MobileNetV2.trainable = False"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "UJI COBA CUSTOM MODEL KE-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = MobileNetV2.output\n",
    "x = tf.keras.layers.GlobalAveragePooling2D()(x)\n",
    "x = tf.keras.layers.Dropout(0.2)(x)\n",
    "output = tf.keras.layers.Dense(3, activation='softmax')(x)\n",
    "modelku = tf.keras.Model(inputs=MobileNetV2.input, outputs = output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "modelku.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_learning_rate = 0.0001\n",
    "modelku.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=base_learning_rate),\n",
    "                loss=\"categorical_crossentropy\",\n",
    "                metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "modelku.fit(train_dataset, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}