Persiapan

Pada materi ini, kita akan melakukan tahap persiapan data (data preprocessing tahap awal). Kamu akan belajar cara mengunduh dataset mentah, memahami strukturnya, membersihkan struktur tersebut, dan menyiapkannya untuk lingkungan pengembangan berbasis cloud.

Langkah 1 : Download Dataset

Langkah pertama adalah mendapatkan materi mentah kita. Kita menggunakan dataset publik yang tersedia di Kaggle karena dataset ini sudah terlabel dengan baik (gambar gunting di folder gunting, dst).

1. Buka browser kamu dan kunjungi url berikut: Kaggle Dataset: Rock Paper Scissors
2. Cari tombol Download (biasanya berada di pojok kanan atas bagian header dataset).
3. Jika belum login, kamu akan diminta masuk ke akun Kaggle.
4. Simpan file archive.zip ke komputer lokal kamu.

Langkah 2: Extract File archive.zip

Setelah file terunduh, kita perlu melihat isinya. Seringkali, dataset publik memiliki struktur folder yang bertingkat atau redundan (berulang) yang bisa membingungkan script pemrograman nantinya.

1. Klik kanan pada file archive.zip yang baru diunduh.
2. Pilih Extract Here atau Extract to folder.
3. Buka folder hasil ekstraksi tersebut.

Kamu akan melihat struktur direktori seperti di bawah ini:

Langkah 3: Seleksi dan Re-Zip

Pada langkah ini, kita akan melakukan cleaning manual. Kita hanya membutuhkan folder yang berisi data gambar untuk ketiga kelas: Gunting, Batu, dan Kertas.

1. Masuk ke dalam folder hasil ekstraksi tadi.
2. Cek folder rock, paper, dan scissors. Pastikan folder tersebut berisi gambar-gambar yang sesuai.
3. Seleksi (Block) ketiga folder tersebut saja (rock, paper, scissors).
4. Klik kanan pada seleksi tersebut, lalu pilih compress tiga folder itu.
5. Beri nama file baru tersebut, misalnya: dataset.zip.

Langkah 4: Upload ke Google Drive

Langkah terakhir upload dataset.zip ke google drive.

Google Drive menjadi cara paling mudah untuk menyimpan dataset. Jika kamu upload langsung ke sesi Colab, data akan hilang saat sesi berakhir (disconnect).

Google Colab

Langkah 1: Membuka Google Colab dan Membuat Notebook Baru

1. Buka browser dan buka link ini: Google Colab.
2. Pada jendela pop-up "Open notebook". Klik tombol New Notebook di pojok kiri bawah.
3. Setelah notebook terbuka, klik pada bagian judul di pojok kiri atas (biasanya bernama Untitled0.ipynb) dan ubah namanya menjadi RPS-Model.ipynb.

Langkah 2: Mengaktifkan T4 GPU

Secara default, Google Colab menggunakan CPU. Untuk kasus Deep Learning yang melibatkan pengolahan ribuan gambar, CPU akan sangat lambat. Kita perlu mengubahnya ke GPU.

1. Di menu bagian atas, klik Runtime.
2. Pilih Change runtime type.
3. Akan muncul jendela konfigurasi. Pada bagian Hardware accelerator, ubah opsi dari None (atau CPU) menjadi T4 GPU.
4. Klik Save.

Langkah 3: Melakukan Mounting Google Drive

Google Colab merupakan mesin virtual yang sementara. Saat kamu menutup tab browser, file yang tersimpan di penyimpanan Colab akan hilang.

Oleh karena itu, kita perlu menghubungkan ("mount") Google Drive kita agar Colab bisa membaca dataset yang sudah kita siapkan sebelemnya.

1. Klik pada menu samping ada icon folder
2. Lalu nanti akan muncul icon google drive (Mount Drive) dibagian atas
3. Klik icon tersebut dan pilih akun google yang sama dengan yang notebook saat ini dan juga akun dimana file dataset.zip kamu simpan

Tunggu sebentar. Jika proses berhasil, daftar file di panel samping refresh otomatis dan folder baru bernama drive akan muncul. Jika kamu membuka folder drive > MyDrive, kamu seharusnya bisa melihat file-file Google Drive kamu, termasuk dataset yang sudah diunggah sebelumnya.

Cari file bernama dataset.zip, klik menu titik tiga di sampingnya, lalu pilih Copy Path.

Membuat Model MobileNetV3-Small

Import

import os
import keras
import zipfile
import tensorflow as tf
import tensorflow_datasets as tfds

from tensorflow.keras.applications import MobileNetV3Small
from tensorflow.keras.applications.mobilenet_v3 import preprocess_input

