Klasifikasi Gambar Menggunakan Deeplearning Untuk Kasus Sel Darah Putih 🩸 [Part 3]

7 min readFeb 17, 2023

Haii readers.. berikut merupakan lanjutan dari part 2 terkait klasifikasi gambar sel darah putih yang sebelumnya sudah di publish yah :)

Berdasarkan model ResNet50 sebelumnya, hasil evaluasi pada data test sudah cukup baik untuk data kesehatan yang pada dasarnya sangat sulit untuk dideteksi. Namun, karena masih terdeteksi adanya overfitting pada hasil data test sehingga kita coba untuk model-model lain. Seperti MobileNetV2 yang mana memiliki banyak kelebihan disisi waktu training yang cepat.

Tahapan yang dilakukan kurang lebih sama dengan proses pemodelan sebelumnya, hanya saja berbeda pada tahapan pembuatan model.

MobileNetV2 adalah arsitektur CNN yang dirancang khusus untuk perangkat seluler dan tersemat, dengan fokus pada efisiensi dan kecepatan. Ini adalah versi yang lebih ringan dan lebih cepat dari arsitektur MobileNet asli, dan dikenal karena kinerjanya yang baik pada berbagai tugas klasifikasi gambar sekaligus lebih efisien secara komputasi daripada VGG19 dan Resnet50.

Di sisi lain, VGG19 dan ResNet50 keduanya adalah arsitektur CNN populer yang telah dilatih pada kumpulan data ImageNet, yang merupakan kumpulan data gambar yang besar dan label yang sesuai. VGG19 dikenal karena kinerjanya yang baik pada kumpulan data ImageNet dan kemampuannya untuk mengekstraksi fitur canggih dari gambar. ResNet50, di sisi lain, dikenal karena kemampuannya untuk melatih jaringan yang sangat dalam tanpa mengalami masalah gradien menghilang dan kinerjanya yang baik pada kumpulan data ImageNet.

Saat membandingkan MobileNetV2 dengan VGG19 dan ResNet50, satu perbedaan utama adalah jumlah parameter. MobileNetV2 memiliki parameter yang jauh lebih sedikit daripada VGG19 dan ResNet50. Ini berarti bahwa MobileNetV2 membutuhkan lebih sedikit memori dan sumber daya komputasi.

Perbedaan utama lainnya adalah biaya komputasi, MobileNetV2 dirancang agar lebih efisien dalam hal komputasi dan karena itu lebih cepat dijalankan di perangkat seluler dan tersemat.

Singkatnya, MobileNetV2 merupakan model komputasi yang lebih efisien dibandingkan dengan VGG19 dan ResNet50, dan sangat cocok untuk perangkat seluler dan tersemat. Namun, VGG19 dan ResNet50 adalah model yang lebih kuat yang telah dilatih pada kumpulan data besar dan telah terbukti bekerja dengan baik pada berbagai tugas klasifikasi gambar. Model terbaik untuk digunakan akan bergantung pada karakteristik khusus dari kumpulan data, masalah yang Anda coba selesaikan, dan sumber daya yang Anda miliki.

Load data Image MobileNet50

Memuat data dengan menggunakan fungsi preprocessing preprocess_input dari modul mobilenet_v2 dari paket tf.keras.applications. Fungsi ini khusus untuk arsitektur MobileNetV2 dan digunakan untuk menyiapkan gambar masukan untuk model. Tidak cocok untuk digunakan dengan model lain seperti VGG19 atau ResNet50.

# Create generators
train_gen_mobile = tf.keras.preprocessing.image.ImageDataGenerator(
    preprocessing_function=tf.keras.applications.mobilenet_v2.preprocess_input,
    validation_split=0.2
) #Membagi data train menjadi train dan validation dengan proporsi 80% dan 20%

test_gen_mobile = tf.keras.preprocessing.image.ImageDataGenerator(
    preprocessing_function=tf.keras.applications.mobilenet_v2.preprocess_input
)

