Klasifikasi Jenis Batik Menggunakan Metode Jaringan Saraf

Konvolusi - Convolutional Neural Network (CNN)

Fahmi Ardiansyah (4611420003)1, Ahmad Syafii (4611420021)2, Ilmaya

Hariani(4611420018)3, Muhammad Zhafran Ammar(4611420029)4, Mhammad
Iqhbal Abdillah(4611420046)5
Program Studi Teknik Informatika
Fakultas Matematika dan Ilmu Pengetahuan Alam
Universitas Negeri Semarang
fahmiardiansyah959@students.unnes.ac.id; ahmadsyafii2751@students,unnes.ac.id,
ilmayahariani@students.unnes.ac.id; email@unnes.ac.
ABSTRAK
Indonesia merupakan negara dengan banyak keanekaragaman di dalamnya. Berbagai
suku, agama, ras, dan budaya hadir di dalamnya dengan mempunyai ciri khas masing-
masing. Indonesia juga memiliki warisan budaya yang telah diakui oleh UNESCO. Batik
merupakan salah satu aset negara yang begitu mahal harganya. Oleh karena itu, semua
kalangan masyarakat harus ikut berperan dalam melestarikan batik ini. Peran generasi
muda dalam pelestarian batik ini juga perlu ditingkatkan karena generasi ini merupakan
pewaris masa depan akan budaya Indonesia. Berbagai jenis batik di Indonesia membuat
generasi muda kesulitan dalam membedakan antara batik satu dengan batik yang lainnya.
Oleh karena itu dibutuhkan sebuah teknologi yang dapat digunakan untuk
mengklasifikasikan antara jenis batik satu dengan batik yang lainnya. Hal ini dapat
ditunjang dengan menggunakan algoritma Convolutional Neural Network (CNN) dalam
mengklasifikasikan jenis batik. Klasifikasi antara jenis batik satu dengan batik lainnya
dapat diukur menggunakan akurasi atau tingkat keakuratan dengan memberikan sampel
data.

1. PENDAHULUAN
Indonesia merupakan negara dengan banyak keanekaragaman di dalamnya.
Indonesia yang terdiri dari ribuan pulau di dalamnya, sehingga Indonesia kaya akan
berbagai suku bangsa, bahasa, dan kebudayaan. Kekayaan yang semacam ini
merupakan suatu hal yang harus selalu dijaga dan dilestarikan supaya dapat dinikmati
oleh generasi yang akan datang.
Indonesia memiliki begitu banyak warisan kebudayaan dari nenek moyang
sebagai identitas bangsa Indonesia salah satunya adalah batik. Batik sudah menjadi ciri
khas dari Indonesia dan sudah diakui oleh UNESCO pada 2 Oktober 2009 sebagai hak
kebudayaan intelektual bangsa Indonesia (Yodha dan Kurniawan, 2014). Warga
Indonesia turut bangga karena batik dapat dikenal oleh dunia luas.
Batik merupakan suatu pola unik dengan unsur ketradisionalan yang diterapkan
pada sebuah kain dan diberi warna dan motif tertentu yang menjadi ciri khas dari
Indonesia itu sendiri (Nurhaida dkk, 2015). Indonesia sendiri memiliki beragam jenis
batik di dalamnya. Selain itu terdapat motif-motif tertentu yang membuat batik tersebut
sulit untuk dikenali. Jika keadaan seperti ini dikhawatirkan akan lunturnya batik dalam
jangka waktu panjang ke depan. Peran kelestarian batik juga terletak pada generasi
muda (Nurcahyadi, 2021). Oleh sebab itu dibutuhkan sebuah teknologi yang dapat
mengklasifikasikan antara batik satu dengan batik yang lain. Metode yang dapat
 digunakan untuk mengklasifikasikan jenis batik ini adalah dengan menggunakan
