Panduan Praktis Klasifikasi Gambar dengan TensorFlow dan Keras

Klasifikasi gambar adalah salah satu cabang penting dari computer vision yang memungkinkan komputer untuk “melihat” dan mengidentifikasi objek dalam gambar. Dalam panduan praktis ini, kita akan menjelajahi cara membangun model klasifikasi gambar menggunakan dua library deep learning populer, yaitu TensorFlow dan Keras. Tutorial ini dirancang untuk pemula dengan pemahaman dasar tentang machine learning dan Python. Kita akan fokus pada kata kunci seperti “klasifikasi gambar TensorFlow”, “klasifikasi gambar Keras”, “tutorial klasifikasi gambar”, “CNN TensorFlow Keras”, dan “model klasifikasi gambar”.

Apa itu Klasifikasi Gambar, TensorFlow, dan Keras?

Klasifikasi gambar adalah proses memberikan label atau kategori pada sebuah gambar berdasarkan konten visualnya. Misalnya, mengklasifikasikan gambar sebagai “kucing”, “anjing”, atau “mobil”. Ini adalah tugas yang mudah bagi manusia, tetapi cukup menantang bagi komputer.

TensorFlow dan Keras adalah dua library yang sangat membantu dalam membangun model deep learning, termasuk untuk deep learning klasifikasi gambar. TensorFlow adalah platform open-source untuk machine learning yang dikembangkan oleh Google. Keras adalah API tingkat tinggi yang berjalan di atas TensorFlow (dan backend lainnya), yang menyediakan antarmuka yang lebih sederhana dan intuitif untuk membangun model neural network.

Convolutional Neural Network (CNN) adalah jenis arsitektur neural network yang sangat efektif untuk tugas-tugas klasifikasi gambar. CNN dirancang untuk secara otomatis dan adaptif mempelajari hierarki fitur spasial dari gambar. Ini berbeda dari pendekatan tradisional yang memerlukan rekayasa fitur manual.

Baca juga: Panduan Lengkap Convolutional Neural Networks (CNN) untuk Pemula

Persiapan Lingkungan Pengembangan

Sebelum memulai, pastikan Anda telah menginstal TensorFlow dan Keras. Anda dapat menginstalnya menggunakan pip, package installer untuk Python:

pip install tensorflow
pip install keras

Selain TensorFlow dan Keras, kita juga akan menggunakan beberapa library Python lainnya:

• NumPy: Untuk manipulasi array multidimensi.
• Matplotlib: Untuk visualisasi data.

Instal library tersebut dengan perintah:

pip install numpy matplotlib

Untuk kemudahan dan akses ke sumber daya komputasi yang lebih baik, sangat disarankan untuk menggunakan Google Colab. Colab adalah lingkungan notebook Jupyter yang berjalan di cloud dan menyediakan akses gratis ke GPU. Ini sangat berguna untuk melatih model CNN, yang seringkali membutuhkan daya komputasi yang besar. Untuk menggunakan colab anda cukup akses google colab, kemudian buat notebook baru. Cara melatih model CNN di google colab sama dengan jika anda membuat dan melatih model di lokal komputer anda.

Memuat dan Mempersiapkan Data CIFAR-10

Untuk tutorial ini, kita akan menggunakan dataset CIFAR-10. CIFAR-10 terdiri dari 60.000 gambar berwarna 32×32 yang dibagi menjadi 10 kelas. Ini adalah dataset yang umum digunakan.

Memuat Dataset CIFAR-10

Kita dapat dengan mudah memuat dataset CIFAR-10 menggunakan Keras:

# Import library yang dibutuhkan
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

# Memuat dataset CIFAR-10
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

# Menampilkan informasi dataset
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

Kode di atas mengunduh dataset CIFAR-10 dan memuatnya ke dalam variabel. `x_train` dan `x_test` berisi data gambar, sedangkan `y_train` dan `y_test` berisi label kelas.

Preprocessing Data CIFAR-10

Sebelum kita menggunakan data untuk melatih model, kita perlu melakukan preprocessing:

Normalisasi:

Nilai piksel gambar berada dalam rentang 0-255. Kita perlu menormalisasikannya.

# Normalisasi data gambar ke rentang 0-1
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

One-hot Encoding:

Label kelas saat ini berupa bilangan bulat 0-9. Kita perlu mengubahnya menjadi vektor one-hot.

# Mengubah label kelas menjadi vektor one-hot
num_classes = 10
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

Membagi Data

Membagi dataset penting untuk pelatihan dan evaluasi, dataset dibagi menjadi 3:

• Data Latih: Melatih model.
• Data Validasi: Memantau performa dan mencegah overfitting.
• Data Uji: Mengevaluasi performa akhir.

Contoh pembagian data train dan validasi:

# Membagi data latih menjadi data latih dan validasi
from sklearn.model_selection import train_test_split

x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.2, random_state=42)

print('x_train shape:', x_train.shape)
print('x_val shape:', x_val.shape)
print('x_test shape:', x_test.shape)

Membangun Model CNN

Kita akan membangun model CNN dengan Keras Sequential API.

Membuat Model Sequential

# Membuat model Sequential
model = keras.Sequential()

Layer Konvolusi (Conv2D)

Layer konvolusi adalah inti CNN. Layer ini mengekstrak fitur. Parameternya:

• Filters: Jumlah filter.
• Kernel_size: Ukuran filter.
• Activation: Fungsi aktivasi (ReLU).
• Padding: “same” atau “valid”.

# Menambahkan layer konvolusi pertama
model.add(keras.layers.Conv2D(32, (3, 3), padding='same',
                 activation='relu',
                 input_shape=x_train.shape[1:]))

