Deep Learning dengan Convolutional Neural Network (CNN) pada Google Colaboratory

        Assalamu'alaikum Wr. Wb. pada kesempatan kali ini saya ingin membagikan tutorial membuat program deep learning menggunakan metode CNN pada Google Colaboratory dengan bahasa pemrograman Python. Program yang dibuat pada tutorial ini digunakan untuk melakukan klasifikasi dari tiga varietas beras, yaitu Beras Basmathi, IR-64, dan Ketan. Framework (kerangka kerja) yang digunakan pada tutorial ini menggunakan Keras dan TensorFlow yang dapat diimpor secara langsung pada Google Colab. Arsitektur CNN yang digunakan adalah MobileNetV1 dengan metode Feature Extraction. Feature Extraction itu sendiri adalah teknik mentransfer hasil pelatihan dari arsitektur CNN yang sudah dilatih sebelumnya (pada kasus ini arsitektur MobileNet yang dilatih pada dataset ImageNet). Metode tersebut saya pilih karena dataset yang saya gunakan jumlahnya sangat sedikit.
        Sebelum lanjut ke pembuatan programnya, kita harus tahu terlebih dahulu bagaimana cara menyimpan dataset pada Github dan mengambil dataset tersebut ke tempat penyimpanan sementara yang disediakan oleh Google Colab. Dataset yang kita buat disimpan pada Github agar tidak perlu meng-upload ulang dari awal ke penyimpanan sementara pada Google Colab melainkan hanya menyalin dataset dari Github ke penyimpanan sementara Google Colab tersebut. Jika Anda belum mengerti cara menyimpan dataset pada Github, Anda dapat membuka link tutorial membuat repositori di Github. Jika sudah mengerti langsung saja menuju langkah-langkah pembuatannya.

1. Pertama buka Google Colab dan login ke akun Google milik Anda, jika sudah masuk maka klik "New Notebook" seperti pada tampilan di bawah ini.
   
2. Jika Anda ingin mengubah tampilannya menjadi dark mode/gelap maka dapat diubah dengan cara klik menu "Tools" kemudian pilih "Settings".
   
3. Pada jendela pop up "Settings" ubah pengaturannya seperti pada gambar berikut.
   
4. Tampilan awal dari Google Colaboratory akan tampil seperti berikut.
   
5. Agar proses jalannya program dapat berjalan dengan lebih cepat maka dapat diganti pengaturan jenis runtime-nya menjadi GPU seperti pada gambar.
   
6. Kemudian pilih GPU pada Hardware Accelerator dan klik "SAVE".
   
7. Selanjutnya klik ikon "+ Text" untuk menambahkan baris sel teks/nootebok baru.
   
8. Setelah muncul baris sel teks baru maka Anda dapat mengetik catatan secara langsung.
   
9. Untuk mengubah level heading tulisan dapat dilakukan dengan klik menu heading pada toolbar format text pada baris sel teks atau dengan mengetik "#" pada sel tersebut.
   
10. Untuk memindahkan posisi baris selnya dapat dilakukan dengan klik ikon panah atas untuk menggeser ke atas atau bawah untuk menggeser ke bawah satu baris.
     Notebook baris sel teks 1 :
1. # **Klasifikasi 3 Varietas Beras**
11. Kemudian dilanjutkan membuat program untuk mengambil dataset dari Github pada baris sel kode program, maka tampilannya akan seperti berikut.
    
    Notebook baris sel teks 2 :
1. # Mengambil *Dataset* dari *Github*
Source code program baris sel kode program 1 :
1. !apt-get install subversion > /dev/null
2. !svn export https://github.com/Soedirman-Machine-Learning/rice-varieties-classification/trunk/data > /dev/null
12. Setelah program tersebut dijalankan maka seluruh dataset yang sudah disimpan di Github akan disalin pada browser direktori penyimpanan sementara Google Colab.
    
