Membuat Model CNN untuk Prediksi

Artiel ini akan menjelaskan bagaimana cara membuat model CNN untuk prediksi diabetes tipe 2 dari gambar lidah.

Dataset yang digunakan berasal dari Mandeley
https://data.mendeley.com/datasets/hyb44jf936/2
Dataset ini berlisensi CC BY 4.0
Lisensi ini memberikan kebebasan yang luas kepada pengguna untuk:
Penggunaan Komersial (Commercial Use): Anda boleh menggunakan dataset untuk tujuan komersial.
Berbagi (Share/Copy): Anda boleh menyalin dan mendistribusikan dataset dalam media atau format apa pun.
Adaptasi (Adapt/Modify): Anda boleh meremix, mengubah, dan membangun karya baru berdasarkan dataset tersebut.

Dengan catatan memberikan atribusi kepada pembuat.

Berikut adalah kerangka langkah-langkah dalam Python, menggunakan library TensorFlow dan Keras, untuk membangun, melatih, dan mengevaluasi model klasifikasi CNN yang memprediksi apakah gambar lidah menunjukkan kondisi Diabetes atau Non-Diabetes.

---

🏗️ 1. Persiapan Lingkungan dan Data

Langkah pertama adalah mengimpor library yang diperlukan dan menyiapkan data Anda menggunakan struktur direktori yang sudah ada (train, valid, test).

A. Impor Library

Python

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
import matplotlib.pyplot as plt

B. Path ke Data

Tentukan path dasar tempat folder train, valid, dan test berada.

Python

# Ganti dengan path folder utama Anda
base_dir = '/path/to/folder/gambar_lidah' 
train_dir = base_dir + '/train'
validation_dir = base_dir + '/valid'
test_dir = base_dir + '/test'

C. Data Augmentation dan Generator

Data Augmentation penting untuk meningkatkan jumlah variasi data pelatihan (dengan memutar, membalik, atau mengubah skala gambar) dan mencegah overfitting. ImageDataGenerator Keras akan memuat dan memproses gambar secara batch.

Python

# Parameter global
IMAGE_SIZE = (150, 150) # Ukuran gambar yang akan diubah ukurannya
BATCH_SIZE = 32

# 1. Generator Data Pelatihan (dengan Augmentation)
train_datagen = ImageDataGenerator(
    rescale=1./255, # Normalisasi piksel ke [0, 1]
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest'
)

# 2. Generator Data Validasi dan Uji (hanya Rescaling)
validation_test_datagen = ImageDataGenerator(rescale=1./255)

# Membuat Generator dari Direktori
train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=IMAGE_SIZE,
    batch_size=BATCH_SIZE,
    class_mode='binary' # Klasifikasi biner: diabetes atau non_diabetes
)

validation_generator = validation_test_datagen.flow_from_directory(
    validation_dir,
    target_size=IMAGE_SIZE,
    batch_size=BATCH_SIZE,
    class_mode='binary'
)

test_generator = validation_test_datagen.flow_from_directory(
    test_dir,
    target_size=IMAGE_SIZE,
    batch_size=BATCH_SIZE,
    class_mode='binary',
    shuffle=False # Penting untuk evaluasi dan prediksi
)

# Output class_indices: {'diabetes': 0, 'non_diabetes': 1} atau sebaliknya
print("Mapping Kelas:", train_generator.class_indices)

---

🧱 2. Pembangunan Model CNN

Kita akan membuat model CNN sequential sederhana yang terdiri dari lapisan Konvolusi dan Pooling untuk mengekstrak fitur, diikuti oleh lapisan Dense untuk klasifikasi.

Python

model = Sequential([
    # Lapisan 1: Konvolusi & Pooling
    Conv2D(32, (3, 3), activation='relu', input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3)),
    MaxPooling2D((2, 2)),
    
    # Lapisan 2: Konvolusi & Pooling
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    
    # Lapisan 3: Konvolusi & Pooling
    Conv2D(128, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    
    # Flattening: Mengubah output 3D menjadi 1D
    Flatten(),
    
    # Dropout (untuk mencegah overfitting)
    Dropout(0.5), 
    
    # Lapisan Fully Connected (Hidden Layer)
    Dense(512, activation='relu'),
    
    # Lapisan Output (1 neuron untuk klasifikasi biner)
    Dense(1, activation='sigmoid') # Sigmoid untuk klasifikasi biner (0 atau 1)
])

# Kompilasi Model
model.compile(
    optimizer='adam',
    loss='binary_crossentropy', # Fungsi kerugian untuk klasifikasi biner
    metrics=['accuracy']
)

# Tampilkan Ringkasan Model
model.summary()

---

🏃 3. Pelatihan Model

Kita akan melatih model menggunakan data pelatihan dan memvalidasinya pada data validasi.

Python

EPOCHS = 20 # Jumlah epoch (dapat disesuaikan)

history = model.fit(
    train_generator,
    steps_per_epoch=train_generator.samples // BATCH_SIZE, # Jumlah langkah per epoch
    epochs=EPOCHS,
    validation_data=validation_generator,
    validation_steps=validation_generator.samples // BATCH_SIZE
)

---

📈 4. Evaluasi dan Prediksi

