Bahasa Python

# Mengimpor library yang diperlukan
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Inisialisasi CNN
MesinKlasifikasi = Sequential()

# Langkah 1 - Convolution
MesinKlasifikasi.add(Conv2D(filters = 32, kernel_size=(3, 3), input_shape = (128, 128, 3), activation = 'relu'))

# Langkah 2 - Pooling
MesinKlasifikasi.add(MaxPooling2D(pool_size = (2, 2)))

# Menambah convolutional layer
MesinKlasifikasi.add(Conv2D(32, (3, 3), activation = 'relu'))
MesinKlasifikasi.add(MaxPooling2D(pool_size = (2, 2)))

# Langkah 3 - Flattening
MesinKlasifikasi.add(Flatten())

# Langkah 4 - Full connection
MesinKlasifikasi.add(Dense(units = 128, activation = 'relu'))
MesinKlasifikasi.add(Dense(units = 1, activation = 'sigmoid'))

# Menjalankan CNN
MesinKlasifikasi.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

# Menjalankan CNN ke training dan test set
from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(rescale = 1./255,
                                   shear_range = 0.2,
                                   zoom_range = 0.2,
                                   horizontal_flip = True)

test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = train_datagen.flow_from_directory('dataset/training_set',
                                                 target_size = (128, 128),
                                                 batch_size = 32,
                                                 class_mode = 'binary')

test_set = test_datagen.flow_from_directory('dataset/test_set',
                                            target_size = (128, 128),
                                            batch_size = 32,
                                            class_mode = 'binary')

MesinKlasifikasi.fit_generator(training_set,
                         steps_per_epoch = 8000/32,
                         epochs = 50,
                         validation_data = test_set,
                         validation_steps = 2000/32)

Penjelasan:

• Line 2-6 mengimpor semua library yang diperlukan.
• Sublibrary Sequential digunakan untuk memulai neural networks kita. Hal ini sama seperti kita membuat ANN (artificial neural networks) di pembahasan sebelumnya.
• Sublibrary Convolution2D digunakan untuk memulai CNN di tahap pertama yaitu proses convolution. Karena kita mengolah data berupa gambar maka kita gunakan library convolution khusus untuk 2 dimensi yaitu Convolution2D. Jika kita mengolah data video ganti menjadi Convolution3D. Untuk mengerti apa itu convolution, pembaca bisa membaca kembali teori CNN di artikel saya sebelumnya.
• Sublibrary MaxPooling2D digunakan setelah proses convolution, yaitu dengan mengambil nilai maximumnya (disebut dengan maxpooling). Karena kita mengolah gambar, maka kita gunakan maxpooling untuk 2 dimensi. Untuk mengerti apa itu maxpooling, silakan membaca teori CNN di artikel saya sebelumnya.
• Sublibrary Flatten digunakan untuk proses flattening yang dilakukan setelah proses maxpooling. Untuk mengerti apa itu flattening, silakan membaca teori CNN di artikel saya sebelumnya.
• Sublibrary Dense digunakan untuk mendefinisikan parameter neural networks kita.
• Line 6 kita definisikan objek bernama MesinKlasifikasi yang merupakan objek untuk melakukan proses klasifikasi. Kita gunakan fungsi Sequential untuk memulai inisialisasi.
• Line 9 kita mulai melakukan convolution. Kita mulai dengan menggunakan method add (sama seperti di pembahasan ANN). Setelah itu di dalam tanda kurung add diikuti dengan Convolution2D. Untuk bisa mengetahui parameter apa saja yang diperlukan oleh perintah Convolution2D, arahkan kursor pada namanya kemudian ketik di keyboard CTRL+i. Tampilannya tampak sebagai berikut:

Kita isikan parameter filter=32. Artinya kita akan menggunakan 32 feature detectors yang berukuran 3×3 (kernel_size=(3,3)).