Layer Pooling (MaxPooling2D)

Layer pooling mengurangi dimensi. MaxPooling2D paling umum.

# Menambahkan layer max pooling
model.add(keras.layers.MaxPooling2D(pool_size=(2, 2)))

Baca juga: Pooling Layer CNN Pengertian, Fungsi, dan Jenisnya

Layer Flatten

Layer Flatten mengubah output konvolusi menjadi vektor 1D.

# Menambahkan layer flatten
model.add(keras.layers.Flatten())

Layer Dense (Fully Connected)

Layer Dense adalah layer neural network standar.

# menambahkan layer dense
model.add(keras.layers.Dense(512, activation='relu'))

Layer Dense terakhir (softmax) 10 unit, sesuai jumlah kelas:

# Menambahkan layer output
model.add(keras.layers.Dense(num_classes, activation='softmax'))

Arsitektur Model CNN Lengkap

model = keras.Sequential([
    keras.layers.Conv2D(32, (3, 3), padding='same',
                 activation='relu',
                 input_shape=x_train.shape[1:]),
    keras.layers.Conv2D(32, (3, 3), activation='relu'),
    keras.layers.MaxPooling2D(pool_size=(2, 2)),
    keras.layers.Dropout(0.25), #menambahkan dropout

    keras.layers.Conv2D(64, (3, 3), padding='same',
                 activation='relu'),
    keras.layers.Conv2D(64, (3, 3), activation='relu'),
    keras.layers.MaxPooling2D(pool_size=(2, 2)),
    keras.layers.Dropout(0.25), # Menambahkan dropout

    keras.layers.Flatten(),
    keras.layers.Dense(512, activation='relu'),
    keras.layers.Dropout(0.5), # Menambahkan dropout
    keras.layers.Dense(num_classes, activation='softmax')
])

Kompilasi Model

Sebelum melatih, model perlu dikompilasi dengan optimizer, loss function, dan metrik.

Optimizer

Optimizer memperbarui bobot model. Adam adalah pilihan yang baik.

Loss Function

Loss function mengukur prediksi model. Gunakan categorical cross-entropy.

Metrik Evaluasi

Metrik untuk memantau performa. Akurasi adalah metrik umum.

# Kompilasi model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

Melatih Model

Latih model dengan metode `fit()`:

# Melatih model
batch_size = 32
epochs = 10

history = model.fit(x_train, y_train,
                    batch_size=batch_size,
                    epochs=epochs,
                    validation_data=(x_val, y_val), # Menggunakan validation data
                    shuffle=True)

Parameter `fit()`:

• Batch_size: Sampel per iterasi.
• Epochs: Berapa kali seluruh dataset dilewati.
• Validation_data: Data validasi.
• Shuffle: Acak data sebelum tiap epoch.

Evaluasi dan Visualisasi Hasil

Evaluasi model dengan data uji:

# Evaluasi model
scores = model.evaluate(x_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])

Visualisasikan loss dan akurasi dengan Matplotlib:

# Membuat plot loss
plt.figure(0)
plt.plot(history.history['loss'], label='training loss')
plt.plot(history.history['val_loss'], label='val loss')
plt.title('Loss')
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend()
plt.show()

# Membuat plot akurasi
plt.figure(1)
plt.plot(history.history['accuracy'], label='training accuracy')
plt.plot(history.history['val_accuracy'], label='val accuracy')
plt.title('Accuracy')
plt.xlabel('epochs')
plt.ylabel('accuracy')
plt.legend()
plt.show()

Prediksi dengan Model

Gunakan model untuk prediksi kelas gambar baru:

# Prediksi kelas untuk beberapa gambar
predictions = model.predict(x_test[:10]) #memprediksi 10 data test
predicted_classes = np.argmax(predictions, axis=1)

# Menampilkan gambar dan prediksi
for i in range(len(predicted_classes)):
  print("prediksi:", predicted_classes[i])

Kesimpulan dan Langkah Selanjutnya

Kita telah mempelajari langkah membangun model klasifikasi gambar. Anda bisa mengembangkan model lebih kompleks, mencoba transfer learning, dan fine tuning.

Langkah selanjutnya:

• Fine-tuning: Sesuaikan hyperparameter.
• Transfer Learning: Gunakan model pre-trained.
• Arsitektur CNN Berbeda: Coba arsitektur lain.

Baca juga: Panduan Lengkap Belajar AI untuk Pemula 2025

• Dataset Lebih Kompleks: Latih dengan dataset lebih menantang.

(Opsional) FAQ

• Apa perbedaan TensorFlow dan Keras?

  TensorFlow lebih low-level. Keras API high-level di atas TensorFlow.

• Bagaimana mengatasi overfitting?

  Overfitting terjadi jika model terlalu “hafal” data latih. Atasi dengan regularisasi, data augmentation, atau mengurangi kompleksitas.

• Bagaimana memilih arsitektur CNN?

  Bergantung pada ukuran dataset, kompleksitas tugas, dan sumber daya. Seringkali perlu eksperimen.

• Cara klasifikasi gambar dengan TensorFlow?

  TensorFlow punya tools untuk memproses gambar. Keras menyederhanakan.

• Tutorial Keras klasifikasi gambar?

  Panduan ini tutorial langkah demi langkah.

• Bagaimana menggunakan CNN untuk klasifikasi?

  CNN mempelajari fitur gambar melalui konvolusi dan pooling. Fitur untuk klasifikasi.

• Contoh kode MNIST dengan TensorFlow?

  Adaptasi panduan ini, ganti dataset dan sesuaikan parameter.

Otomatiskan tugas pemasaran dengan platform Kirim.ai. Pelajari lebih lanjut.