13. Setelah itu menambah baris sel kode baru di bawahnya dengan klik ikon "+ Code" untuk mengimpor library yang dibutuhkan, setelah dijalankan maka hasil output dari program tersebut akan ditampilkan di bagian bawah tiap baris programnya.
    
    Notebook Subheading Persiapan :
1. Program ini dibuat untuk membedakan 3 varietas beras yaitu :
2. 
   
3. 1.   Varietas Beras Basmathi
4. 2.   Varietas Beras IR 64
5. 3.   Varietas Beras Ketan
6. 
   
7. Pada program ini menggunakan metode *Convolutional Neural Network* (CNN) untuk melakukan klasifikasinya.
Source code program untuk mengimpor library yang dibutuhkan :
1. from __future__ import absolute_import, division, print_function, unicode_literals
2. 
   
3. try:
4.   # The %tensorflow_version magic only works in colab.
5.   %tensorflow_version 2.x
6. except Exception:
7.   pass
8. import numpy as np 
9. import math, os, sys
10. import itertools
11. 
    
12. import matplotlib.pyplot as plt
13. plt.style.use('default')
14. from scipy import ndimage
15. 
    
16. from skimage import measure, morphology
17. from skimage.io import imsave, imread
18. from skimage.filters import threshold_otsu
19. from skimage.transform import resize
20. 
    
21. import tensorflow as tf
22. from sklearn import svm, datasets
23. from sklearn.metrics import confusion_matrix
24. import pandas as pd
14. Selanjutnya menampilkan list file gambar dataset berformat ".jpg" yang diimpor
1. #Perintah di bawah ini untuk melihat list bagian dari file yang sudah diunduh dari Github
2. !ls data/image
3. !ls data/image/train
4. !ls data/image/train/Basmathi
5. !ls data/image/train/IR64
6. !ls data/image/train/Ketan
15. Source code selanjutnya untuk menampilkan sebuah gambar dari data train
1. #Perintah untuk memvisualisasikan satu gambar dari data train
2. image = imread("data/image/train/IR64/I17.jpg")
3. plt.figure(figsize=(3,3))
4. plt.imshow(image)
16. Memuat dataset pelatihan, dataset validasi dan dataset pengujian
1. #Memuat semua gambar ke memori untuk pertama kali
2. 
   
3. #Memuat dataset pelatihan
4. IMAGE_SIZE = 224
5. BATCH_SIZE = 128
6. base_dir = os.path.join('data/image/train')
7. 
   
8. datagen = tf.keras.preprocessing.image.ImageDataGenerator(
9.     rescale=1./255, 
10.     validation_split=0.2)
11. 
    
12. train_generator = datagen.flow_from_directory(
13.     base_dir,
14.     target_size=(IMAGE_SIZE, IMAGE_SIZE),
15.     batch_size=BATCH_SIZE, 
16.     subset='training')
17. 
    
18. val_generator = datagen.flow_from_directory(
19.     base_dir,
20.     target_size=(IMAGE_SIZE, IMAGE_SIZE),
21.     batch_size=BATCH_SIZE, 
22.     subset='validation')
23. 
    
24. #Memuat dataset pengujian
25. X_test = []
26. y_test = []
27. labels = ['Basmathi', 'IR64', 'Ketan']
28. 
    
29. for i,label in enumerate(labels):
30.     folder = os.path.join("data/image/test",label)
31.     files = sorted(os.listdir(folder))
32.     files = [x for x in files if x.endswith(".jpg")]
33.     for k,file in enumerate(files):
34.         image_path = os.path.join(folder, file)
35.         
36.         image = imread(image_path)/255.
37.         image = resize(image,(224,224))
38.         X_test.append(image)
39.         category = os.path.split(folder)[-1]
40.         y_test.append(i)
41. 
    
42. X_test = np.array(X_test)
43. y_test = np.array(y_test)
44. 
    
