Description

Kode di atas digunakan untuk mengakses direktori yang berisi dataset gambar kanker darah dan mendapatkan informasi tentang jumlah gambar dalam setiap kelas. Pada baris pertama, data_dir diinisialisasi dengan path ke direktori yang berisi dataset gambar. Path ini dapat disesuaikan dengan lokasi sebenarnya dari dataset di Google Drive. Kemudian, os.listdir(data_dir) digunakan untuk mengambil daftar file dan direktori yang ada di data_dir. Hasilnya akan berupa list yang berisi nama-nama file dan direktori dalam data_dir. Selanjutnya, label digunakan untuk menyimpan hasil dari os.listdir(data_dir). label akan berisi list nama-nama file dan direktori dalam data_dir. Pada baris terakhir, print('Total Gambar Blood Cancer : ', len(os.listdir(data_dir))) digunakan untuk mencetak jumlah gambar dalam dataset. len(os.listdir(data_dir)) akan menghitung jumlah item (file dan direktori) dalam data_dir dan hasilnya akan dicetak dengan pesan "Total Gambar Blood Cancer : ". Dengan kode tersebut, Anda dapat melihat jumlah gambar dalam dataset kanker darah yang tersimpan dalam direktori yang ditentukan oleh data_dir.

Kode di atas digunakan untuk menginisialisasi path direktori untuk setiap kelas dalam dataset. Setiap variabel seperti train_Benign_dir, train_Early_dir, train_Pre_dir, dan train_Pro_dir menyimpan path direktori untuk masing-masing kelas dalam dataset.

• train_Benign_dir merupakan path ke direktori kelas "Benign" dalam dataset.
• train_Early_dir merupakan path ke direktori kelas "Early" dalam dataset.
• train_Pre_dir merupakan path ke direktori kelas "Pre" dalam dataset.
• train_Pro_dir merupakan path ke direktori kelas "Pro" dalam dataset.

Dalam kode di atas, os.path.join() digunakan untuk menggabungkan path ke direktori utama (drive/MyDrive/Data/Original) dengan nama direktori kelas (misalnya, "Benign", "Early", "Pre", "Pro") untuk membentuk path lengkap ke direktori kelas tersebut. Dengan menginisialisasi variabel tersebut, Anda dapat menggunakan path direktori ini untuk mengakses gambar-gambar dalam masing-masing kelas saat memuat dan melatih model Anda

Kode di atas digunakan untuk menghitung jumlah gambar dalam setiap kelas dalam dataset pelatihan. Setiap pernyataan print akan mencetak jumlah gambar dalam kelas yang sesuai.

• len(os.listdir(train_Benign_dir)) menghitung jumlah gambar dalam kelas "Benign" dalam dataset pelatihan.
• len(os.listdir(train_Early_dir)) menghitung jumlah gambar dalam kelas "Early" dalam dataset pelatihan.
• len(os.listdir(train_Pre_dir)) menghitung jumlah gambar dalam kelas "Pre" dalam dataset pelatihan.
• len(os.listdir(train_Pro_dir)) menghitung jumlah gambar dalam kelas "Pro" dalam dataset pelatihan.

Dengan menggunakan fungsi os.listdir() untuk membaca daftar file dalam setiap direktori kelas, kemudian menggunakan len() untuk menghitung jumlah file, kita dapat mengetahui jumlah gambar yang ada dalam setiap kelas. Hasilnya akan dicetak dengan menggunakan pernyataan print. Dengan informasi ini, Anda dapat memverifikasi jumlah gambar yang ada dalam setiap kelas dan memastikan dataset Anda seimbang atau jika ada ketidakseimbangan antara jumlah gambar dalam kelas-kelas tertent

