Sistem Cerdas Klasifikasi Fashion Otomatis Menggunakan Algoritma Convolutional Neural Network

Pernahkah kamu bertanya-tanya bagaimana aplikasi e-commerce bisa mengenali jenis pakaian dari sebuah foto? Jawabannya ada pada Computer Vision dan Deep Learning. Dalam artikel ini, saya akan membagikan pengalaman membangun model Convolutional Neural Network (CNN) untuk mengklasifikasikan gambar artikel pakaian menggunakan dataset Fashion MNIST.

Seluruh kode tersedia di repositori GitHub dan bisa langsung dijalankan di Google Colab.

Apa Itu Fashion MNIST?

Fashion MNIST adalah dataset yang dibuat oleh Zalando Research sebagai pengganti dataset MNIST klasik (angka tulisan tangan). Dataset ini dirancang sebagai benchmark yang lebih menantang untuk algoritma machine learning.

Dataset ini terdiri dari:

• 60.000 gambar pelatihan (training set)
• 10.000 gambar pengujian (test set)
• Setiap gambar berukuran 28×28 piksel dalam format grayscale
• Total 10 kategori kelas pakaian

Berikut adalah 10 kategori yang akan diklasifikasikan:

Persiapan dan Memuat Dataset

Langkah pertama adalah mengimpor library yang dibutuhkan dan memuat dataset Fashion MNIST. Keras sudah menyediakan dataset ini secara built-in, jadi kita bisa memuatnya dengan satu baris kode.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

# Muat dataset Fashion MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()

# Normalisasi gambar ke skala 0-1
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# Reshape data untuk input CNN (menambah dimensi channel tunggal)
x_train = np.expand_dims(x_train, -1)  # Menjadi (60000, 28, 28, 1)
x_test = np.expand_dims(x_test, -1)    # Menjadi (10000, 28, 28, 1)

Proses normalisasi penting dilakukan agar nilai piksel berada pada rentang 0–1, yang membantu model belajar lebih efisien. Selain itu, kita perlu menambahkan dimensi channel karena CNN membutuhkan input 4D: (batch, height, width, channels).

Berikut tampilan beberapa contoh gambar dari dataset:

Arsitektur Model CNN

Model CNN yang dibangun menggunakan arsitektur sekuensial dengan lapisan-lapisan berikut:

Input (28, 28, 1)
    │
    ├── Conv2D (32 filter, 3×3, ReLU)
    ├── MaxPooling2D (2×2)
    ├── Conv2D (64 filter, 3×3, ReLU)
    ├── MaxPooling2D (2×2)
    ├── Flatten
    ├── Dropout (0.5)
    └── Dense (10 unit, Softmax)

Mari kita bedah setiap lapisan:

• Conv2D (32 filter) — Lapisan konvolusi pertama mengekstrak fitur dasar seperti tepi dan tekstur dari gambar input.
• MaxPooling2D — Mengurangi dimensi spasial, mempertahankan fitur penting sambil mengurangi komputasi.
• Conv2D (64 filter) — Lapisan konvolusi kedua mengekstrak fitur yang lebih kompleks dan abstrak.
• Flatten — Meratakan output 2D dari lapisan konvolusi menjadi vektor 1D untuk lapisan fully connected.
• Dropout (0.5) — Teknik regularisasi yang secara acak menonaktifkan 50% neuron selama pelatihan untuk mencegah overfitting.
• Dense (10, Softmax) — Lapisan output dengan 10 unit sesuai jumlah kelas, menggunakan aktivasi Softmax untuk menghasilkan probabilitas prediksi.

Implementasinya dalam kode:

model = keras.Sequential(
    [
        keras.Input(shape=(28, 28, 1)),
        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Flatten(),
        layers.Dropout(0.5),
        layers.Dense(10, activation="softmax"),
    ]
)

Melatih Model

Model dikompilasi menggunakan konfigurasi berikut:

• Loss function: sparse_categorical_crossentropy — cocok untuk klasifikasi multi-kelas dengan label integer.
• Optimizer: adam — optimizer adaptif yang populer dan efisien.
• Metrics: accuracy — metrik akurasi untuk memantau performa.

model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer="adam",
    metrics=["accuracy"]
)