45. #Menampilkan bentuk dari masing-masing dataset
46. for image_batch, label_batch in train_generator:
47.   break
48. print("Bentuk array dari dataset train (pelatihan) adalah:", image_batch.shape,label_batch.shape)
49. for image_batch, label_batch in val_generator:
50.   break
51. print("Bentuk array dari dataset validation (validasi) adalah:", image_batch.shape,label_batch.shape)
52. print("Bentuk array dari dataset test (pengujian) adalah:", X_test.shape,y_test.shape)
17. Menyimpan label varietas beras secara berurutan dalam format file ".txt"
1. print (train_generator.class_indices)
2. 
   
3. labels_txt = '\n'.join(sorted(train_generator.class_indices.keys()))
4. 
   
5. with open('labels.txt', 'w') as f:
6.   f.write(labels_txt)
1. !cat labels.txt
18. Membuat Model dari Jaringan CNN yang Sudah dipelajari Sebelumnya (pre-trained convnets). Pada tutorial ini menggunakan arsitektur MobileNet, jika Anda ingin menggunakan arsitektur yang lain dapat mengunjungi https://keras.io/applications/.
1. IMG_SHAPE = (224, 224, 3)
2. # Membuat model dasar (base model) dari pre-trained model MobileNet
3. base_model = tf.keras.applications.MobileNet(input_shape=IMG_SHAPE,
4.                                               include_top=False, 
5.                                               weights='imagenet')
19. Notebook Metode Feature Extraction (Transfer Learning)
1. Menggunakan model pre-trained untuk ekstraksi fitur (feature extraction) : Ketika bekerja dengan dataset kecil, adalah umum untuk mengambil keuntungan dari fitur yang dipelajari oleh model yang dilatih pada dataset yang lebih besar dalam domain yang sama. Ini dilakukan dengan membuat contoh model pre-trained dan menambahkan classifier yang sepenuhnya terhubung di atas. Model pre-trained adalah "beku" dan hanya bobot pengklasifikasi yang diperbarui selama pelatihan. Dalam hal ini, basis konvolusional mengekstraksi semua fitur yang terkait dengan setiap gambar dan Anda baru saja melatih classifier yang menentukan kelas gambar mengingat set fitur yang diekstraksi.
Source code Feature Extraction
1. base_model.trainable = False
2. base_model.summary()
20. Mengelompokkan Klasifikasi Tiga Jenis Beras dengan Deep learning Menggunakan Metode Convolutional Neural Network (CNN).
Notebook klasifikasi 3 varietas beras dengan CNN :
1. Sesudah mengimpor dataset, kita akan menggunakan CNN, salah satu arsitektur Deep Learning yang dapat menghandle gambar. Dengan menggunakan Deep CNN, kita dibebaskan dari pendefinisian fitur yang cocok dan hanya memberikan gambar-gambar ke jaringan. CNN akan menentukan fitur yang paling cocok untuk pengklasifikasian.
Library untuk klasifikasi 3 kelas varietas beras :
1. import keras
2. from keras import backend as K
3. from keras.models import Sequential
4. from keras import layers
5. from keras.utils.np_utils import to_categorical
6. 
   
7. from sklearn.model_selection import train_test_split
21. Mempersiapkan Data Masukkan Pengujian
1. y_test2 = to_categorical(y_test)
2. X_test3, y_test3 = (X_test, y_test2)
22. Pembuatan Model (Menambah Model untuk Melakukan Klasifikasi)
1. model = tf.keras.Sequential([
2.     base_model,    
3.     tf.keras.layers.Conv2D(32, 3, activation='relu'),
4.     #tf.keras.layers.Dropout(0.2),
5.     tf.keras.layers.GlobalAveragePooling2D(),
6.     tf.keras.layers.Dense(3, activation='softmax')
7. ])
8. 
   
9. model.compile("adam",loss="categorical_crossentropy",metrics=["acc"])
10. model.summary()
23. Pelatihan Model Arsitektur CNN yang dibuat pada Dataset Pelatihan dan Validasi
1. #from keras.callbacks import EarlyStopping, ModelCheckpoint
2. 
   