Kemudian kita isi input_shape = (128, 128, 3). Artinya kita ingin semua ukuran gambar yang masuk ke dalam input layer berukuran 128×128 pixels, dan berukuran 3 array. Mengapa 3 array? Karena gambarnya berwarna (lihat materi teori CNN). Jika gambarnya hitam putih maka kita pilih format 2 array.

Tips: Jika kita menggunakan GPU yang kuat (GPU Nvidia yang berharga mahal), maka pembaca bisa meningkatkan dimensi input_shape menjadi (256, 256, 3) misalnya, atau bahkan (512, 512, 3). Dengan demikian gambarnya akan beresolusi besar. Bagaimana jika gambar aslinya berukuran kecil? Jika gambar asalnya kecil, maka akan distretch menjadi besar. Semakin banyak pixel maka akan semakin banyak feature yang bisa ditangkap oleh CNN.

Kemudian kita isi parameter selanjutnya yaitu activation= ‘relu’. Mengapa kita pilih ReLu (rectifier linear unit)? Karena ini adalah fungsi yang umum dipakai untuk ANN dan CNN.

• Line 12 adalah perintah untuk melakukan proses maxpooling. Proses ini adalah tahapan untuk memperkecil ukuran feature maps dengan mencari nilai maksimumnya. Mari kita lihat tampilan parameternya dengan mengklik di keyboard CTRL+i.

Parameter yang kita perlukan adalah pool_size = (2,2). Kita juga menggunakan ukuran yang sama di tampilan gambaran yaitu 2×2 pixels. Dan itu saja parameter yang kita perlukan. Dengan demikian, sekarang analisisnya lebih cepat karena ukuran feature maps sudah mengecil.

• Line 15 & 16 adalah proses untuk ‘mempertajam’ dan ‘meningkatkan’ performa CNN kita, kita tambahkan lagi layer dengan proses convolution dan pooling. Logikanya, hasil feature maps setelah proses maxpooling di line 12, kita buat feature mapsnya lagi, sehingga semakin detail hasil feature maps yang baru. Setelah itu kita lakukan lagi maxpooling untuk memperkecil lagi ukurannya. Dengan demikian feature yang ditangkap benar-benar ‘berisi’ dan compact.
• Line 19 adalah perintah untuk melakukan proses flattening. Seperti yang sudah dibahas di materi CNN sebelumnya, proses ini membuat semua matriks menjadi berukuran single vektor yang akan menjadi input bagi neural networks di depannya. Perintahnya sangat mudah, cukup tulis Flatten().
• Line 22-23 adalah proses ANN seperti bab sebelumnya.
• Line 22 adalah menambah hidden layer. Untuk melakukannya kita tuliskan perintah Dense yang kemudian diikuti dengan tanda kurung units=128. Units=128 artinya ada 128 neuron yang ada di layer ini. Angkanya bebas, silakan bereksperimen. Panduan umumnya adalah jangan terlalu besar (sesuaikan kemampuan hardware komputer), umumnya antara 64-256 untuk CNN (ini juga bukan patokan pasti). Lalu parameter selanjutnya adalah activation=’relu’.
• Line 23 adalah mendefisinikan output layer. Karena hanya ada 2 pilihan (cat/dog, di mana cat=1, dog=0), maka cukup 1 neuron saja (units=1). Karena binary maka activation function yang digunakan adalah sigmoid (baca pembahasan di teknik ANN sebelumnya).
• Line 26 adalah perintah untuk menjalankan arsitektur ANN kita. Sama seperti pembahasan sebelumnya di materi ANN, perintah yang kita perlukan adalah compile. Parameter yang diperlukan adalah optimizer=’adam’, kemudian loss_function= binary_crossentropy, dan metrics=[‘accuracy’]. Perlu diingat karena metrics adalah sebuah list, maka penulisan accuracy harus diapit oleh 2 kurung kotak (squared brackets).
• Line 29 mengimpor sublibrary ImageDataGenerator untuk melakukan image augmentation process. Proses ini digunakan untuk mengurangi overfitting. Jika terjadi overfitting maka performa training set cenderung lebih baik daripada test set.