Perintah pip install keras_preprocessing digunakan untuk menginstal paket keras_preprocessing melalui pip. Paket ini adalah bagian dari keras yang menyediakan utilitas pemrosesan gambar yang dapat digunakan dalam pengembangan model jaringan saraf. Penjelasan kode di atas adalah untuk menginstal keras_preprocessing agar tersedia dalam lingkungan kerja. Setelah instalasi selesai, Anda dapat mengimpor dan menggunakan modul keras_preprocessing untuk melakukan operasi pemrosesan gambar yang diperlukan, seperti augmentasi data, normalisasi, dan sebagainya. 

kode di atas mengimpor modul tensorflow dan keras_preprocessing dari paket keras_preprocessing. Kemudian, itu juga mengimpor submodul image dan ImageDataGenerator dari keras_preprocessing.image.

• tensorflow adalah platform open-source yang digunakan untuk mengembangkan dan melatih model jaringan saraf.
• keras_preprocessing adalah paket yang menyediakan utilitas pemrosesan gambar untuk digunakan dalam pengembangan model jaringan saraf.
• image adalah submodul dari keras_preprocessing yang menyediakan fungsi dan kelas untuk memproses gambar, seperti mengubah ukuran, mengubah format, dan sebagainya.
• ImageDataGenerator adalah kelas yang memungkinkan augmentasi data pada gambar dan menghasilkan batch data gambar yang dimuat dari direktori.

Dengan mengimpor modul dan submodul ini, Anda dapat menggunakan fungsi dan kelas yang disediakan untuk memproses gambar dalam rangka mempersiapkan data pelatihan dan validasi untuk model jaringan saraf.

Kode di atas membuat objek datagen dari kelas ImageDataGenerator yang digunakan untuk menormalisasi data gambar dan membagi data menjadi data pelatihan dan data validasi.

• ImageDataGenerator adalah kelas yang digunakan untuk menghasilkan batch data gambar yang dimuat dari direktori. Selain itu, ia juga menyediakan berbagai transformasi dan augmentasi data gambar seperti rotasi, pergeseran, zoom, dan lainnya.

Pada konstruktor ImageDataGenerator, terdapat dua argumen penting:

• rescale=1./255: Argumen ini digunakan untuk menormalisasi intensitas piksel gambar. Dalam hal ini, nilai setiap piksel gambar akan dibagi dengan 255 sehingga intensitas piksel akan berada dalam rentang 0 hingga 1. Normalisasi seperti ini umum dilakukan sebelum melatih model jaringan saraf untuk membantu dalam konvergensi yang lebih baik dan stabil.
• validation_split=0.2: Argumen ini menentukan proporsi data yang akan dialokasikan sebagai data validasi. Dalam hal ini, 20% data akan digunakan sebagai data validasi, sementara 80% data lainnya akan digunakan sebagai data pelatihan.

Dengan menggunakan objek datagen yang telah dibuat, Anda dapat menggunakan metode-metode dari kelas ImageDataGenerator untuk memproses dan mempersiapkan batch data gambar yang akan digunakan dalam pelatihan dan validasi model jaringan saraf.

Kode di atas menggunakan modul ImageDataGenerator dari Keras untuk memuat data gambar dalam format direktori dan membuat generator aliran data untuk melatih dan memvalidasi model. Pertama, flow_from_directory digunakan untuk membuat generator aliran data pelatihan dengan memuat gambar dari direktori yang ditentukan oleh data_dir.

• target_size = (224,224) mengatur ukuran target gambar yang akan diberikan kepada model. Gambar dalam direktori akan diubah ukurannya menjadi 224x224 piksel.
• class_mode = 'categorical' mengindikasikan bahwa tugas klasifikasi yang dilakukan adalah klasifikasi banyak kelas. Dengan ini, label kelas akan dihasilkan dalam format one-hot encoding.
• shuffle = True akan mengacak urutan gambar yang dihasilkan oleh generator aliran data, sehingga setiap epoch akan melibatkan urutan data yang berbeda.
• subset = 'training' mengindikasikan bahwa generator ini digunakan untuk melatih model. Ini akan memuat gambar-gambar dari subdirektori 'training' dalam direktori data_dir.