3. #Menyimpan file model bobot yang terbaik selama pelatihan (dalam format keras ".h5")
4. #ckpt = ModelCheckpoint("Klasifikasi Beras Tumpukan.h5", monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)
5. history = model.fit_generator(train_generator, 
6.                     epochs=100, 
7.                     validation_data=val_generator)
8. #history = model.fit(x = X_train3, y = y_train3, batch_size=120, epochs= 100,validation_data=(X_valid3,y_valid3),callbacks = [ckpt])
24. Menggambarkan Hasil Pelatihan dalam Bentuk Grafik yang dilakukan Selama 100 Epochs
1. plt.plot(history.history["acc"],label="Akurasi Pelatihan")
2. plt.plot(history.history["val_acc"],label="Validasi Akurasi")
3. plt.legend()
4. plt.show()
5. 
   
6. plt.plot(history.history["loss"],label="Kesalahan Pelatihan")
7. plt.plot(history.history["val_loss"],label="Validasi Kesalahan")
8. plt.legend()
9. plt.show()
25. Menggunakan Model untuk Melihat Hasil Pelatihan antara Dataset Pelatihan dan Validasi.
Source code model hasil pelatihan :
1. #Prediksi Label Validasi dengan Pelatihan
2. n = 44
3. input_image = image_batch[n][np.newaxis,...]
4. print("Labelnya adalah: ", label_batch[n])
5. 
   
6. predictions = model.predict(input_image)
7. print("Prediksinya adalah",predictions[0])
Notebook model hasil pelatihan :
1. Hasil tersebut merupakan hasil prediksi dari training dari 3 jenis data pelatihan yaitu jenis beras Basmathi, IR 64, dan Ketan. Menggunakan inputan gambar dengan piksel 224 x 224, 1 filter dengan fungsi aktivasi relu, dan 1 layer output dengan fungsi aktivasi softmax
26. Evaluasi Model Hasil Pelatihan dengan Dataset Pengujian
1. #Memeriksa matriks model
2. print(model.metrics_names)
3. #Evaluasi data test
4. print(model.evaluate(x= X_test3, y = y_test3))
1. #Menampilkan matriks yang benar dan matriks hasil prediksi
2. 
   
3. #Label yang benar
4. y_true = np.argmax(y_test2,axis=1)
5. 
   
6. #Label prediksi
7. Y_pred = model.predict(X_test)
8. y_pred = np.argmax(Y_pred, axis=1)
9. 
   
10. print(y_true)
11. print(y_pred)
27. Hasil Prediksi dari setiap Gambar Dataset Pengujian
1. n = 44 #Jangan melampaui (nilai dari gambar test - 1)
2. 
   
3. plt.imshow(X_test[n])
4. plt.show()
5. 
   
6. true_label = np.argmax(y_test2,axis=1)[n]
7. print("Label yang benar adalah:",true_label,":",labels[true_label])
8. prediction = model.predict(X_test[n][np.newaxis,...])[0]
9. print("Nilai yang diprediksi adalah:",prediction)
10. predicted_label = np.argmax(prediction)
11. print("Label yang diprediksi adalah:",predicted_label,":",labels[predicted_label])
12. 
    
13. if true_label == predicted_label:
14.     print("Prediksi benar")
15. else:
16.     print("Prediksi salah")
28. Confusion Matrix dari Hasil Pengujian Setiap Dataset Varietas Beras
1. from sklearn.metrics import confusion_matrix
2. from sklearn.utils.multiclass import unique_labels
3. 
   
4. def plot_confusion_matrix(y_true, y_pred, classes,
5.                           normalize=False,
6.                           title=None,
7.                           cmap=plt.cm.Blues):
8.     """
9.     This function prints and plots the confusion matrix.
10.     Normalization can be applied by setting `normalize=True`.
11.     """
12.     if not title:
13.         if normalize:
14.             title = 'Normalized confusion matrix'
15.         else:
16.             title = 'Confusion matrix, without normalization'
17. 
    