history = model.fit(
    x_train, y_train,
    batch_size=128,
    epochs=5,
    validation_split=0.1
)

Model dilatih selama 5 epoch dengan batch size 128 dan validation split 10% (6.000 gambar digunakan untuk validasi). Berikut visualisasi proses pelatihan:

Grafik di atas menunjukkan bahwa akurasi pelatihan dan validasi meningkat setiap epoch, sementara loss menurun — menandakan model belajar dengan baik tanpa overfitting yang signifikan.

Evaluasi dan Prediksi

Setelah pelatihan selesai, model dievaluasi menggunakan data pengujian (10.000 gambar yang belum pernah dilihat model sebelumnya):

score = model.evaluate(x_test, y_test, verbose=0)
print(f"Test loss: {score[0]:.4f}")
print(f"Test accuracy: {score[1]:.4f}")

Berikut hasil prediksi model pada beberapa gambar pengujian. Warna biru menandakan prediksi benar, sedangkan merah menandakan prediksi salah:

Hasil di atas menunjukkan bahwa model mampu mengklasifikasikan berbagai jenis pakaian dengan tingkat keyakinan (confidence) yang tinggi.

Uji dengan Gambar Sendiri

Salah satu fitur menarik dari notebook ini adalah kemampuan mengunggah gambar sendiri untuk diprediksi. Gambar yang diunggah akan diproses melalui langkah-langkah berikut:

1. Konversi ke grayscale — Menyesuaikan format gambar dengan dataset.
2. Resize ke 28×28 piksel — Menyesuaikan dimensi input model.
3. Normalisasi — Menskalakan nilai piksel ke rentang 0–1.
4. Prediksi — Model menghasilkan probabilitas untuk setiap kelas.

from google.colab import files
from PIL import Image
import cv2

uploaded = files.upload()

# Proses gambar yang diunggah
img = Image.open(io.BytesIO(uploaded[uploaded_image_name]))
img = img.convert('L')         # Konversi ke grayscale
img = img.resize((28, 28))     # Resize ke 28x28

img_array = np.array(img, dtype="float32") / 255.0
processed_image = np.expand_dims(np.expand_dims(img_array, 0), -1)

# Prediksi
prediction = model.predict(processed_image)
predicted_class = np.argmax(prediction[0])
confidence = np.max(prediction[0])

Teknologi yang Digunakan

Cara Menjalankan

Google Colab (Direkomendasikan)

Cara paling mudah adalah menggunakan Google Colab — cukup klik badge di atas atau buka link berikut:

Buka di Google Colab →

Lingkungan Lokal

# Clone repositori
git clone https://github.com/achmadhadikurnia/klasifikasi-fashion-menggunakan-cnn.git
cd klasifikasi-fashion-menggunakan-cnn

# Instal dependensi
pip install tensorflow numpy matplotlib pillow opencv-python

# Jalankan notebook
jupyter notebook Klasifikasi_Fashion_Menggunakan_CNN.ipynb

Catatan: Fitur unggah gambar pada bagian akhir notebook menggunakan google.colab.files.upload(), sehingga hanya berfungsi di Google Colab. Untuk penggunaan lokal, bagian tersebut perlu dimodifikasi.

Kesimpulan

Dengan model CNN sederhana yang terdiri dari dua lapisan konvolusi, kita sudah mampu mengklasifikasikan gambar pakaian dari dataset Fashion MNIST dengan akurasi yang baik. Proyek ini mendemonstrasikan bahwa deep learning, khususnya CNN, sangat efektif untuk tugas klasifikasi gambar — bahkan dengan arsitektur yang relatif sederhana.

Beberapa ide pengembangan lanjutan:

• Menambah epoch untuk meningkatkan akurasi
• Data augmentation seperti rotasi, flip, dan zoom untuk memperkaya data pelatihan
• Arsitektur lebih dalam seperti menambahkan lapisan konvolusi tambahan atau menggunakan arsitektur populer seperti ResNet atau VGG
• Transfer learning menggunakan model pre-trained untuk performa yang lebih baik

Kode sumber lengkap tersedia di GitHub. Silakan fork, modifikasi, dan bereksperimen! ⭐