Mengapa proses ini penting? Jadi ketika CNN kita bisa menangkap pola (feature) di training set, terkadang ia gagal untuk menggeneralisir pola ini untuk observasi lainnya (test set). Mengapa gagal menerapkan pola yang sudah dipelajari di training set? Itu dikarenakan overfitting.

Ada teknik yang direkomendasikan di manual Keras untuk menghindari overfitting yaitu dengan data augmentation (diartikan sebagai memperbanyak data). Untuk mendapatkan pembelajaran yang baik tentunya harus menggunakan data yang banyak. Data yang kita miliki adalah 10000 gambar. Sebenarnya 10rb gambar masih terlalu sedikit, karena untuk komersialisasi produk berbasis CNN biasanya datasetnya berukuran sampai ratusan bahkan puluhan ribu gambar.

Untuk bisa memperbanyak gambar (padahal gambar yang dimiliki sedikit) maka kita gunakan gambar yang ada, kita perbanyak, namun posisinya yang dirubah. Misal gambarnya dimiringkan, diputar, dimirroring, dan seterusnya. Dengan demikian, gambar kita tetap menjadi banyak dan CNN juga tidak mengenali bahwa gambar yang baru itu adalah gambar yang sebenarnya sama. Dengan gambar yang banyak, maka tingkat akurasi bisa ditingkatkan, tanpa mengalami kendala overfitting.

Informasi yang diperlukan untuk bisa melakukan proses data augmentation bisa dilihat di dokumentasi Keras. Silakan lihat di link ini.

Tampilan semua tahapannya dari dokumentasi Keras adalah sebagai berikut:

• Line 31 adalah perintah untuk membuat objek dengan nama train_datagen. Objek train_datagen ini digunakan untuk melatih training set kita (semua gambar di folder training_set). Semua parameter yang kita gunakan persis seperti yang ada di dokumentasi Keras.

Penjelasan parameternya adah sebagai berikut:

Pertama kita hunakan parameter rescale. Di penjelasan sebelumnya (teori CNN) kita sudah mengetahui bahwa nilai pixel adalah antara 1-256 (atau 0-255 dalam python). Dengan konversi menggunakan perintah rescale, datanya menjadi 0-1.

Parameter kedua adalah shear_range untuk mengapkikasikan pergeseran sudur sebesar 0.2. Kita ikuti saja nilai parameter ini sesuai di dokumentasi Keras yaitu 0.2.

Parameter ketiga adalah zoom_range. Merupakan jarak (rentang) zoom yang kita inginkan. Ikuti saja di parameter sesuai di dokumentasi Keras yaitu 0.2.

Parameter terakhir adalah horizontal_flip. Adalah parameter untuk memutar gambar secara horizontal. Dengan demikian, gambar baru hasil augmentation akan berbeda dengan gambar asal karena dibalik (diputar) secara horisontal. Kita set nilainya sebagai True.

• Line 36 kita buat objek dengan nama test_datagen. Objek test_datagen ini digunakan untuk menguji test_set kita (semua gambar di folder test_set). Parameter yang diperlukan (sesuai dengan dokumentasi Keras) hanyalah rescale saja.
• Line 38 mendefinisikan objek training set kita dengan nama training_set. Semua parameter dan perintah yang digunakan sama dengan yang ada di dokumentasi Keras. Yang perlu dirubah hanya direktori folder tempat kita menyiapkan gambarnya saja. Perlu diperhatikan juga bahwa target_size (ukuran gambar) harus sama dengan yang kita definisikan di line 12 yaitu 128×128. Batch_size kita pilih 32, artinya untuk 8000 gambar di training set, akan dibagi menjadi beberapa ukuran dengan isinya masing-masing 32 gambar (ada 8000/32 batch). Kemudian class_mode kita biarkan ‘binary’ karena output layernya hanya binary (0=cat, dan 1=dog).

Setelah kita jalankan maka di bagian console spyder akan mencantumkan tulisan “Found 8000 images belonging to 2 classes.” Artinya kita sudah berhasil mendeteksi direktori training set.