18.     # Compute confusion matrix
19.     cm = confusion_matrix(y_true, y_pred)
20.     # Only use the labels that appear in the data
21.     #classes = classes[unique_labels(y_true, y_pred)]
22.     if normalize:
23.         cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
24.         print("Normalized confusion matrix")
25.     else:
26.         print('Confusion matrix, without normalization')
27. 
    
28.     print(cm)
29. 
    
30.     fig, ax = plt.subplots(figsize=(5,5))
31.     im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
32.     #ax.figure.colorbar(im, ax=ax)
33.     # We want to show all ticks...
34.     ax.set(xticks=np.arange(cm.shape[1]),
35.            yticks=np.arange(cm.shape[0]),
36.            # ... and label them with the respective list entries
37.            xticklabels=classes, yticklabels=classes,
38.            title=title,
39.            ylabel='Label Benar',
40.            xlabel='Label Prediksi')
41. 
    
42.     # Rotate the tick labels and set their alignment.
43.     plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
44.              rotation_mode="anchor")
45. 
    
46.     # Loop over data dimensions and create text annotations.
47.     fmt = '.2f' if normalize else 'd'
48.     thresh = cm.max() / 2.
49.     for i in range(cm.shape[0]):
50.         for j in range(cm.shape[1]):
51.             ax.text(j, i, format(cm[i, j], fmt),
52.                     ha="center", va="center",
53.                     color="white" if cm[i, j] > thresh else "black")
54.     fig.tight_layout()
55.     return ax
56. 
    
57. 
    
58. np.set_printoptions(precision=2)
59. 
    
60. plot_confusion_matrix(y_true, y_pred, classes=labels, normalize=True,
61.                       title='Normalized confusion matrix')
29. Menyimpan Hasil Model Pelatihan dan Konversi ke TensorFlow Lite.
Notebook konversi model ke ".tflite"
1. Menyimpan model menggunakan tf.saved_model.save dan kemudian mengonversi model tersimpan ke format yang kompatibel tf lite.
Source code konversi model ke ".tflite"
1. saved_model_dir = 'save/model'
2. tf.saved_model.save(model, saved_model_dir)
3. 
   
4. converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
5. tflite_model = converter.convert()
6. 
   
7. with open('Klasifikasi_3_Varietas_Beras_MobileNet.tflite', 'wb') as f:
8.   f.write(tflite_model)
30. Jika Anda ingin menjalankan seluruh program tersebut dari awal sampai akhir maka dapat menggunakan cara seperti berikut.
    
31. Setelah seluruh program tersebut dijalankan maka akan didapat model hasil pelatihannya yang sudah dikonversi ke dalam format TensorFlow Lite beserta labelnya.
    
32. Untuk menyimpan model dan labelnya dapat dilakukan dengan cara klik kanan pada file model dan labelnya kemudian pada pop up pilih "Download".
    
    
33. Untuk menyimpan program beserta ouput-nya pada Github dapat dilakukan dengan cara membuka menu "File" kemudian pilih "Save a copy in Github".
    
34. Selanjutnya Anda akan diminta masuk ke akun Github milik Anda.
    
35. Masukkan kode verifikasi dari e-mail atau nomor HP Anda (jika ada).
    
36. Kemudian pada jendela pop up "Copy to Github" pilih lokasi repositori Anda dan isi nama file ".ipynb" sesuai keinginan kemudian klik "OK".
    
37. Selesai !!

Catatan :

1. Bingkai textbox yang berwarna oranye merupakan isi pada baris sel Notebook, sedangkan yang berwarna ungu adalah Source code program yang dibuat pada baris sel kode Google Colab.
2. Penulisan Notebook yang Anda buat dapat berbeda sesuai dengan keinginan.
3. Untuk source code lengkapnya dapat dilihat di sini.

Video tutorial hasil pelatihannya dapat dilihat di bawah.

Terima kasih atas kunjungannya :)))
Tutorial selanjutnya adalah menerapkan model hasil pelatihan CNN di postingan ini pada perangkat Android pada link berikut.