• os: Modul bawaan Python untuk berinteraksi dengan sistem operasi. Biasanya digunakan untuk mengatur manajemen file, seperti membuat folder baru, mengecek lokasi direktori, atau menggabungkan path file.
• keras: High-level API untuk membangun dan melatih model Deep Learning. Keras didesain agar mudah dibaca dan digunakan oleh manusia (user-friendly).
• zipfile: Modul bawaan Python untuk mengelola file arsip ZIP. Ini berguna jika dataset kamu masih dalam bentuk terkompresi (.zip) dan perlu diekstrak melalui kode.
• tensorflow (tf): Framework utama (core library) buatan Google untuk komputasi numerik dan Machine Learning. Ini adalah package utama yang menangani operasi matematika kompleks (tensor).
• tensorflow_datasets (tfds): Package tambahan yang menyediakan koleksi dataset siap pakai (seperti MNIST, Cats vs Dogs, dll.) yang sudah terstandarisasi, sehingga mudah diunduh dan langsung digunakan untuk latihan model.
• MobileNetV3Small: Arsitektur model Convolutional Neural Network (CNN) yang sudah dilatih sebelumnya (pre-trained). Varian "Small" ini dioptimalkan agar sangat ringan dan cepat, khusus untuk perangkat dengan sumber daya terbatas (seperti HP atau IoT).
• preprocess_input: Fungsi utilitas khusus untuk mengubah data gambar mentah (misalnya mengubah rentang nilai pixel) agar sesuai dengan format spesifik yang diharapkan oleh model MobileNetV3 sebelum proses training atau prediksi dimulai.

Version

tf.__version__

keras.__version__

Delete folder

data_dir = "dataset"

!rm -rf {data_dir}

Unzip

file_zip = "PATH FILE YANG KAMU COPY SEBELUMNYA"

zipfile.ZipFile(file_zip, "r").extractall(data_dir)

Kode ini berfungsi untuk mengekstrak seluruh isi file arsip (ZIP) ke dalam folder tujuan yang telah ditentukan. Pertama, variabel file_zip menyimpan lokasi path file yang akan diproses, lalu fungsi zipfile.ZipFile membuka file tersebut dalam mode baca ("r"), dan perintah .extractall(data_dir) langsung extract semua file / folder di dalamnya ke direktori data_dir.

Labels

labels = []
for dirname in os.listdir(data_dir):
    if os.path.isdir(os.path.join(data_dir, dirname)):
        labels.append(dirname)

labels.sort()

LABELS_TENSOR = tf.constant(labels)

Check Total File

total_files = 0
for label in labels:
  path = os.path.join(data_dir, label)
  files = 0
  for root, dirnames, filenames in os.walk(path):
    print("Folder Name : ", label)
    files += len(filenames)

  total_files += files
  print("Total Files : ", files)
  print("----------------------------")

Constanta

IMAGE_SIZE = (150, 150)
BATCH_SIZE = 32
DATA_SIZE = total_files
VALIDATION_RATIO = 0.2
VALIDATION_SIZE = int(VALIDATION_RATIO * DATA_SIZE)
AUTOTUNE = tf.data.AUTOTUNE

Helpers

def get_label(file_path):
  parts = tf.strings.split(file_path, os.path.sep)

  return parts[-2]

def process_path(file_path):
  img = tf.io.read_file(file_path)
  img = tf.image.decode_png(img, channels=3)
  img = tf.image.resize(img, IMAGE_SIZE)

  img = preprocess_input(img)

  label_str = get_label(file_path)
  label = tf.argmax(tf.cast(tf.equal(LABELS_TENSOR, label_str), tf.int32))
  label = tf.one_hot(label, depth=len(labels))

  return img, label

Persiapan Data

list_ds = tf.data.Dataset.list_files(os.path.join(data_dir, "*/*"), shuffle=True)

list_ds = list_ds.shuffle(buffer_size=1000, seed=42)

val_list_ds = list_ds.take(VALIDATION_SIZE)
train_list_ds = list_ds.skip(VALIDATION_SIZE)

val_labeled_ds = val_list_ds.map(process_path, num_parallel_calls=AUTOTUNE)
train_labeled_ds = train_list_ds.map(process_path, num_parallel_calls=AUTOTUNE)

Membagi data train dan validation

train_ds = train_labeled_ds.shuffle(buffer_size=total_files).batch(BATCH_SIZE).prefetch(buffer_size=AUTOTUNE)
val_ds = val_labeled_ds.cache().batch(BATCH_SIZE).repeat().prefetch(buffer_size=AUTOTUNE)

Base Model

base_model = MobileNetV3Small(input_shape=(150, 150, 3), include_top=False)
base_model.trainable = False

Augmentation

data_augmentation = tf.keras.Sequential([
  tf.keras.layers.RandomFlip("horizontal_and_vertical"),
  tf.keras.layers.RandomRotation(0.2),
  tf.keras.layers.RandomZoom(0.2),
])

Model

model =  tf.keras.models.Sequential([
    data_augmentation,
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(3, activation='softmax')
])

model.summary()

model.compile(loss='categorical_crossentropy',
              optimizer=tf.optimizers.Adam(learning_rate=0.001),
              metrics=['accuracy'])

early_stopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)

Train Model

history = model.fit(
    train_ds,
    epochs = 20,
    validation_data = val_ds,
    validation_steps = 5,
    verbose = 2,
    callbacks = [early_stopping])

Save Model

model.save('RPS.keras')

Selesai

Silahkan download file RPS.keras nya dan simpan di drive