Kode diatas merupakan proses preprocessing menggunakan fungsi dari MobileNet50 itu sendiri tidak sama dengan langkah model-model sebelumnya.

train_images=train_gen_mobile.flow_from_directory(
    directory=train_path,
    target_size=(224, 224),
    color_mode='rgb',
    class_mode='categorical',
    batch_size=32,
    shuffle=True,
    seed=42,
    subset='training'
)

val_images=train_gen_mobile.flow_from_directory(
    directory=train_path,
    target_size=(224, 224),
    color_mode='rgb',
    class_mode='categorical',
    batch_size=32,
    shuffle=True,
    seed=42,
    subset='validation'
)

test_images=test_gen_mobile.flow_from_directory(
    directory=test_path,
    target_size=(224, 224),
    color_mode='rgb',
    class_mode='categorical',
    batch_size=32,
    shuffle=False
)

Terdeteksi hasil pembagian dataset menggunakan model MobileNet50 sama seperti pada pembagian model-model sebelumnya. Baik itu Dataset Train, Validation, dan Test nya.

Build Pre-Trained Model

# Load pretrained model
pretrained_model = tf.keras.applications.mobilenet_v2.MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,
    weights='imagenet'
)

# The convolutional layers have already been optimized to extract features
pretrained_model.trainable = False

Kode diatas memuat versi pretrained model MobileNetV2 dari modul tf.keras.applications TensorFlow, dengan

`input shape` = (224, 224, 3), artinya model mengharapkan gambar dengan tinggi dan lebar 224 piksel dan 3 saluran warna (merah, hijau, biru) dimana ini merupakan hasil perubahan dimensi gambar awal dari 320x240 piksel.
`include_top` = False, artinya lapisan atas model (lapisan klasifikasi) tidak disertakan.
`weights` = `imagenet`, artinya model akan diinisialisasi dengan bobot yang telah dilatih sebelumnya dari kumpulan data ImageNet.
`pooling` = diatur ke ’max’, artinya pooling maksimal global akan digunakan sebagai keluaran model.
`pretrained_model.trainable` = False, artinya menetapkan semua lapisan dalam model menjadi tidak dapat dilatih, yang berarti bahwa parameter lapisan tidak akan diperbarui selama proses training. Hal ini berguna saat menggunakan model pra-pelatihan sebagai ekstraktor fitur, karena memastikan bahwa fitur yang dipelajari tidak berubah selama pelatihan.

Berdasarkan cek layer model MobileNet50 yang digunakan terdapat 154 layer pada pretrained modelnya. Tahap selanjutnya, kita perlu melakukan pembuatan model klasifikasinya.

Buil Classification Model

inputs = pretrained_model.input

x = GlobalAveragePooling2D()(pretrained_model.output)
x = Dense(1024, activation='relu')(x)
x = Dense(512, activation='relu')(x)
x = Dense(256, activation='relu')(x)
outputs = Dense(4, activation='softmax')(x) #terdapat 4 kelas klasifikasi gambar 

model_mvnet = tf.keras.Model(inputs=inputs, outputs=outputs)

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


history_mvnet = model_mvnet.fit(
    train_images,
    validation_data=val_images,
    epochs=20)

Berdasarkan hasil training model dengan 20 epoch didapatkan nilai loss dan accuracy. Maka kita perlu melihat visualisasi dari trainingnya dengan menggunakan plot berikut.

#Menampilkan plot history
accuracy = history_mvnet.history['accuracy']
val_acc = history_mvnet.history['val_accuracy']
loss = history_mvnet.history['loss']
val_loss = history_mvnet.history['val_loss']
 
epochs = range(len(accuracy))
 