algoritma Convolutional Neural Network (CNN).
Penelitian ini bertujuan untuk mengklasifikasikan antara jenis batik satu dengan
batik yang lain. Klasifikasi ketepatan antara jenis batik dapat diukur dengan mengetahui
tingkat akurasi pengklasifikasian antara batik satu dengan bati yang lain. Penelitian ini
diharapkan dapat bermanfaat bagi masyarakat umum dan khususnya generasi muda
dalam membantu mengenali jenis batik.

2. METODOLOGI
metode yang digunakan dalam penelitian ini adalah dengan konvolusi jaringan
saraf atau Convolutional Neural Network (CNN).
CNN merupakan sebuah feedforward jaringan saraf tiruan yang memiliki struktur dalam.
CNN juga merupakan salah satu representasi dari deep learning. Algoritma CNN
mempunyai kelebihan yaitu dapat mengenali informasi tersembunyi dari suatu objek
seperti gambar, suara, teks, dan lain sebagainya
CNN terdiri dari neuron (saraf) yang memiliki weight dan fungsi aktivasi. CNN
bekerja menggerakkan kernel konvolusi ke sebuah citra agar didapatkan informasi
representatif yang baru dari hasil perkalian bagian citra tersebut dengan filter yang
digunakan.
Struktur algoritma dari CNN itu terdiri dari :
a. input layer
b. feature extraction layer
● convolutional layer => terdiri dari neuron yang tersusun sedemikisn rupa
sehinga memebentuk filter dengan panjang dan tinggi (pixels).
● Rectified Linear Unit (ReLU) =>menghilangkan vanishing gradient
dengan cara menerapkan fungsi aktivasi elemen, aktivasi elemen
dilakukan saat berada pada ambang batas 0.
● pooling layer => terdiri dari sebuah filter dengan ukuran stride tertentu
yang akan bergeser pada seluruh area feature map. pooling layer akan
mempercepat komputasi karena parameter yang harus di update semakin
sedikit dan mengatasi overfitting. pooling yang biasanya digunakan
adalah Max Pooling dan Average Pooling.
c. classification
● flatten => membentuk ulang fitur (reshape feature map) menjadi sebuah
vektor agar bisa kita gunakan sebagai input dari fully=connected layer.
● fully-connected layer =>feature yang dihasilkan masih berbentuk
multimedia array, sehingga kita harus melakukan “flatten” atau reshape
feature map menjadi sebuah vektor agar bisa kita gunakan sebagai input
dari fully-connected layer.
● softmax => menghitung probabilitas dari setiap kelas target atas semua
kelas target yang memungkinkan dan akan membantu untuk menentukan
kelas target untuk input yang diberikan. softmax menggunakan
eksponensial (e-power) dari nilai input yang diberikan dan jumlah nilai
eksponensial dari semua nilai dalam input. maka rasio eksponensial dari
nilai input dan jumlah eksponensial adalah output dari fungsi softmax.
3. HASIL DAN PEMBAHASAN

SOURCE CODE:

# Library untuk mengimport tensorflow

import tensorflow as tf
print('Versi Tensor Flow yang digunakan adalah versi : ',tf.__version__)
from tensorflow.keras.optimizers import Adam

# Membaca drive dan mengimport file

import zipfile, os
from google.colab import drive
drive.mount('/content/drive')

# Mmelakukan ekstraksi pada file zip

local_zip = '/content/drive/MyDrive/Data Batiknyo.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall('/content')
# Membaca Direktori Awal
base_dir = '/content/Data Batiknyo'
print ("\n Disini terdapat Folder : ")
!ls "/content/Data Batiknyo"
train_dir = os.path.join(base_dir, 'train')
print ('Jumlah Folder pada direktory train : ' , len(os.listdir(train_dir)))

# Membaca direktori pada folder train (class train)

