Program ini akan melatih model untuk mengenali 100 kelas objek berbeda dari gambar berukuran kecil (32x32 piksel). Saya akan menjelaskan tujuan program, struktur kode, dan membedah setiap bagian secara rinci.
Penjelasan Program
Tujuan Program: Program ini bertujuan untuk membangun, melatih, dan mengevaluasi model CNN untuk mengklasifikasikan gambar dari dataset CIFAR-100, yang berisi 60.000 gambar berwarna (50.000 untuk pelatihan, 10.000 untuk pengujian) dengan 100 kelas berbeda (misalnya, apel, sepeda, kucing). Model ini menggunakan TensorFlow untuk membangun arsitektur CNN yang mampu mengekstrak fitur visual dari gambar dan mengklasifikasikannya dengan akurat.
Mengapa CNN? CNN sangat efektif untuk tugas computer vision karena mampu mendeteksi pola spasial (seperti tepi, tekstur, atau bentuk) melalui lapisan konvolusi dan pooling, yang cocok untuk dataset gambar kompleks seperti CIFAR-100.
Dataset: CIFAR-100 adalah dataset standar yang kompleks karena memiliki banyak kelas (100 kelas) dan gambar beresolusi rendah, yang menantang model untuk menangkap fitur yang relevan.
Apa Itu Dataset CIFAR-100?
CIFAR-100 adalah dataset gambar berwarna yang digunakan untuk tugas computer vision, khususnya klasifikasi gambar. Berikut detailnya:
Ukuran Dataset:
- 60.000 gambar berwarna (RGB) berukuran 32x32 piksel.
- Dibagi menjadi 50.000 gambar untuk pelatihan dan 10.000 gambar untuk pengujian.
Kelas:
- 100 kelas berbeda, masing-masing berisi 600 gambar (500 untuk pelatihan, 100 untuk pengujian).
- Kelas-kelas ini dikelompokkan ke dalam 20 superkelas (misalnya, superkelas "hewan besar" mencakup kelas seperti gajah, singa, dll.).
Struktur Label:
- Setiap gambar memiliki dua label: label "fine" (1 dari 100 kelas spesifik, seperti apel, kucing) dan label "coarse" (1 dari 20 superkelas).
Contoh Kelas:
- Fine: apel, sepeda, kucing, dll.
- Coarse: buah, kendaraan, mamalia, dll.
- Kompleksitas: CIFAR-100 lebih kompleks daripada CIFAR-10 karena jumlah kelas yang lebih banyak dan resolusi gambar yang rendah, membuatnya menantang untuk klasifikasi akurat.
Dataset ini tersedia langsung di TensorFlow (tensorflow.keras.datasets.cifar100) atau PyTorch (torchvision.datasets.CIFAR100), sehingga Anda tidak perlu mengunduhnya secara manual.
Kodingan Python :
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import numpy as np
from tensorflow.keras.datasets import cifar100
# 1. Memuat dataset CIFAR-100
(x_train, y_train), (x_test, y_test) = cifar100.load_data(label_mode='fine')
# Normalisasi data (skala piksel dari 0-255 ke 0-1)
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0
# Daftar nama kelas (100 kelas)
class_names = [
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle', 'bicycle', 'bottle',
'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel', 'can', 'castle', 'caterpillar', 'cattle',
'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'keyboard',
'lamp', 'lawn_mower', 'leopard', 'lion', 'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain',
'mouse', 'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear', 'pickup_truck', 'pine_tree',
'plain', 'plate', 'poppy', 'porcupine', 'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket',
'rose', 'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake', 'spider',
'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table', 'tank', 'telephone', 'television', 'tiger', 'tractor',
'train', 'trout', 'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 'worm'
]
# 2. Visualisasi beberapa gambar dari dataset
plt.figure(figsize=(15, 4))
for i in range(10):
plt.subplot(2, 5, i+1)
plt.imshow(x_train[i])
plt.title(f"{class_names[y_train[i][0]]} ({y_train[i][0]})")
plt.axis('off')
plt.suptitle("10 Contoh Gambar dari CIFAR-100")
plt.show()
# 3. Augmentasi data untuk pelatihan
train_datagen = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
zoom_range=0.1
)
train_datagen.fit(x_train)
# 4. Membangun arsitektur model CNN
model = models.Sequential([
# Lapisan konvolusi pertama
layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)),
layers.BatchNormalization(),
layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.Dropout(0.25),
# Lapisan konvolusi kedua
layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
layers.BatchNormalization(),
layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.Dropout(0.25),
# Lapisan konvolusi ketiga
layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
layers.BatchNormalization(),
layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
layers.BatchNormalization(),
layers.MaxPooling2D((2, 2)),
layers.Dropout(0.25),
# Flatten dan lapisan dense
layers.Flatten(),
layers.Dense(512, activation='relu'),
layers.BatchNormalization(),
layers.Dropout(0.5),
layers.Dense(100, activation='softmax') # 100 kelas untuk CIFAR-100
])
# 5. Mengompilasi model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Menampilkan ringkasan model
model.summary()
# 6. Melatih model dengan augmentasi
batch_size = 64
history = model.fit(
train_datagen.flow(x_train, y_train, batch_size=batch_size),
epochs=8,
validation_data=(x_test, y_test),
steps_per_epoch=len(x_train) // batch_size
)
# 7. Mengevaluasi model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"\nAkurasi pada data uji: {test_acc:.4f}")
# 8. Visualisasi hasil pelatihan
plt.figure(figsize=(12, 4))
# Plot akurasi
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Akurasi Pelatihan')
plt.plot(history.history['val_accuracy'], label='Akurasi Validasi')
plt.title('Akurasi Model')
plt.xlabel('Epoch')
plt.ylabel('Akurasi')
plt.legend()
# Plot loss
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Loss Pelatihan')
plt.plot(history.history['val_loss'], label='Loss Validasi')
plt.title('Loss Model')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()
# 9. Prediksi dan visualisasi hasil pada data uji
predictions = model.predict(x_test[:10])
plt.figure(figsize=(15, 4))
for i in range(10):
plt.subplot(2, 5, i+1)
plt.imshow(x_test[i])
predicted_label = np.argmax(predictions[i])
true_label = y_test[i][0]
plt.title(f"Pred: {class_names[predicted_label]}\nTrue: {class_names[true_label]}")
plt.axis('off')
plt.suptitle("Prediksi pada 10 Gambar Uji")
plt.show()
HASIL :
Epoch 1/8
/usr/local/lib/python3.11/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.
781/781 ━━━━━━━━━━━━━━━━━━━━ 455s 573ms/step - accuracy: 0.0742 - loss: 4.5615 - val_accuracy: 0.2055 - val_loss: 3.3738
self._interrupted_warning()
781/781 ━━━━━━━━━━━━━━━━━━━━ 20s 25ms/step - accuracy: 0.1875 - loss: 3.1215 - val_accuracy: 0.2010 - val_loss: 3.4069
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 341ms/step
Gambar yang Anda berikan menunjukkan hasil evaluasi model CNN yang dilatih pada dataset CIFAR-100, serupa dengan kode Python yang telah saya berikan sebelumnya. Gambar ini terdiri dari dua bagian utama: grafik performa model (akurasi dan loss) serta hasil prediksi pada beberapa gambar uji. Saya akan menjelaskan setiap bagian dari gambar tersebut dan menghubungkannya dengan kode Python yang telah dibuat sebelumnya, sambil menganalisis apakah hasil ini konsisten dengan apa yang diharapkan dari kode tersebut.
1. Grafik Performa Model (Akurasi dan Loss)
a. Grafik Akurasi Model
Isi Grafik:
- Sumbu X: Epoch (0 hingga 7).
- Sumbu Y: Akurasi (0.10 hingga 0.35).
- Dua garis:
- Akurasi Pelatihan (biru): Mulai dari sekitar 0.15, naik perlahan, dan stabil di sekitar 0.30-0.35 pada epoch ke-7.
- Akurasi Validasi (oranye): Mulai dari sekitar 0.20, fluktuatif, dan stabil di sekitar 0.25-0.30 pada epoch ke-7.
Hubungan dengan Kode:
- Grafik ini dihasilkan oleh bagian kode berikut:plt.subplot(1, 2, 1)plt.plot(history.history['accuracy'], label='Akurasi Pelatihan')plt.plot(history.history['val_accuracy'], label='Akurasi Validasi')plt.title('Akurasi Model')plt.xlabel('Epoch')plt.ylabel('Akurasi')plt.legend()
- Grafik ini menunjukkan perkembangan akurasi selama pelatihan (history.history['accuracy']) dan validasi (history.history['val_accuracy']) sepanjang epoch.
Analisis:
- Akurasi Pelatihan: Meningkat secara konsisten, menunjukkan bahwa model belajar dengan baik pada data pelatihan.
- Akurasi Validasi: Fluktuatif dan lebih rendah dari akurasi pelatihan, mengindikasikan adanya overfitting ringan. Model lebih baik pada data pelatihan daripada data uji, yang wajar untuk dataset kompleks seperti CIFAR-100.
- Nilai Akurasi: Akurasi validasi maksimal sekitar 0.30 (30%), yang cukup rendah. Akurasi rendah ini mungkin disebabkan oleh:
- Jumlah epoch yang lebih sedikit (hanya 8 epoch pada grafik)
- Augmentasi data yang kurang agresif atau arsitektur model yang lebih sederhana dibandingkan kode saya.
- CIFAR-100 memang sulit karena resolusi rendah (32x32) dan 100 kelas, sehingga akurasi 30% dalam 8 epoch masih masuk akal untuk model dasar tanpa optimasi lebih lanjut.
b. Grafik Loss Model
Isi Grafik:
- Sumbu X: Epoch (0 hingga 7).
- Sumbu Y: Loss (2.6 hingga 4.0).
- Dua garis:
- Loss Pelatihan (biru): Mulai dari 3.8, turun perlahan, dan stabil di sekitar 3.0 pada epoch ke-7.
- Loss Validasi (oranye): Mulai dari 3.4, turun sedikit, dan stabil di sekitar 2.8 pada epoch ke-7.
Hubungan dengan Kode:
Grafik ini dihasilkan oleh bagian kode berikut:
plt.subplot(1, 2, 2)
- Grafik ini menunjukkan perkembangan loss selama pelatihan (history.history['loss']) dan validasi (history.history['val_loss']).
Analisis:
- Loss Pelatihan: Menurun seiring waktu, menunjukkan model belajar untuk meminimalkan kesalahan pada data pelatihan.
- Loss Validasi: Juga menurun, tetapi lebih lambat dan stabil di nilai yang lebih rendah dari loss pelatihan. Ini sedikit tidak biasa, karena biasanya loss validasi lebih tinggi pada kasus overfitting. Hal ini mungkin menunjukkan bahwa model belum sepenuhnya overfit, tetapi akurasi rendah menunjukkan model masih underfitting (belum cukup belajar pola yang relevan).
- Nilai Loss: Loss akhir (sekitar 3.0 untuk pelatihan, 2.8 untuk validasi) masih cukup tinggi. Untuk klasifikasi 100 kelas dengan sparse_categorical_crossentropy, loss yang baik biasanya di bawah 1.0 setelah pelatihan optimal. Nilai ini konsisten dengan akurasi rendah, menunjukkan model perlu lebih banyak epoch atau optimasi (seperti arsitektur yang lebih dalam, learning rate scheduling, atau augmentasi lebih agresif).
2. Hasil Prediksi pada Data Uji
Bagian bawah gambar menunjukkan 10 gambar uji dari CIFAR-100 dengan label prediksi dan label sebenarnya.
Isi:
Setiap gambar memiliki dua label:
- Pred: Prediksi model (misalnya, "dolphin", "porcupine").
- True: Label sebenarnya (misalnya, "mountain", "forest").
Contoh:
- Gambar 1: Pred: dolphin, True: mountain.
- Gambar 2: Pred: porcupine, True: forest.
- Gambar 3: Pred: pickup_truck, True: seal.
- Gambar 10: Pred: apple, True: apple (benar).
Hubungan dengan Kode:
Bagian ini dihasilkan oleh kode berikut:
predictions = model.predict(x_test[:10])
- Kode ini memprediksi kelas untuk 10 gambar uji pertama, lalu menampilkan gambar beserta label prediksi dan sebenarnya menggunakan class_names.
Analisis:
- Akurasi Prediksi: Dari 10 gambar, hanya 1 prediksi yang benar (Gambar 10: Pred: apple, True: apple). Ini konsisten dengan akurasi validasi rendah (sekitar 30%) pada grafik. Dengan akurasi 30%, diharapkan sekitar 3 dari 10 prediksi benar, tetapi di sini hanya 1 yang benar, yang masih dalam variasi statistik yang wajar.
- Kualitas Gambar: Gambar-gambar dalam CIFAR-100 beresolusi rendah (32x32 piksel), sehingga sulit bahkan untuk manusia untuk mengenali beberapa gambar (misalnya, Gambar 1 "mountain" yang diprediksi "dolphin"). Resolusi rendah ini adalah salah satu alasan akurasi model rendah.
- Kesalahan Prediksi:
- Beberapa kesalahan masuk akal:
- Gambar 2 (True: forest, Pred: porcupine): Gambar hutan mungkin memiliki tekstur yang mirip dengan bulu landak (porcupine) pada resolusi rendah.
- Gambar 4 (True: sea, Pred: pickup_truck): Warna biru laut mungkin membingungkan model dengan warna truk tertentu.
- Beberapa kesalahan kurang masuk akal:
- Gambar 1 (True: mountain, Pred: dolphin): Tidak ada kemiripan visual yang jelas, menunjukkan model belum menangkap fitur yang relevan.
- Kelas yang Digunakan: Kelas seperti "dolphin", "mountain", "apple", dll., sesuai dengan daftar class_names yang digunakan dalam kode, yang mencakup 100 kelas CIFAR-100.
3. Perbandingan dengan Ekspektasi dari Kode
Akurasi dan Loss:
- Loss yang masih tinggi (sekitar 3.0) juga konsisten dengan pelatihan yang belum cukup lama.
- Kode saya menggunakan augmentasi data (ImageDataGenerator) untuk mencegah overfitting, tetapi grafik menunjukkan tanda-tanda overfitting ringan (akurasi validasi lebih rendah dari pelatihan). Augmentasi mungkin kurang agresif atau epoch terlalu sedikit.
Prediksi:
- Bagian prediksi pada gambar sangat mirip dengan output kode saya, menampilkan 10 gambar uji dengan label prediksi dan sebenarnya. Satu prediksi benar dari 10 gambar konsisten dengan akurasi 30%.
- Gambar-gambar beresolusi rendah (32x32) sesuai dengan dataset CIFAR-100 yang digunakan dalam kode.
Kecepatan Pelatihan:
- Gambar menyebutkan "Qâ‚› 341ms/step". Ini menunjukkan waktu rata-rata per langkah (step) selama pelatihan, yang dihitung oleh TensorFlow selama model.fit. Dalam kode saya:history = model.fit(train_datagen.flow(x_train, y_train, batch_size=64),epochs=50,validation_data=(x_test, y_test),steps_per_epoch=len(x_train) // batch_size)steps_per_epoch dihitung sebagai len(x_train) // batch_size (50.000 // 64 ≈ 781 langkah per epoch). Kecepatan 341ms/step berarti 1 epoch memakan waktu sekitar 781 × 341ms ≈ 266 detik (4,4 menit). Ini wajar untuk pelatihan tanpa GPU pada dataset CIFAR-100.
4. Konsistensi dengan Dataset CIFAR-100
- Kelas: Kelas yang ditampilkan (dolphin, mountain, apple, dll.) sesuai dengan 100 kelas CIFAR-100 yang didefinisikan dalam class_names pada kode.
- Resolusi Gambar: Gambar beresolusi rendah (32x32 piksel), sesuai dengan spesifikasi CIFAR-100 (50.000 gambar pelatihan, 10.000 gambar pengujian, masing-masing 32x32x3).
- Kompleksitas: Akurasi rendah (30%) dan kesalahan prediksi mencerminkan kompleksitas CIFAR-100, yang memiliki 100 kelas dan gambar beresolusi rendah, membuatnya sulit untuk klasifikasi akurat tanpa pelatihan lebih lama atau model yang lebih canggih.
Bedah Kodingan
1. Impor Pustaka
import tensorflow as tf
Penjelasan:
- tensorflow dan tf.keras: Digunakan untuk membangun, melatih, dan mengevaluasi model CNN.
- layers dan models: Modul untuk mendefinisikan arsitektur model (contoh: Conv2D, Dense, Sequential).
- ImageDataGenerator: Untuk augmentasi data (rotasi, flip, dll.).
- matplotlib.pyplot: Untuk visualisasi grafik (akurasi/loss) dan gambar.
- numpy: Untuk operasi array (misalnya, np.argmax pada prediksi).
- cifar100: Dataset CIFAR-100 yang sudah tersedia di TensorFlow.
2. Memuat Dataset CIFAR-100
(x_train, y_train), (x_test, y_test) = cifar100.load_data(label_mode='fine')
Penjelasan:
- cifar100.load_data(label_mode='fine'): Memuat dataset CIFAR-100 dengan label fine (100 kelas, bukan 20 superkelas).
- x_train: (50000, 32, 32, 3) (50.000 gambar pelatihan, 32x32 piksel, 3 channel RGB).
- y_train: (50000, 1) (label kelas 0-99).
- x_test: (10000, 32, 32, 3) (10.000 gambar pengujian).
- y_test: (10000, 1).
- Normalisasi: Nilai piksel (0-255) dibagi 255 untuk mengubah rentang menjadi 0-1. Ini mempercepat konvergensi model karena skala data lebih kecil.
- Fungsi: Memastikan data siap untuk pelatihan dengan format dan skala yang sesuai.
3. Daftar Nama Kelas
class_names = [
Penjelasan:
- Daftar class_names berisi 100 nama kelas CIFAR-100, sesuai dengan label numerik (0-99).
- Digunakan untuk interpretasi label (misalnya, label 0 = "apple") saat visualisasi.
- Fungsi: Memudahkan pemahaman hasil prediksi dengan nama kelas yang lebih deskriptif.
4. Visualisasi Dataset
plt.figure(figsize=(15, 4))
Penjelasan:
- Menampilkan 10 gambar pertama dari data pelatihan (x_train) dalam grid 2x5.
- plt.imshow(x_train[i]): Menampilkan gambar ke-i.
- plt.title(f"{class_names[y_train[i][0]]} ({y_train[i][0]})"): Menampilkan nama kelas dan label numerik (misalnya, "apple (0)").
- plt.axis('off'): Menghilangkan sumbu untuk tampilan lebih bersih.
- plt.suptitle: Judul keseluruhan plot.
- Fungsi: Memverifikasi bahwa dataset dimuat dengan benar dan memberikan gambaran visual tentang data (resolusi rendah 32x32, variasi kelas).
5. Augmentasi Data
train_datagen = ImageDataGenerator(
Penjelasan:
- ImageDataGenerator: Membuat variasi gambar secara real-time selama pelatihan untuk mencegah overfitting.
- rotation_range=15: Rotasi acak hingga 15 derajat.
- width_shift_range=0.1: Pergeseran horizontal hingga 10% lebar gambar.
- height_shift_range=0.1: Pergeseran vertikal hingga 10% tinggi gambar.
- horizontal_flip=True: Flip horizontal acak.
- zoom_range=0.1: Zoom in/out hingga 10%.
- train_datagen.fit(x_train): Menyiapkan generator untuk data pelatihan.
- Fungsi: Augmentasi meningkatkan generalisasi model dengan membuatnya lebih tahan terhadap variasi kecil pada gambar, yang sangat penting untuk dataset kompleks seperti CIFAR-100.
6. Membangun Arsitektur Model CNN
model = models.Sequential([
Penjelasan:
- Model dibangun menggunakan Sequential (lapisan ditambahkan secara berurutan).
- Lapisan Konvolusi:
- Tiga blok konvolusi, masing-masing dengan 2 lapisan Conv2D:
- Blok 1: 32 filter (3x3), ReLU, padding 'same'.
- Blok 2: 64 filter.
- Blok 3: 128 filter.padding='same': Menjaga ukuran output sama dengan input.
- input_shape=(32, 32, 3): Ukuran gambar CIFAR-100.BatchNormalization: Menormalkan aktivasi untuk stabilitas pelatihan.
- MaxPooling2D((2, 2)): Mengurangi dimensi spasial (dari 32x32 ke 16x16, dst.) untuk efisiensi.
- Dropout(0.25): Mengabaikan 25% neuron secara acak untuk mencegah overfitting.
- Flatten: Mengubah peta fitur 2D menjadi vektor 1D.
- Dense(512, relu): Lapisan fully connected dengan 512 neuron.
- Dropout(0.5): Regularisasi lebih agresif (50%) pada lapisan dense.
- Dense(100, softmax): Lapisan keluaran untuk 100 kelas, menghasilkan probabilitas.Fungsi: Arsitektur ini cukup dalam untuk menangkap fitur kompleks dari 100 kelas CIFAR-100, dengan regularisasi untuk mencegah overfitting.
7. Mengompilasi Model
model.compile(optimizer='adam',
Penjelasan:
- optimizer='adam': Algoritma optimasi adaptif, cocok untuk tugas kompleks.
- loss='sparse_categorical_crossentropy': Fungsi loss untuk klasifikasi multi-kelas dengan label integer (0-99).
- metrics=['accuracy']: Mengukur akurasi selama pelatihan dan evaluasi.
- model.summary(): Menampilkan ringkasan arsitektur (jumlah parameter, ukuran output tiap lapisan).
- Fungsi: Menentukan bagaimana model akan dilatih dan dievaluasi.
8. Melatih Model
batch_size = 64
Penjelasan:
- batch_size=64: Memproses 64 gambar per iterasi.
- train_datagen.flow(x_train, y_train, batch_size=batch_size): Generator data dengan augmentasi.
- epochs=8: Melatih model selama 8 epoch (sebelumnya 50 epoch, ini adalah perubahan utama).
- validation_data=(x_test, y_test): Menggunakan data uji untuk validasi.
- steps_per_epoch=len(x_train) // batch_size: Jumlah langkah per epoch (50.000 // 64 ≈ 781 langkah).
- Fungsi: Melatih model untuk menyesuaikan bobot berdasarkan data pelatihan, dengan validasi untuk memantau performa pada data uji.
Hubungan dengan Gambar:
- Grafik pada gambar sebelumnya menunjukkan 7 epoch (sumbu X dari 0 hingga 7), sedangkan kode di sini menggunakan 8 epoch. Ini mungkin karena gambar dihasilkan dari pelatihan sebelumnya dengan epoch sedikit berbeda, atau pelatihan dihentikan lebih awal (misalnya, dengan callback seperti EarlyStopping yang tidak ada di kode ini).
9. Mengevaluasi Model
test_loss, test_acc = model.evaluate(x_test, y_test)
Penjelasan:
- model.evaluate: Mengukur loss dan akurasi pada data uji (10.000 gambar).
- test_acc: Akurasi pada data uji, dicetak dengan 4 desimal.
- Fungsi: Memberikan gambaran performa model pada data yang belum pernah dilihat.
Hubungan dengan Gambar:
- Grafik akurasi validasi menunjukkan nilai akhir sekitar 0.25-0.30. Kode ini kemungkinan menghasilkan akurasi serupa setelah 8 epoch, yang konsisten dengan gambar.
10. Visualisasi Hasil Pelatihan
plt.figure(figsize=(12, 4))
Penjelasan:
- Grafik akurasi: Membandingkan akurasi pelatihan dan validasi sepanjang epoch.
- Grafik loss: Membandingkan loss pelatihan dan validasi.
- history.history: Berisi metrik pelatihan (accuracy, val_accuracy, loss, val_loss) per epoch.
- Fungsi: Membantu analisis performa model, seperti mendeteksi overfitting (jika akurasi validasi jauh lebih rendah) atau underfitting (jika akurasi pelatihan rendah).
Hubungan dengan Gambar:
Grafik ini identik dengan grafik pada gambar sebelumnya:
- Akurasi pelatihan (biru) naik hingga ~0.35.
- Akurasi validasi (oranye) fluktuatif, stabil di ~0.30.
- Loss pelatihan (biru) turun ke ~3.0.
- Loss validasi (oranye) turun ke ~2.8.
- Perbedaan kecil pada jumlah epoch (7 pada gambar, 8 pada kode) mungkin karena pelatihan sebelumnya sedikit berbeda.
11. Prediksi dan Visualisasi
predictions = model.predict(x_test[:10])
Penjelasan:
- model.predict(x_test[:10]): Memprediksi kelas untuk 10 gambar uji pertama.
- np.argmax(predictions[i]): Mengambil indeks kelas dengan probabilitas tertinggi.
- Menampilkan gambar dalam grid 2x5 dengan label prediksi (Pred) dan label sebenarnya (True).
- Fungsi: Memberikan wawasan kualitatif tentang performa model pada data uji.
Hubungan dengan Gambar:
- Bagian ini identik dengan bagian bawah gambar sebelumnya, yang menunjukkan 10 gambar uji dengan prediksi seperti "Pred: dolphin, True: mountain".
- Satu prediksi benar (Pred: apple, True: apple), konsisten dengan akurasi rendah (~30%) yang terlihat pada grafik.
Hubungan dengan Gambar Hasil
Grafik Akurasi dan Loss:
- Grafik pada gambar (7 epoch, akurasi ~30%, loss ~3.0) konsisten dengan pelatihan 8 epoch pada kode ini. Akurasi rendah karena epoch sedikit dan dataset CIFAR-100 yang kompleks.
- Grafik ini langsung dihasilkan oleh bagian visualisasi (langkah 10).
Prediksi Gambar:
- Bagian prediksi pada gambar (10 gambar uji dengan label Pred/True) dihasilkan oleh langkah 11 kode ini. Akurasi rendah (1 dari 10 benar) sesuai dengan akurasi validasi ~30%.
Kecepatan Pelatihan:
Gambar menyebutkan "Qâ‚› 341ms/step", yang konsisten dengan pelatihan pada kode ini. Dengan steps_per_epoch ≈ 781 (50.000 // 64), 1 epoch memakan waktu ~266 detik (4,4 menit), wajar untuk pelatihan tanpa GPU.
Kesimpulan
Gambar tersebut adalah hasil evaluasi model CNN yang dilatih pada dataset CIFAR-100. Grafik akurasi dan loss menunjukkan performa model selama 8 epoch, dengan akurasi validasi sekitar 30%, yang rendah karena pelatihan belum optimal (epoch sedikit, kemungkinan augmentasi kurang agresif). Bagian prediksi menunjukkan 2 dari 10 gambar diprediksi dengan benar, sesuai dengan akurasi rendah. Untuk meningkatkan performa, tingkatkan jumlah epoch, gunakan augmentasi lebih agresif, dan pertimbangkan arsitektur yang lebih dalam.
No comments:
Post a Comment