Setelah model dilatih, kita akan mengevaluasinya menggunakan set data test yang independen.

A. Evaluasi Akurasi

Python

print("Evaluasi pada Data Test...")
loss, accuracy = model.evaluate(test_generator, steps=test_generator.samples // BATCH_SIZE)
print(f"Akurasi Test: {accuracy*100:.2f}%")
print(f"Loss Test: {loss:.4f}")

B. Visualisasi Hasil Pelatihan

Visualisasi loss dan accuracy selama pelatihan sangat membantu untuk mendiagnosis overfitting atau underfitting.

Python

# Plot hasil pelatihan
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs_range = range(EPOCHS)

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()

C. Prediksi Gambar Baru

Untuk memprediksi kelas gambar baru:

Python

import numpy as np
from tensorflow.keras.preprocessing import image

def predict_single_image(img_path):
    # Muat gambar
    img = image.load_img(img_path, target_size=IMAGE_SIZE)
    # Ubah menjadi array dan normalisasi
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0) # Tambah dimensi batch
    img_array /= 255.0

    # Lakukan prediksi
    prediction = model.predict(img_array)[0][0]
    
    # Ambil label kelas dari generator
    class_labels = list(train_generator.class_indices.keys())
    
    if prediction >= 0.5:
        # Asumsikan 'non_diabetes' adalah 1 (jika class_indices = {'diabetes': 0, 'non_diabetes': 1})
        result = class_labels[1] 
        confidence = prediction
    else:
        # Asumsikan 'diabetes' adalah 0
        result = class_labels[0]
        confidence = 1 - prediction

    print(f"Prediksi: {result} ({confidence*100:.2f}% Confident)")

# Contoh penggunaan (ganti dengan path gambar lidah baru)
# predict_single_image('/path/to/new/lidah_unknown.jpg') 

Tentu saja! Model yang telah dilatih (trained model) dapat dan harus disimpan (diserialisasi) agar dapat digunakan kembali di masa depan, baik untuk prediksi (inferensi) maupun untuk melanjutkan pelatihan. Proses ini adalah langkah krusial dalam setiap proyek Machine Learning.

---

💾 Proses Menyimpan dan Memuat Model Keras/TensorFlow

Ada dua metode utama untuk menyimpan model dalam konteks Keras/TensorFlow.

1. Menyimpan Seluruh Model (Direktori/Format HDF5)

Ini adalah cara yang paling umum dan direkomendasikan karena menyimpan semuanya:

• Arsitektur model (lapisan-lapisan, parameter).
• Bobot yang telah dipelajari (weights).
• Konfigurasi pelatihan (loss, optimizer).

A. Menyimpan Model

Setelah Anda selesai melatih model Anda (model.fit(...)), Anda dapat menyimpannya:

Python

# Menyimpan seluruh model ke dalam format Keras
model.save('cnn_lidah_diabetes.keras') 

Atau, menggunakan format HDF5 yang lebih lama:

Python

model.save('cnn_lidah_diabetes.h5')

B. Memuat Model

Model yang disimpan dapat dimuat kembali ke dalam memori kapan saja untuk digunakan:

Python

from tensorflow.keras.models import load_model

# Memuat model
loaded_model = load_model('cnn_lidah_diabetes.keras')

# Ringkasan model yang dimuat akan sama
loaded_model.summary()

2. Menyimpan Hanya Bobot (Checkpoints)

Metode ini hanya menyimpan bobot (weights) model. Ini berguna jika Anda sering menyimpan model selama pelatihan (checkpointing) atau jika Anda hanya ingin menyimpan bobotnya saja untuk digunakan pada model dengan arsitektur yang sama.

A. Menyimpan Bobot

Python

# Menyimpan hanya bobot model
model.save_weights('cnn_lidah_diabetes_weights.h5')

B. Memuat Bobot

Untuk memuat bobot, Anda harus terlebih dahulu mendefinisikan kembali arsitektur model yang sama persis, dan kemudian memuat bobot ke dalamnya:

Python

# 1. Definisikan kembali arsitektur model (kode dari langkah 2 di respons sebelumnya)
# ... (contoh: model = Sequential([ ... ])) ...

# 2. Muat bobot yang disimpan
model.load_weights('cnn_lidah_diabetes_weights.h5')

---

🛠️ Penggunaan Model yang Disimpan

Setelah model dimuat, Anda dapat menggunakannya untuk berbagai tujuan:

Tujuan	Metode	Penjelasan
Prediksi/Inferensi	loaded_model.predict(new_data)	Mengklasifikasikan gambar lidah diabetes baru tanpa perlu melatih ulang model.
Melanjutkan Pelatihan	loaded_model.fit(...)	Jika Anda mendapatkan lebih banyak data pelatihan, Anda dapat melanjutkan pelatihan model dari titik di mana ia terakhir disimpan.
Transfer Learning	Menggunakan arsitektur atau bobot sebagai dasar untuk melatih model baru pada tugas yang sedikit berbeda.

Kesimpulan: Ya, model yang dilatih sepenuhnya portabel, dapat disimpan dengan fungsi .save(), dan dimuat kembali dengan load_model() untuk digunakan kapan saja, tanpa perlu melatih dari awal lagi.