Hasil dari pemanggilan flow_from_directory pada data pelatihan adalah "Found 2607 images belonging to 4 classes", yang berarti ada total 2607 gambar yang ditemukan dalam direktori pelatihan dan gambar-gambar tersebut berasal dari 4 kelas yang berbeda. Selanjutnya, kode yang sama digunakan untuk membuat generator aliran data validasi dengan menggunakan subset = 'validation'. Generator ini akan memuat gambar-gambar dari subdirektori 'validation' dalam direktori data_dir. Hasil dari pemanggilan flow_from_directory pada data validasi adalah "Found 649 images belonging to 4 classes", yang berarti ada total 649 gambar yang ditemukan dalam direktori validasi dan gambar-gambar tersebut berasal dari 4 kelas yang berbeda. Generator aliran data pelatihan dan validasi ini nantinya dapat digunakan sebagai input untuk metode fit_generator atau evaluate_generator pada model Keras untuk melatih dan mengevaluasi model klasifikasi gambar.

Kode di atas mendefinisikan sebuah model neural network dengan 5 layer konvolusi untuk klasifikasi gambar. Berikut adalah penjelasan mengenai setiap layer dalam model:

1. Layer 1:
   • Conv2D(16, (3,3), activation='relu', input_shape=(224, 224, 3)): Layer konvolusi dengan 16 filter ukuran 3x3, menggunakan fungsi aktivasi ReLU. Input gambar memiliki ukuran 224x224 piksel dan 3 channel (RGB).
   • MaxPooling2D(2,2): Layer pooling untuk mengurangi dimensi spasial dengan faktor 2.
2. Layer 2:
   • Conv2D(16, (3,3), activation='relu'): Layer konvolusi kedua dengan 16 filter ukuran 3x3, menggunakan fungsi aktivasi ReLU.
   • MaxPooling2D(2,2): Layer pooling kedua dengan faktor 2.
3. Layer 3:
   • Conv2D(16, (3,3), activation='relu'): Layer konvolusi ketiga dengan 16 filter ukuran 3x3, menggunakan fungsi aktivasi ReLU.
   • MaxPooling2D(2,2): Layer pooling ketiga dengan faktor 2.
4. Layer 4:
   • Conv2D(16, (3,3), activation='relu'): Layer konvolusi keempat dengan 16 filter ukuran 3x3, menggunakan fungsi aktivasi ReLU.
   • MaxPooling2D(2,2): Layer pooling keempat dengan faktor 2.
5. Layer 5:
   • Conv2D(16, (3,3), activation='relu'): Layer konvolusi kelima dengan 16 filter ukuran 3x3, menggunakan fungsi aktivasi ReLU.
   • MaxPooling2D(2,2): Layer pooling kelima dengan faktor 2.

Setelah 5 layer konvolusi, dilanjutkan dengan layer input Deep Learning Neural Network:

• Flatten(): Mengubah output dari layer sebelumnya menjadi satu dimensi.
• Dropout(0.5): Mengimplementasikan dropout dengan tingkat dropout sebesar 0.5 untuk mengurangi overfitting.

Kemudian, terdapat tiga hidden layer dengan 512 neuron dan menggunakan fungsi aktivasi ReLU:

• Dense(512, activation='relu'): Hidden layer pertama.
• Dense(512, activation='relu'): Hidden layer kedua.
• Dense(512, activation='relu'): Hidden layer ketiga.

Terakhir, layer output menggunakan fungsi aktivasi softmax untuk melakukan klasifikasi pada 4 kelas yang ada:

• Dense(4, activation='softmax'): Layer output dengan 4 neuron.

Dengan demikian, model ini akan menghasilkan output berupa probabilitas kelas untuk setiap input gambar yang diberikan.