os.listdir(train_dir)
validation_dir = os.path.join(base_dir, 'val')
print ('Jumlah Folder pada direktory val : ' , len (os.listdir(validation_dir)))
# Membaca direktori pada folder val (class val)
os.listdir(validation_dir)
# Membuat direktori Batik pada direktori data TRAINING
train_megamendung_dir = os.path.join(train_dir, 'Batik Megamendung')
train_poleng_dir = os.path.join(train_dir, 'Batik Poleng')
train_parang_dir = os.path.join(train_dir, 'Batik Parang')
# Membuat direktori Batik pada direktori data Testing
validation_megamendung_dir = os.path.join(validation_dir, 'Batik
Megamendung')
validation_poleng_dir = os.path.join(validation_dir, 'Batik Poleng')
validation_parang_dir = os.path.join(validation_dir, 'Batik Parang')

# Membuat Generator untuk tata cara / alur metode pengujian data yang
akan divalidasi / ditesting .
from tensorflow.keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=30,
horizontal_flip = True,
shear_range = 0.3,
fill_mode = 'nearest',
width_shift_range = 0.2 ,
height_shift_range = 0.2,
 zoom_range = 0.1)

test_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=30,
horizontal_flip = True,
shear_range = 0.3,
fill_mode = 'nearest',
width_shift_range = 0.2 ,
height_shift_range = 0.2,
zoom_range = 0.1)

# Mengatur jumlah batch atau pembagian data untuk pemrosesan bitnya

pada train generator dan validator pada gambar yang resolusinya akan
dilatih berdasarkan matriks yang sudah ditentukan.
batch = 32
train_generator = train_datagen.flow_from_directory(
train_dir, # direktori data latih
target_size=(224, 224), # mengubah resolusi seluruh gambar
batch_size=batch,
color_mode="rgb",
class_mode='categorical')

validation_generator = test_datagen.flow_from_directory(
validation_dir, # direktori data validasi
target_size=(224, 224), # mengubah resolusi seluruh gambar
batch_size=batch,
color_mode="rgb",
class_mode='categorical',
shuffle=True)

# Membuat model sekuensial lalu dikonvolusi dengan bantuan fungsi