• Line 43 sama dengan line 38, hanya saja kita buat objek test set ktia dengan nama test_set. Direktori foldernya juga kita sesuaikan untuk test set yang kita miliki.

Setelah kita jalankan maka di bagian console spyder akan mencantumkan tulisan “Found 2000 images belonging to 2 classes.” Artinya kita sudah berhasil mendeteksi direktori training set.

• Line 48 adalah langkah terakhir untuk mengaplikasikan CNN kita. Di langkah ini kita mengaplikasikan model kita (MesinKlasifikasi) ke training_set, kemudian memvalidasi hasilnya ke test_set. Semua parameternya bisa dilihat di dokumentasi Keras. Parameter steps_per_epoch diisi dengan jumlah gambar di training_set (8000) dibagi dengan banyaknya file per epoch (32 file), sehingga diisi 8000/32. Kemudian parameter validation_steps diisi dengan jumlah file test_set (2000) dibagi ukuran file per epoch (32) sehingga ditulis (2000/32). Parameter epochs diisi sesuai keinginan kita. Semakin banyak maka akurasi bisa semakin baik, tapi jika sudah converge akurasinya tidak akan naik lagi. Kali ini kita coba nilai 50.

Jika di jalankan, maka tampilannya di syder tampak sebagai berikut:

Bisa dilihat bahwa kita memiliki 50 epoch. Penjelasan untuk setiap nilai di tiap epoch adalah sebagai berikut:

1. Loss menyatakan nilai loss function di training set. Kita menginginkan nilai ini semakin kecil untuk iterasi epoch selanjutnya.
2. Acc menyatakan nilai akurasi di training set. Kita ingin agar nilai ini semakin besar untuk iterasi selanjutnya.
3. Val_loss adalah nilai loss function di test set. Kita ingin agar nilai ini semakin kecil untuk iterasi selanjutnya.
4. Val_acc adalah nilai akurasi di test set. Kita ingin agar nilai ini semakin kecil untuk iterasi selanjutnya.

Kita tunggu beberapa menit sampai mencapai iterasi epoch ke 50. Tampilannya akan menjadi seperti ini (nilainya bisa berbeda untuk komputer lain).

Kita bisa melihat bahwa nilai loss di training set menjadi sangat kecil yaitu 0.0652. Walaupun nilainya sudah 0, namun dari iterasi epoch di atasnya nilai ini masih bisa terus turun (jadi bisa ditambah lagi jumlah epoch-nya).

Kemudian nilai akurasinya sudah sangat tinggi yaitu 97%. Nilai ini juga masih bisa ditingkatkan lagi dengan menambah epoch nya.

Val_loss menunjukkan angka yang juga sangat kecil yaitu 1.03.

Nilai val_acc juga sangat baik yaitu 80.4%. Nilai ini menunjukkan bahwa model CNN kita (MesinKlasifikasi) mampu membedakan gambar cats dan dogs di test_set.

Perlu diperhatikan bahwa jarak antara acc dengan val_acc sebenarnya masih bisa ditingkatkan. Jika jaraknya masih jauh, ada kecenderungan terjadi overfitting. Tentu saja hal ini kita hindari. Ada beberapa pilihan untuk menghindari overfitting selain image augmentation, yaitu:

1. Menambah lagi convolution layer dan max pooling. Kita sudah memiliki 2 convolution layer, di mana setiap layer ini diikuti dengan max pooling. Kita bisa mengurangi jarak antara val_acc dengan acc dengan menambah layer ini.
2. Pilihan kedua adalah menambah fully connected layer yaitu dengan perintah dense (langkah 4, line 24). Dengan demikian kita memiliki berlapi-lapis fully connected layer.

Tentunya pembaca dipersilakan untuk mencoba dan bereksperimen sendiri, dan harus disesuaikan dengan kemampuan CPU maupun GPU.

Untuk melanjutkan membaca silakan klik tombol lanjut ke halaman di bawah ini.

Pages: 1 2 3