plt.plot(epochs, accuracy, 'b', label='Training accuracy')
plt.plot(epochs, val_acc, 'r', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()
 
plt.figure()
 
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
 
plt.show()

Evaluasi Model

predictions = np.argmax(model_mvnet1.predict(test_images), axis=1)

acc = accuracy_score(test_images.labels, predictions)
cm = tf.math.confusion_matrix(test_images.labels, predictions)
clr = classification_report(test_images.labels, predictions, target_names=CLASS_NAMES)

print("Test Accuracy: {:.3f} %".format(acc * 100))

plt.figure(figsize=(6,5))
sns.heatmap(cm, annot=True, fmt='g', vmin=0, cmap='Reds', cbar=False)
plt.xticks(ticks=np.arange(4) + 0.5, labels=CLASS_NAMES)
plt.yticks(ticks=np.arange(4) + 0.5, labels=CLASS_NAMES)
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix")
plt.show()

print("Classification Report:\n-----------------------------\n", clr)

# Model Resnet
print("The best Training accuracy = {:.3f}%".format(max(accuracy)*100))
print("The best validation accuracy = {:.3f}% ".format(max(val_acc)*100))
print("The best Test accuracy =",(model_mvnet1.evaluate(test_images)[1]*100))

Hasil dari evaluasi model menggunakan mobilenet V2 yakni:

The best Training accuracy = 97.904%
The best validation accuracy = 91.151%
The best Test accuracy = 50.945%

Dari hasil diatas dapat kita lihat bahwa, ada sesuatu yang mengkhawatirkan dalam hasil yang kita dapatkan. Set validasi memiliki akurasi sekitar 91% yang bagus. Namun pada set test atau pengujian, akurasinya turun menjadi sekitar 51%. Ini tidak normal dan ini menandakan adanya ketidak miripan antara data set train dengan data test.

Kesimpulan

Berdasarkan hasil image classification menggunakan data sel darah putih dengan 4 jenis kelas menggunakan beberapa model transfer learning seperti `VGG19`, `Resnet50`, dan `MobilenetV2`. Kedua model pertama yakni `VGG19` dan `Resnet50` memang digunakan untuk kasus klasifikasi gambar CNN untuk data yang besar dan kompleks. Sedangkan MobileNetV2 ini untuk daya representasinya terbatas dimana karena dirancang untuk ukuran yang kecil dan dioptimalkan untuk inferensi cepat, yang memungkinkannya berjalan dengan cepat bahkan pada perangkat dengan sumber daya terbatas. Dibuktikan dengan hasil test pada model memiliki nilai yang paling kecil diantara model lainnya walau saat running model paling cepat dan memiliki akurasi train dan validation yang sangat baik(overfitting).

Sedangkan, penggunaan model Resnet memiliki akurasi test yang terbaik sejauh model yang telat diujicobakan dengan akurasi pada data test sebesar 81.1%. Sehingga untuk kedepannya model yang disarankan untuk dijadikan rekomendasi pemodelan klasifikasi darah putih ini yakni dengan model `ResNet50` dengan catatan kemungkinan akan lebih baik lagi jika mempeebaiki data cleansingnya.

Berdasarkan jurnal-jurnal kesehatan yang mengimplementasikan image classification menggunakan CNN dan transfer learning seperti diatas, pada umumnya ResNet50 untuk data data kesehatan memiliki akurasi yang sangat baik karena beberapa alasan:

1. Jumlah layer yang banyak: jika dilihat dari hasil model diatas, memang ResNet50 lah yang punya layer terbanyak yakni 174, dibanding dengan model lain.

2. ResNet50 menggunakan koneksi residual yang memungkinkan jaringan menyimpan informasi dengan lebih baik dari lapisan sebelumnya saat masuk lebih dalam ke jaringan. Ini membantu mengurangi masalah gradien yang hilang dan memungkinkan ResNet50 untuk mempelajari representasi data yang lebih kompleks.

3. Mempunyai pre-training yang memberikan fondasi yang kuat untuk jaringan, membuatnya lebih mudah beradaptasi dengan kumpulan data baru seperti citra medis.