Kode di atas menggunakan model.summary() untuk menampilkan ringkasan atau informasi terkait dengan model yang telah dibuat. Berikut adalah penjelasan mengenai informasi yang ditampilkan oleh model.summary():

• Model: "sequential": Nama model ini adalah "sequential", yang mengindikasikan bahwa model ini dibuat sebagai urutan linier dari layer-layer yang dihubungkan secara berurutan.
• Layer (type) Output Shape Param #:
  • Conv2D: Layer konvolusi dengan ukuran output shape (None, 222, 222, 16) dan memiliki 448 parameter yang dapat dipelajari.
  • MaxPooling2D: Layer pooling dengan ukuran output shape (None, 111, 111, 16) dan tidak memiliki parameter yang dapat dipelajari.

(Informasi serupa diberikan untuk layer-layer berikutnya)

• Flatten: Layer flatten dengan output shape (None, 400). Layer ini mengubah output dari layer sebelumnya menjadi satu dimensi.
• Dropout: Layer dropout dengan output shape (None, 400). Dropout dilakukan dengan tingkat dropout 0.5 untuk mengurangi overfitting.
• Dense: Hidden layer pertama dengan output shape (None, 512) dan memiliki 205,312 parameter yang dapat dipelajari.
• Dense_1: Hidden layer kedua dengan output shape (None, 512) dan memiliki 262,656 parameter yang dapat dipelajari.
• Dense_2: Hidden layer ketiga dengan output shape (None, 512) dan memiliki 262,656 parameter yang dapat dipelajari.
• Dense_3: Layer output dengan output shape (None, 4) dan memiliki 2,052 parameter yang dapat dipelajari.
• Total params: Jumlah total parameter dalam model, yaitu 742,404.
• Trainable params: Jumlah parameter yang dapat dipelajari atau diubah selama proses pelatihan, yaitu 742,404.
• Non-trainable params: Jumlah parameter yang tidak dapat dipelajari atau diubah selama proses pelatihan, yang pada kasus ini adalah 0.

Ringkasan model memberikan informasi tentang ukuran output dari setiap layer, jumlah parameter yang ada dalam model, serta apakah parameter tersebut dapat dipelajari selama proses pelatihan. Informasi ini sangat berguna dalam menganalisis dan memahami arsitektur model yang telah dibuat.

Kode di atas menggunakan metode compile pada model untuk mengkonfigurasi proses pelatihan. Berikut adalah penjelasan mengenai argumen yang digunakan dalam compile:

• loss='categorical_crossentropy': Menentukan fungsi loss yang digunakan selama pelatihan model. Dalam kasus ini, digunakan categorical cross-entropy loss karena tugas klasifikasi yang dilakukan adalah klasifikasi banyak kelas.
• optimizer='adam': Menentukan optimizer yang digunakan untuk mengoptimalkan model selama pelatihan. Dalam kasus ini, digunakan optimizer Adam, yang merupakan metode optimasi yang populer dan efisien dalam pelatihan model deep learning.
• metrics=['accuracy']: Menentukan metrik evaluasi yang akan digunakan untuk memantau kinerja model selama pelatihan. Dalam kasus ini, metrik yang digunakan adalah akurasi (accuracy), yang mengukur sejauh mana model dapat mengklasifikasikan data dengan benar.

Dengan melakukan model.compile, model telah siap untuk dilatih menggunakan data yang telah disiapkan dengan generator aliran data dan konfigurasi pelatihan yang telah ditentukan.

Kode di atas menggunakan metode fit pada model untuk melatih model menggunakan data yang telah disiapkan. Berikut adalah penjelasan mengenai argumen yang digunakan dalam fit:

• train: Generator aliran data yang digunakan untuk melatih model. Data pelatihan akan diberikan pada model dalam batch-batch sesuai dengan konfigurasi yang telah ditentukan saat pembuatan generator aliran data.
• epochs=50: Jumlah epoch yang akan dilakukan selama pelatihan. Satu epoch mengacu pada satu iterasi melalui seluruh data pelatihan.
• validation_data=validasi: Generator aliran data yang digunakan untuk validasi model. Data validasi akan digunakan untuk memantau kinerja model pada setiap epoch.
• verbose=2: Menentukan tingkat detail informasi yang akan ditampilkan selama pelatihan. Dalam kasus ini, verbose=2 berarti akan menampilkan bar notasi progres per epoch.

Setelah menjalankan kode di atas, model akan mulai dilatih menggunakan data pelatihan dan akan dievaluasi menggunakan data validasi pada setiap epoch. Proses ini akan berlangsung selama 50 epoch, dan setiap detail pelatihan dan evaluasi akan ditampilkan sesuai dengan tingkat verbosity yang ditentukan. Hasil dari pelatihan model dapat ditemukan dalam variabel history, yang berisi riwayat pelatihan, seperti loss dan akurasi pada setiap epoch. Riwayat ini dapat digunakan untuk menganalisis kinerja model dan membuat visualisasi grafik untuk memantau perkembangan pelatihan.

Kode di atas menggunakan metode evaluate pada model untuk menghitung nilai loss dan akurasi dari data validasi. Berikut adalah penjelasan mengenai argumen dan hasil yang diberikan oleh evaluate:

• validasi: Generator aliran data yang digunakan untuk evaluasi model. Data validasi akan digunakan untuk mengukur kinerja model setelah pelatihan.
• verbose=1: Menentukan tingkat detail informasi yang akan ditampilkan selama evaluasi. Dalam kasus ini, verbose=1 berarti akan menampilkan informasi progres evaluasi.

Setelah menjalankan kode di atas, model akan menghitung nilai loss dan akurasi dari data validasi. Hasil evaluasi ditampilkan dalam bentuk baris yang terdiri dari loss dan akurasi. hasil evaluasi menunjukkan bahwa nilai loss adalah 0.3170 dan akurasi adalah 0.9337. Ini berarti model telah mencapai tingkat akurasi sebesar 93.37% pada data validasi yang digunakan untuk evaluasi.

Kode di atas menggunakan modul matplotlib.pyplot untuk membuat grafik yang menampilkan perubahan akurasi model pada setiap epoch selama pelatihan dan evaluasi. Berikut adalah penjelasan mengenai langkah-langkah yang dilakukan dalam kode tersebut:

• plt.plot(history.history['accuracy'], label='Training', color='Red'): Membuat plot garis untuk akurasi pelatihan. history.history['accuracy'] mengacu pada nilai akurasi yang tersimpan dalam riwayat pelatihan model. Garis ini ditandai dengan label 'Training' dan memiliki warna merah.
• plt.plot(history.history['val_accuracy'], label='validation', color='Green'): Membuat plot garis untuk akurasi evaluasi (validasi). history.history['val_accuracy'] mengacu pada nilai akurasi validasi yang tersimpan dalam riwayat pelatihan model. Garis ini ditandai dengan label 'validation' dan memiliki warna hijau.
• plt.title('Accuracy Training & Validasi'): Memberikan judul grafik, yaitu 'Accuracy Training & Validasi'.
• plt.xlabel('Epoch'): Memberikan label sumbu x pada grafik, yaitu 'Epoch', yang mengindikasikan jumlah epoch yang telah dilakukan.
• plt.legend(loc='lower right'): Menampilkan legenda (keterangan) pada grafik, dengan posisi di kanan bawah.
• plt.show(): Menampilkan grafik akurasi pelatihan dan evaluasi.

Dengan menjalankan kode di atas, Anda akan melihat grafik yang menunjukkan perubahan akurasi model pada setiap epoch selama pelatihan dan evaluasi. Grafik ini memberikan gambaran visual tentang kinerja model dan dapat membantu dalam menganalisis perubahan akurasi seiring berjalannya proses pelatihan. Garis merah menunjukkan akurasi pelatihan, sementara garis hijau menunjukkan akurasi evaluasi (validasi).