aktivasi tertentu.
model = tf.keras.models.Sequential([
 tf.keras.layers.Conv2D(16, (3,3),
activation='relu', input_shape=(224, 224, 3)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(32, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),

tf.keras.layers.Flatten(),
tf.keras.layers.Dense(200, activation='relu'),
tf.keras.layers.Dropout(0.3, seed = 112),
tf.keras.layers.Dense(500, activation='relu'),
tf.keras.layers.Dropout(0.5, seed = 112),
tf.keras.layers.Dense(3, activation='softmax') ])
# Menentukan Model Pengoptimalisasi - memakai Fungsi Optimizer adam
dan dengan metric parameternya berdasarkan akurasi.
# Loss dengan kategori karena jumlah class datanya lebih dari 2 ,
tf.keras.optimizers.Adam(learning_rate=lr)
# Compile model dengan 'adam' optimizer loss function
'categorical_crossentropy'
model.compile(loss='categorical_crossentropy',
optimizer='Adam',
metrics=['accuracy'])
# Menentukan epoch jumlah pengetesan.
epoch = 200
# Latih model dengan model.fit
history = model.fit ( train_generator,
steps_per_epoch=train_generator.samples//train_generator.batch_size,

# Berapa batch yang akan dieksekusi pada setiap epoch

epochs=epoch,

# Tambahkan eposchs jika akurasi model belum optimal

validation_data=validation_generator,
# Menampilkan akurasi pengujian
 data validasi
validation_steps=
validation_generator.samples//validation_generator.batch_size,
verbose=1)

# Untuk menampilkan hasilnya kita perlu lib tambhan + plot grafik

import numpy as np
from google.colab import files

from keras.preprocessing import image

import matplotlib.pyplot as plt

import matplotlib.image as mpimg

%matplotlib inline
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

Masing-masing hasilnya terlihat pada grafik dibawah :

● Untuk Batch = 8
 ( Gambar 3. 1 )
Terlihat (Gambar 3. 1) menyatakan bahwa Uji testing Accuracy dan Val
Accuracy mengalami kenaikan namun pada Validation Accuracy rata-ratanya berada di
ambang angka kisaran 0.7 dan 0.8 artinya memiliki nilai persentase sekitaran 70% dan
80% , dengan epoch terakhirnya yaitu bernilai 0.8667 atau 86,667 %.

Semakin epoch-nya naik semakin mengalami kenaikan pula (Overfitting) , setelah epoch
mencapai 100 lebih maka pada grafiknya berubah menjadi (Underfitting) yang dimana
nilainya tidak turun dan naik secara signifikan, namun berada tetap dalam ambang batas
kondisi tersebut.

Untik Loss nya sendiri selalu turun, namun pada Val Loss memiliki grafik tetap
dan frekuensinya gelombang nya sangat tinggi dan cukup signifikan perubahannya mulai
dari 0.5 hingga 1.75 dengan rata-rata Loss-nya adalah 1, kadang naik nya melambung ,
kadang turunnya rendah, maka grafik seperti ini dapat dikatakan tidaklah bagus.

● Untuk batch = 32
 ( Gambar 3. 3 )

Pada percobaan (Gambar 3. 3) diatas dengan mengubah batchnya diperbesar 4 kali dari
semula pada (Gambar 3. 1), dan 2 kali dari batch hasil (Gambar 3. 2) yang awalnya 8
kemudian diubah menjadi 16 kemudian diubah lagi yang ini menjadi 32 agar mengetahui
perbedaannya, Grafik ini terlihat sama saja pada bagian Akurasi untuk Training dan
Validation . Pada bagian Training Loss juga terlihat seperti mirip dan tidak jauh berbeda,
Namun pada Validation Loss ini terlihat mengalami perubahan yang cukup tinggi yang
bertipe Overfitting, kemudian terlihat jelas bahwa Val Loss terus mengalami kenaikan,
maka dapat dinyatakan grafik (Gambar 3. 3) memiliki hasil yang lebih buruk daripada
hasil (Gambar 3.1) serta lebih buruk pula dari hasil (Gambar 3. 2). Dari yang semula 0.5
menjadi berubah 0.25, tetapi maximum-nya berubah juga menjadi 3, dan rata-rata loss
nya diambang angka 1.5, dimana grafik ini terbilang sangat jelek.

● Untuk Batch = 16
sadsadasdsadkjkajcxzcmxzmcksmdkdsmdfasdasdasd
4. KESIMPULAN DAN SARAN
Berdasarkan penelitian diatas, akurasi paling tinggi didapatkan adalah 0,9783
dengan epoch sebesar 200 dan batch sebesar 32. Kemudian lama proses komputasi juga
berdasarkan banyak nya jumlah epoch dan ukuran batch yang digunakan. Berdasarkan
akurasi yang didapatkan bahwa adanya teknologi dapat menunjang para generasi muda
dalam hal mengenai jenis jenis batik.
penelitian ini banyak kekurangannya, sehingga dibutuhkan data yang lebih
banyak untuk mengetahui tingkat keakuratannya atau dengan mengujinya dengan metode
yang berbeda.
 DAFTAR PUSTAKA
J. W. Yodha and A. W. Kurniawan, “Pengenalan Motif Batik Menggunakan
Deteksi Tepi Canny Dan K-Nearest Neighbor,” J. Techno.COM, Vol. 13,
No. 4, Novemb. 2014 251-262, vol. 13, no. 4, pp. 251–262, 2014.
Pattern Recognition Using SIFT Approach,” Procedia Comput. Sci., vol. 59, no.
Iccsci, pp. 567–576, 2015
Nurchayadi, Ghani. 2021. Pelibatan Generasi Muda Jadi Kunci Pelestarian Batik
Sebagai Budaya Identitas Indonesia. diakses dari
https://mediaindonesia.com/humaniora/437067/pelibatan-generasi-muda-
jadi-kunci-pelestarian-batik-sebagai-budaya-identitas-indonesia pada 4 Juni
2022.
J. W. G. Putra. 2019. Pengenalan Konsep Pembelajaran Mesin dan Deep Learning.
vol. 4, pp. 1–235, [Online]. Available:
https://www.researchgate.net/publication/3237 00644.