Kode di atas menggunakan model yang telah dilatih untuk melakukan prediksi pada data validasi. Berikut adalah penjelasan mengenai langkah-langkah yang dilakukan dalam kode tersebut:

• predict = model.predict(validasi): Menggunakan metode predict pada model untuk melakukan prediksi pada data validasi. Hasil prediksi akan berupa probabilitas kelas untuk setiap data validasi.
• y_classes = predict.argmax(axis=-1): Mencari indeks dengan nilai probabilitas tertinggi pada setiap prediksi. argmax digunakan untuk mengembalikan indeks dengan nilai probabilitas terbesar pada setiap prediksi. Dalam hal ini, axis=-1 mengacu pada sumbu terakhir dari array probabilitas, yaitu kelas.
• y_classes: Variabel y_classes berisi array yang berisi prediksi kelas yang telah diubah dari probabilitas menjadi indeks dengan nilai probabilitas terbesar.

Dengan menjalankan kode di atas, Anda akan mendapatkan array y_classes yang berisi prediksi kelas untuk setiap data dalam data validasi. Array ini memberikan prediksi kelas yang dihasilkan oleh model untuk data validasi yang digunakan.

Kode di atas menggunakan modul sklearn.metrics untuk menghitung dan menampilkan matriks kebingungan (confusion matrix) serta laporan klasifikasi (classification report) dari hasil prediksi model pada data validasi. Berikut adalah penjelasan mengenai langkah-langkah yang dilakukan dalam kode tersebut:

• from sklearn.metrics import confusion_matrix, classification_report, ConfusionMatrixDisplay: Mengimpor modul dan fungsi yang diperlukan dari sklearn.metrics. confusion_matrix digunakan untuk menghitung matriks kebingungan, classification_report digunakan untuk menghasilkan laporan klasifikasi, dan ConfusionMatrixDisplay digunakan untuk menampilkan matriks kebingungan dengan tampilan yang lebih baik.
• cm = confusion_matrix(validasi.classes, y_classes): Menghitung matriks kebingungan dengan membandingkan kelas sebenarnya (validasi.classes) dengan kelas prediksi (y_classes).
• disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=label): Membuat objek ConfusionMatrixDisplay dengan matriks kebingungan (cm) dan label yang ditentukan (label).
• disp.plot(cmap=plt.cm.Blues): Menampilkan matriks kebingungan dengan menggunakan plot pada objek ConfusionMatrixDisplay. cmap=plt.cm.Blues mengatur skema warna untuk tampilan matriks kebingungan.
• plt.show(): Menampilkan grafik matriks kebingungan.

Dengan menjalankan kode di atas, Anda akan melihat tampilan grafik matriks kebingungan yang memberikan gambaran visual tentang seberapa baik model melakukan prediksi untuk setiap kelas pada data validasi. Matriks kebingungan akan memberikan informasi tentang jumlah data yang terklasifikasikan dengan benar atau salah ke setiap kelas, sementara laporan klasifikasi akan memberikan informasi seperti presisi, recall, dan f1-score untuk setiap kelas.

Kode di atas menggunakan fungsi classification_report dari modul sklearn.metrics untuk menghasilkan laporan klasifikasi dari hasil prediksi model pada data validasi. Berikut adalah penjelasan mengenai hasil laporan klasifikasi yang ditampilkan dalam kode tersebut:

• precision: Menunjukkan tingkat ketepatan dalam memprediksi setiap kelas. Precision dihitung sebagai rasio antara jumlah true positives dan jumlah total prediksi positif (true positives + false positives). Semakin tinggi nilai precision, semakin baik model dalam memprediksi kelas tertentu.
• recall: Menunjukkan tingkat keberhasilan dalam menemukan kembali (recall) setiap kelas. Recall dihitung sebagai rasio antara jumlah true positives dan jumlah total data sebenarnya yang memiliki label positif (true positives + false negatives). Semakin tinggi nilai recall, semakin baik model dalam menemukan kembali data yang sebenarnya positif.
• f1-score: Menggabungkan informasi precision dan recall menjadi satu skor yang mencerminkan keseimbangan antara keduanya. F1-score dihitung sebagai rata-rata harmonik precision dan recall. Semakin tinggi nilai f1-score, semakin baik kinerja model dalam memprediksi kelas tertentu.
• support: Menunjukkan jumlah data yang termasuk dalam setiap kelas.
• accuracy: Menunjukkan tingkat akurasi model, yaitu rasio antara jumlah prediksi yang benar dengan jumlah total prediksi.
• macro avg: Merupakan rata-rata dari metrik precision, recall, dan f1-score dihitung secara individu untuk setiap kelas. Macro avg memberikan perhatian yang sama terhadap setiap kelas.
• weighted avg: Merupakan rata-rata dari metrik precision, recall, dan f1-score dihitung berdasarkan bobot yang ditentukan oleh jumlah data dalam setiap kelas. Weighted avg memberikan bobot yang berbeda-beda terhadap setiap kelas berdasarkan jumlah datanya.

Dalam laporan klasifikasi terdapat informasi tentang precision, recall, dan f1-score untuk setiap kelas. Selain itu, juga diberikan akurasi secara keseluruhan (accuracy), serta rata-rata (macro avg dan weighted avg) dari metrik-metrik tersebut.

Kode di atas adalah contoh implementasi untuk mengupload gambar menggunakan Google Colab, mengubah ukuran gambar menjadi 224x224 piksel, dan melakukan prediksi kelas gambar menggunakan model yang telah dilatih sebelumnya. Berikut adalah penjelasan mengenai langkah-langkah yang dilakukan dalam kode tersebut:

• import numpy as np: Mengimpor modul numpy yang digunakan untuk manipulasi array.
• from google.colab import files: Mengimpor modul files dari Google Colab untuk mengupload gambar.
• from keras.preprocessing import image: Mengimpor modul image dari Keras untuk memproses gambar.
• import keras.utils as image: Mengimpor modul utils dari Keras untuk keperluan pengolahan gambar.
• uploaded = files.upload(): Menggunakan fungsi upload() untuk mengunggah gambar dari komputer ke Google Colab.
• for fn in uploaded.keys():: Melakukan iterasi untuk setiap kunci (nama file) yang diunggah.
• path = fn: Mendefinisikan path (lokasi) file gambar yang diunggah.
• img = image.load_img(path, target_size = (224, 224)): Memuat gambar dari path yang ditentukan dan mengubah ukurannya menjadi 224x224 piksel.
• imgplot = plt.imshow(img): Menampilkan gambar yang diunggah.
• x = image.img_to_array(img): Mengubah gambar menjadi bentuk array.
• x = np.expand_dims(x, axis = 0): Menambahkan dimensi baru pada array gambar.
• images = np.vstack([x]): Menggabungkan array gambar menjadi satu.
• classes = model.predict(images, batch_size = 10): Melakukan prediksi kelas gambar menggunakan model yang telah dilatih sebelumnya.
• if classes[0][0]==1: ...: Melakukan pengecekan pada setiap kelas hasil prediksi dan mencetak kelas yang sesuai dengan prediksi yang diperoleh.

Dengan menjalankan kode di atas, Anda dapat mengunggah gambar dari komputer Anda, dan kode akan menampilkan gambar tersebut beserta prediksi kelas yang dilakukan oleh model. Prediksi kelas dapat berupa "Gambar Benign", "Gambar Early", "Gambar Pre", atau "Gambar Pro" berdasarkan probabilitas tertinggi dari model. Jika tidak ada kelas yang memenuhi ambang batas probabilitas tertentu, maka akan dicetak "Tidak Diketahui".