Sistem Isyarat Bahasa Indonesia (SIBI) Menggunakan Convolutional Neural Network (CNN) | by Kelompok 3 (Farid, Komariah, Yusup) | Jun, 2024

Untuk membuat program yang dapat mengenali Sistem Isyarat Bahasa Indonesia (SIBI) menggunakan Convolutional Neural Community (CNN), kita memerlukan beberapa komponen penting seperti knowledge gambar dari isyarat tangan, preprocessing knowledge, mannequin CNN, pelatihan mannequin, dan evaluasi mannequin. Berikut ini adalah penjelasan dan contoh supply code sederhana untuk implementasi tersebut.

1. Pengumpulan Knowledge dan Preprocessing:

– dataset gambar yang berisi isyarat tangan untuk setiap huruf atau kata dalam SIBI. Dataset ini bisa didapatkan dari web site kaggle. Whole dataset yg di gunakan ada 2600 gambar.

– Sebelum knowledge gambar dapat digunakan untuk pelatihan mannequin, kita perlu melakukan preprocessing seperti resize gambar, normalisasi nilai pixel, dan pembagian dataset menjadi coaching dan testing set.

2) Mannequin CNN:
– CNN adalah jenis neural community yang sangat efektif untuk pengenalan gambar. Mannequin ini terdiri dari beberapa lapisan konvolusi, pooling, dan totally linked.

3) Pelatihan dan Evaluasi:
– Mannequin dilatih menggunakan knowledge coaching dengan augmentasi gambar untuk meningkatkan generalisasi.

– Pada program ini knowledge dibagi menjadi set pelatihan (80%) dan validasi (20%).

– Augmentasi knowledge diterapkan (rescaling dan zoom) untuk meningkatkan variasi knowledge pelatihan.

– Mannequin dievaluasi menggunakan knowledge testing untuk mengukur akurasi. Tingkat akurasi yg di gunakan pada program ini 60%

PENJELASAN SOURCE CODE SIBI

KODE 1

!pip set up kaggle

Perintah !pip set up kaggle adalah perintah yang digunakan untuk menginstal paket Python bernama kaggle menggunakan pip (bundle installer for Python). Kaggle adalah platform on-line yang menyediakan kompetisi knowledge science, dataset, dan alat untuk analisis knowledge. Dengan menginstal paket kaggle, pengguna dapat mengakses API Kaggle untuk mengunduh dataset, mengirimkan hasil kompetisi, dan melakukan berbagai operasi lain yang terkait dengan platform Kaggle langsung dari lingkungan pemrograman Python.

KODE 2

from google.colab import information

information.add ()

· from google.colab import information: Ini mengimpor modul information dari pustaka google.colab, yang berisi fungsi untuk mengelola file dalam lingkungan Google Colab.

· information.add(): Memanggil metode add dari modul information, yang membuka dialog unggahan file di browser. Pengguna dapat memilih file dari komputer lokal mereka untuk diunggah ke lingkungan Google Colab

KODE 3,4, dan 5

!mkdir ~/.kaggle

!cp kaggle.json ~/.kaggle

!chmod 600 ~/.kaggle/kaggle.json

from google.colab import drive

drive.mount(‘/content material/drive’)

!mkdir -p /content material/drive/MyDrive/sibi

%cd /content material/drive/MyDrive/sibi

· Perintah ini membuat direktori .kaggle di dalam direktori dwelling pengguna jika direktori tersebut belum ada.

· Perintah ini menyalin file kaggle.json (yang harus berada di direktori kerja saat ini) ke dalam direktori .kaggle.

· Perintah ini memastikan bahwa hanya pemilik file yang dapat membaca dan menulis file kaggle.json, yang meningkatkan keamanan kredensial API Anda

· Mengimpor modul drive dari pustaka google.colab, yang berisi fungsi untuk mengelola Google Drive di Colab.

· Memanggil metode mount dari modul drive dan menetapkan titik mount di /content material/drive. Ketika perintah ini dijalankan, Anda akan diminta untuk memberikan izin akses ke akun Google Drive Anda. Setelah memberikan izin, semua file dan folder di Google Drive Anda akan tersedia di bawah direktori /content material/drive.

· !mkdir -p /content material/drive/MyDrive/sibi Perintah ini akan membuat sebuah direktori baru bernama “sibi” di dalam jalur “/content material/drive/MyDrive/”. Flag -p memastikan bahwa semua direktori induk yang diperlukan akan dibuat jika belum ada. Ini berguna untuk membuat struktur folder yang lengkap dalam satu perintah

· %cd /content material/drive/MyDrive/sibi Perintah ini akan mengubah direktori kerja saat ini ke “/content material/drive/MyDrive/sibi”. Dengan kata lain, ini akan memindahkan “lokasi” kerja Anda ke dalam folder “sibi” yang baru saja dibuat.

KODE KE 6

!kaggle datasets obtain -d mrifqiazkiyaj/sibidatasets

Perintah ini akan mencoba mengunduh dataset bernama “sibidatasets” yang dibuat oleh pengguna “mrifqiazkiyaj” dari Kaggle

KODE KE 7

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import cv2

import os

import tensorflow as tf

import seaborn as sns

· import numpy as np Ini mengimpor library NumPy dan memberikannya alias ‘np’. NumPy digunakan untuk komputasi numerik yang efisien dalam Python, terutama untuk operasi array dan matriks.

· import pandas as pd Mengimpor library Pandas dengan alias ‘pd’. Pandas sangat berguna untuk manipulasi dan analisis knowledge, terutama untuk knowledge terstruktur seperti tabel atau time sequence.

· import matplotlib.pyplot as plt Mengimpor modul pyplot dari Matplotlib dengan alias ‘plt’. Matplotlib adalah library untuk membuat visualisasi knowledge dan grafik dalam Python.

· import cv2 Mengimpor library OpenCV. OpenCV (Open Supply Pc Imaginative and prescient Library) digunakan untuk pemrosesan gambar dan tugas laptop imaginative and prescient.

· import os Mengimpor modul os, yang menyediakan fungsi-fungsi untuk berinteraksi dengan sistem operasi, seperti manipulasi path file dan direktori.

· import tensorflow as tf Mengimpor TensorFlow, sebuah library open-source untuk machine studying dan deep studying.

· import seaborn as sns Mengimpor Seaborn, sebuah library visualisasi knowledge berbasis Matplotlib yang menyediakan antarmuka tingkat tinggi untuk membuat grafik statistik yang menarik.

KODE KE 8

from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D

from keras.fashions import Sequential

from keras.preprocessing.picture import ImageDataGenerator

from google.colab.patches import cv2_imshow

1. import numpy as np Ini mengimpor library NumPy dan memberikannya alias ‘np’. NumPy digunakan untuk komputasi numerik yang efisien dalam Python, terutama untuk operasi array dan matriks.
2. import pandas as pd Mengimpor library Pandas dengan alias ‘pd’. Pandas sangat berguna untuk manipulasi dan analisis knowledge, terutama untuk knowledge terstruktur seperti tabel atau time sequence.
3. import matplotlib.pyplot as plt Mengimpor modul pyplot dari Matplotlib dengan alias ‘plt’. Matplotlib adalah library untuk membuat visualisasi knowledge dan grafik dalam Python.
4. import cv2 Mengimpor library OpenCV. OpenCV (Open Supply Pc Imaginative and prescient Library) digunakan untuk pemrosesan gambar dan tugas laptop imaginative and prescient.
5. import os Mengimpor modul os, yang menyediakan fungsi-fungsi untuk berinteraksi dengan sistem operasi, seperti manipulasi path file dan direktori.
6. import tensorflow as tf Mengimpor TensorFlow, sebuah library open-source untuk machine studying dan deep studying.
7. import seaborn as sns Mengimpor Seaborn, sebuah library visualisasi knowledge berbasis Matplotlib yang menyediakan antarmuka tingkat tinggi untuk membuat grafik statistik yang menarik.

KODE KE 9

# Get and extract file Extract

source_path = ‘/content material/drive/MyDrive/sibi/sibidatasets.zip’

dataset_path = “/content material/datasets/”

from zipfile import ZipFile

zf = ZipFile(source_path)

zf.extractall(dataset_path)

zf.shut()

1. source_path = ‘/content material/drive/MyDrive/sibi/sibidatasets.zip’ Ini mendefinisikan path ke file zip yang berisi dataset. File ini berada di Google Drive Anda, di folder ‘sibi’.
2. dataset_path = “/content material/datasets/” Ini mendefinisikan path tujuan di mana isi file zip akan diekstrak.
3. from zipfile import ZipFile Ini mengimpor kelas ZipFile dari modul zipfile, yang akan digunakan untuk membuka dan mengekstrak file zip.
4. zf = ZipFile(source_path) Ini membuat objek ZipFile dari file zip yang ditentukan oleh source_path.
5. zf.extractall(dataset_path) Ini mengekstrak semua isi file zip ke direktori yang ditentukan oleh dataset_path.
6. zf.shut() Ini menutup file zip setelah selesai diekstrak.

Tujuan dari kode ini adalah untuk mengekstrak dataset yang telah Anda unduh sebelumnya (mungkin dari Kaggle) dari file zip ke lokasi yang dapat diakses oleh kode Anda.

KODE KE 10

from sklearn.preprocessing import MultiLabelBinarizer

labels = [“A”, “B”, “C”, “D”, “E”, “F”, “G”, “H”, “I”, “J”, “K”, “L”, “M”, “N”, “O”, “P”, “Q”, “R”, “S”, “T”, “U”, “V”, “W”, “X”, “Y”, “Z”]

mlb = MultiLabelBinarizer()

mlb.match(labels)

mlb.classes_

Tujuan dari kode ini adalah untuk menyiapkan sistem encoding untuk label-label yang akan digunakan dalam proyek. Dalam konteks ini, bekerja dengan dataset yang melibatkan huruf-huruf alfabet, mungkin untuk pengenalan huruf atau kata dalam bahasa isyarat (mengingat nama dataset “sibidatasets” yang mungkin merujuk pada SIBI — Sistem Isyarat Bahasa Indonesia).

MultiLabelBinarizer berguna ketika Anda memiliki tugas klasifikasi multi-label, di mana satu sampel bisa termasuk dalam beberapa kelas sekaligus. Meskipun dalam kasus ini Anda hanya menggunakan huruf tunggal, penggunaan MultiLabelBinarizer memberi fleksibilitas untuk kasus di mana satu sampel mungkin terdiri dari beberapa huruf.

KODE KE 11

data_dir = ‘/content material/datasets/coaching’

target_size = (64,64)

courses = 26

batch_size = 32

from PIL import ImageFile

ImageFile.LOAD_TRUNCATED_IMAGES = True

train_datagen = ImageDataGenerator(rescale=1./255,

zoom_range=0.1,

horizontal_flip=False,

validation_split=0.2)

train_gen = train_datagen.flow_from_directory(data_dir, target_size=target_size,

shuffle=True,

batch_size= batch_size,

color_mode=’grayscale’,

class_mode=’categorical’,

subset=’coaching’)

val_gen = train_datagen.flow_from_directory(data_dir, target_size=target_size,

batch_size= batch_size,

color_mode=’grayscale’,

class_mode=’categorical’,

subset=’validation’)

1. Pengaturan awal:

• data_dir = ‘/content material/datasets/coaching’: Menentukan direktori knowledge pelatihan.
• target_size = (64,64): Menentukan ukuran goal gambar (64×64 piksel).
• courses = 26: Jumlah kelas (mungkin merujuk pada 26 huruf alfabet).
• batch_size = 32: Ukuran batch untuk pelatihan.

2. from PIL import ImageFile dan ImageFile.LOAD_TRUNCATED_IMAGES = True: Ini memungkinkan loading gambar yang mungkin rusak atau tidak lengkap.

3. Membuat ImageDataGenerator:

train_datagen = ImageDataGenerator(rescale=1./255,

zoom_range=0.1,

horizontal_flip=False,

validation_split=0.2)

• rescale=1./255: Mengubah skala nilai piksel ke rentang 0–1.
• zoom_range=0.1: Menerapkan zoom acak hingga 10%.
• horizontal_flip=False: Tidak melakukan flip horizontal.
• validation_split=0.2: Menggunakan 20% knowledge untuk validasi.

4. Membuat generator knowledge pelatihan:

· train_gen = train_datagen.flow_from_directory(data_dir,

· target_size=target_size,

· shuffle=True,

· batch_size=batch_size,

· color_mode=’grayscale’,

· class_mode=’categorical’,

· subset=’coaching’)

Ini membuat generator untuk knowledge pelatihan dengan pengaturan spesifik.

5. Membuat generator knowledge validasi:

val_gen = train_datagen.flow_from_directory(data_dir,

target_size=target_size,

batch_size=batch_size,

color_mode=’grayscale’,

class_mode=’categorical’,

subset=’validation’)

Ini membuat generator untuk knowledge validasi dengan pengaturan serupa.

Poin-poin penting:

• Knowledge gambar diubah menjadi grayscale dan diubah ukurannya menjadi 64×64 piksel.
• Augmentasi knowledge diterapkan (rescaling dan zoom) untuk meningkatkan variasi knowledge pelatihan.
• Knowledge dibagi menjadi set pelatihan (80%) dan validasi (20%).
• Label diatur sebagai ‘categorical’, cocok untuk klasifikasi multi-kelas.

KODE KE 12

epoch = 50

train_size = len(train_gen)

steps_per_epoch = 32

validation_steps = 9

· epoch = 50

Ini menentukan jumlah epoch untuk pelatihan mannequin.

Sebuah epoch adalah satu kali proses melewatkan seluruh dataset melalui mannequin (baik untuk ahead cross maupun backward cross).

Menetapkan 50 epoch berarti mannequin akan melihat seluruh dataset sebanyak 50 kali selama proses pelatihan.

· train_size = len(train_gen)

Ini menghitung jumlah batch dalam generator knowledge pelatihan.

len(train_gen) akan memberikan jumlah batch yang akan dihasilkan oleh generator untuk satu epoch lengkap.

· steps_per_epoch = 32

Ini menentukan berapa banyak batch yang akan diproses dalam satu epoch.

Nilai 32 di sini mungkin dipilih berdasarkan pertimbangan tertentu atau mungkin hasil dari perhitungan sebelumnya.

Biasanya, steps_per_epoch seharusnya sama dengan train_size, tetapi bisa diatur lebih kecil jika Anda ingin epoch berakhir sebelum seluruh dataset diproses.

· validation_steps = 9

Ini menentukan berapa banyak batch dari generator validasi yang akan digunakan untuk evaluasi di akhir setiap epoch.

Nilai 9 mungkin dipilih berdasarkan ukuran dataset validasi atau pertimbangan lain.

KODE KE 13

x,y = train_gen.subsequent()

for i in vary(0,3):

picture = x[i]

label = y[i]

print(x[i].form)

print (label)

plt.imshow(picture[:,:,0], cmap=’grey’)

plt.present()

· x, y = train_gen.subsequent()

Ini mengambil batch berikutnya dari generator knowledge pelatihan.

x akan berisi batch gambar.

y akan berisi label yang sesuai untuk gambar-gambar tersebut.

· for i in vary(0,3):

Ini memulai loop yang akan berjalan 3 kali, untuk menampilkan 3 gambar pertama dari batch.

· Di dalam loop:

picture = x[i]: Mengambil gambar ke-i dari batch.

label = y[i]: Mengambil label ke-i yang sesuai.

· print(x[i].form)

Ini akan mencetak bentuk (form) dari gambar ke-i.

Bentuknya kemungkinan akan berupa (64, 64, 1) karena Anda menggunakan mode grayscale dan ukuran goal 64×64.

· print(label)

Ini akan mencetak label untuk gambar ke-i.

Label akan dalam format one-hot encoding karena Anda menggunakan class_mode=’categorical’.

· plt.imshow(picture[:,:,0], cmap=’grey’)

Ini menampilkan gambar menggunakan matplotlib.

picture[:,:,0] mengambil channel pertama (dan satu-satunya) dari gambar grayscale.

cmap=’grey’ menentukan bahwa gambar harus ditampilkan dalam skala abu-abu.

· plt.present()

Ini menampilkan plot yang telah dibuat.

KODE KE 14

def CNN():

#inisiasi CNN

mannequin = Sequential()

#Convolution dan Max Pooling

mannequin.add(Conv2D(32, (3, 3), input_shape=(64,64,1), activation=’relu’))

mannequin.add(MaxPooling2D(pool_size=(2, 2))) # 2×2 is perfect

mannequin.add(Dropout(0.5))

mannequin.add(Conv2D(64, (3, 3), activation=’relu’))

mannequin.add(MaxPooling2D(pool_size=(2, 2)))

mannequin.add(Conv2D(128, (3, 3), activation=’relu’))

mannequin.add(MaxPooling2D(pool_size=(2, 2)))

mannequin.add(Dropout(0.5))

mannequin.add(Conv2D(256, (3, 3), activation=’relu’))

mannequin.add(MaxPooling2D(pool_size=(2, 2)))

#Flattening

mannequin.add(Flatten())

#Dense atau Full Connection

mannequin.add(Dropout(0.5))

mannequin.add(Dense(512, activation=’relu’))

mannequin.add(Dropout(0.5))

mannequin.add(Dense(models = 26, activation = ‘softmax’))

return mannequin

Menjelaskan fungsi CNN() ini dalam bahasa Indonesia. Fungsi ini mendefinisikan arsitektur Convolutional Neural Community (CNN) untuk tugas klasifikasi gambar:

1. mannequin = Sequential(): Inisialisasi mannequin Sequential dari Keras.
2. Layer-layer konvolusi dan pooling:

• Layer 1: Conv2D(32, (3, 3), input_shape=(64,64,1), activation=’relu’): 32 filter konvolusi 3×3, enter 64×64 piksel grayscale. MaxPooling2D(pool_size=(2, 2)): Pooling 2×2 untuk mengurangi dimensi.
• Dropout(0.5): Dropout 50% untuk mengurangi overfitting.
• Layer 2: Conv2D(64, (3, 3), activation=’relu’): 64 filter konvolusi 3×3. MaxPooling2D(pool_size=(2, 2))
• Layer 3: Conv2D(128, (3, 3), activation=’relu’): 128 filter konvolusi 3×3. MaxPooling2D(pool_size=(2, 2))
• Dropout(0.5)
• Layer 4: Conv2D(256, (3, 3), activation=’relu’): 256 filter konvolusi 3×3. MaxPooling2D(pool_size=(2, 2))

1. Flatten(): Mengubah output konvolusi menjadi vektor 1D.
2. Absolutely linked layers:

• Dropout(0.5)
• Dense(512, activation=’relu’): Layer totally linked dengan 512 neuron.
• Dropout(0.5)
• Dense(models = 26, activation = ‘softmax’): Layer output dengan 26 neuron (satu untuk setiap huruf alfabet), menggunakan aktivasi softmax untuk klasifikasi multi-kelas.

Beberapa poin penting:

• Arsitektur ini cukup dalam dengan 4 layer konvolusi, yang baik untuk menangkap fitur kompleks.
• Penggunaan Dropout yang intensif (50% setelah beberapa layer) menunjukkan upaya kuat untuk mencegah overfitting.
• Layer terakhir memiliki 26 unit, sesuai dengan jumlah kelas (huruf A-Z).
• Aktivasi ReLU digunakan di semua layer kecuali output, yang menggunakan softmax untuk klasifikasi multi-kelas.

Mannequin ini tampaknya dirancang untuk tugas klasifikasi huruf bahasa isyarat, dengan mempertimbangkan kompleksitas tugas dan kebutuhan untuk generalisasi yang baik.

KODE KE 15

SibiKlasifikasi = CNN()

SibiKlasifikasi = CNN()

Kode ini melakukan hal berikut:

1. Memanggil fungsi CNN() yang telah Anda definisikan sebelumnya.
2. Fungsi CNN() mengembalikan mannequin neural community yang telah dikonfigurasi.
3. Mannequin yang dikembalikan kemudian disimpan dalam variabel bernama SibiKlasifikasi.

Implikasi dan penjelasan lebih lanjut:

• SibiKlasifikasi sekarang adalah sebuah objek mannequin Keras yang berisi arsitektur CNN yang telah Anda definisikan.
• Mannequin ini siap untuk digunakan, tetapi belum dilatih. Ini seperti kerangka kosong yang sudah memiliki struktur tetapi belum memiliki pengetahuan.
• Nama SibiKlasifikasi menunjukkan bahwa mannequin ini dimaksudkan untuk klasifikasi SIBI (Sistem Isyarat Bahasa Indonesia).

Langkah-langkah selanjutnya yang biasanya dilakukan setelah ini adalah:

1. Mengompilasi mannequin dengan menentukan optimizer, loss operate, dan metrik.
2. Melatih mannequin menggunakan knowledge coaching yang telah Anda siapkan.
3. Mengevaluasi mannequin menggunakan knowledge validasi atau testing.
4. Menggunakan mannequin untuk membuat prediksi pada knowledge baru.

KODE KE 16

SibiKlasifikasi.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’])

SibiKlasifikasi.abstract()

1. SibiKlasifikasi.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’]) Baris ini mengompilasi mannequin SibiKlasifikasi dengan konfigurasi berikut:

• Optimizer: ‘adam’ — Adam adalah optimizer yang adaptif dan efisien, populer untuk deep studying.
• Loss operate: ‘categorical_crossentropy’ — Ini adalah fungsi loss yang cocok untuk klasifikasi multi-kelas dengan output one-hot encoded.
• Metrics: [‘accuracy’] — Akurasi akan digunakan sebagai metrik untuk mengevaluasi performa mannequin selama pelatihan dan validasi.

1. SibiKlasifikasi.abstract() Baris ini akan mencetak ringkasan arsitektur mannequin, termasuk:

• Urutan layer-layer dalam mannequin
• Output form dari setiap layer
• Jumlah parameter (bobot) yang dapat dilatih di setiap layer
• Whole jumlah parameter dalam mannequin

Output dari abstract() akan terlihat seperti tabel yang menunjukkan setiap layer, bentuk outputnya, dan jumlah parameternya. Ini sangat berguna untuk:

• Memverifikasi bahwa arsitektur mannequin sesuai dengan yang diinginkan
• Memeriksa jumlah complete parameter untuk memastikan mannequin tidak terlalu besar atau terlalu kecil untuk tugas yang diberikan
• Memahami bentuk output di setiap tahap mannequin

KODE KE 17

!pip set up keras

!pip set up pydot

!pip set up graphviz

from tensorflow.keras.utils import plot_model # Import plot_model from tensorflow.keras.utils

plot_model(SibiKlasifikasi, to_file=’model_plot.png’, show_shapes=True, show_layer_names=True)

Tujuan dari kode ini adalah:

1. Memastikan semua dependensi yang diperlukan terinstal.
2. Membuat visualisasi grafis dari arsitektur mannequin CNN Anda.

Hasil dari kode ini akan berupa file gambar ‘model_plot.png’ yang menunjukkan struktur mannequin Anda secara visible. Gambar ini akan menampilkan:

• Setiap layer dalam mannequin
• Koneksi antar layer
• Bentuk output dari setiap layer
• Nama setiap layer

Visualisasi ini sangat berguna untuk:

• Memahami aliran knowledge melalui mannequin
• Memverifikasi arsitektur mannequin
• Mempresentasikan struktur mannequin kepada orang lain

Perlu diingat bahwa untuk menjalankan kode ini dengan sukses, Anda mungkin perlu memiliki Graphviz terinstal di sistem Anda. Jika Anda menggunakan Google Colab, ini biasanya sudah terinstal.

KODE KE 18

historical past = SibiKlasifikasi.match(train_gen,

steps_per_epoch = steps_per_epoch,

epochs = epoch,

validation_data = val_gen,

validation_steps = validation_steps)

Kode ini melatih mannequin SibiKlasifikasi yang telah Anda buat sebelumnya. Mari kita bahas setiap bagiannya:

1. historical past = SibiKlasifikasi.match(…)

• Metode match() digunakan untuk melatih mannequin.
• Hasil pelatihan disimpan dalam variabel historical past, yang akan berisi informasi tentang proses pelatihan.

1. Parameter yang digunakan dalam metode match(): a. train_gen

• Ini adalah generator knowledge pelatihan yang Anda buat sebelumnya menggunakan ImageDataGenerator.
• Generator ini akan menyediakan batch gambar dan label yang sesuai untuk pelatihan.

b. steps_per_epoch = steps_per_epoch

• Menentukan berapa banyak batch yang akan diproses dalam satu epoch.
• Nilai ini seharusnya sudah Anda tetapkan sebelumnya.

c. epochs = epoch

• Jumlah epoch (iterasi penuh melalui seluruh knowledge pelatihan) yang akan dilakukan.
• Nilai epoch seharusnya sudah Anda tetapkan sebelumnya, misalnya 50.

d. validation_data = val_gen

• Generator untuk knowledge validasi.
• Digunakan untuk mengevaluasi mannequin setelah setiap epoch.

e. validation_steps = validation_steps

• Menentukan berapa banyak batch dari generator validasi yang akan digunakan untuk evaluasi di akhir setiap epoch.
• Nilai ini seharusnya sudah Anda tetapkan sebelumnya.

Setelah kode ini dijalankan:

• Mannequin akan mulai proses pelatihan.
• Untuk setiap epoch, mannequin akan melalui knowledge pelatihan dan kemudian melakukan validasi.
• Progres pelatihan akan ditampilkan, biasanya menunjukkan metrik seperti loss dan akurasi untuk knowledge pelatihan dan validasi.
• Setelah selesai, historical past akan berisi informasi tentang performa mannequin selama pelatihan, yang dapat digunakan untuk membuat plot atau analisis lebih lanjut.

Proses ini mungkin memakan waktu cukup lama, tergantung pada ukuran dataset, kompleksitas mannequin, dan kemampuan komputasi yang tersedia.

KODE KE 19

SibiKlasifikasi.save(‘my_model.keras’) # Save the educated mannequin SibiKlasifikasi

SibiKlasifikasi.save(‘my_model.keras’)

Kode ini berfungsi untuk menyimpan mannequin yang telah dilatih ke dalam file. Mari kita bahas lebih element:

1. SibiKlasifikasi: Ini adalah objek mannequin yang telah Anda latih sebelumnya.
2. .save(): Ini adalah metode yang digunakan untuk menyimpan mannequin Keras.
3. ‘my_model.keras’: Ini adalah nama file yang akan digunakan untuk menyimpan mannequin. File akan disimpan dengan ekstensi .keras.

Tujuan dan implikasi dari kode ini:

1. Menyimpan Mannequin:

• Seluruh arsitektur mannequin, termasuk konfigurasi layer dan bobot yang telah dilatih, akan disimpan.

1. Portabilitas:

• Mannequin yang disimpan dapat dimuat kembali nanti atau di mesin lain tanpa perlu melatih ulang.

1. Backup:

• Ini berfungsi sebagai backup dari mannequin Anda, melindungi hasil pelatihan dari kehilangan knowledge.

1. Deployment:

• Mannequin yang disimpan dapat digunakan untuk deployment di aplikasi atau sistem lain.

1. Format File:

• Format .keras adalah format baru yang diperkenalkan dalam TensorFlow 2.x untuk menyimpan mannequin Keras.

Setelah menjalankan kode ini, Anda akan menemukan file baru bernama my_model.keras di direktori kerja Anda. File ini berisi seluruh informasi yang diperlukan untuk merekonstruksi mannequin Anda

KODE KE 20

import pytz

import shutil

import os # Import os module to work with file paths

model_path = ‘/content material/drive/MyDrive/sibi’

# Confirm if the file exists earlier than copying

if os.path.exists(“my_model.keras”):

shutil.copy(“my_model.keras”, os.path.be a part of(model_path, “e50.h5”))

print(“File copied efficiently.”)

else:

print(“File ‘my_model.keras’ not discovered.”)

1. Import modul yang diperlukan:

python

Copy

import pytz

import shutil

import os

• pytz untuk bekerja dengan zona waktu (meskipun tidak digunakan dalam kode ini).
• shutil untuk operasi file tingkat tinggi seperti penyalinan file.
• os untuk bekerja dengan path file dan direktori.

1. Menentukan path tujuan:

python

Copy

model_path = ‘/content material/drive/MyDrive/sibi’

• Ini menentukan direktori tujuan di mana mannequin akan disalin.

1. Memeriksa keberadaan file dan menyalinnya:

python

Copy

if os.path.exists(“my_model.keras”):

shutil.copy(“my_model.keras”, os.path.be a part of(model_path, “e50.h5”))

print(“File copied efficiently.”)

else:

print(“File ‘my_model.keras’ not discovered.”)

• os.path.exists(“my_model.keras”) memeriksa apakah file “my_model.keras” ada di direktori saat ini.
• Jika file ada:
• shutil.copy() digunakan untuk menyalin file.
• File sumber adalah “my_model.keras”.
• File tujuan adalah “e50.h5” di dalam direktori yang ditentukan oleh model_path.
• os.path.be a part of() digunakan untuk menggabungkan path secara aman.
• Jika file tidak ditemukan, pesan error dicetak.

Beberapa poin penting:

1. Kode ini mengubah nama file dari “my_model.keras” menjadi “e50.h5” saat menyalinnya.
2. “.h5” adalah format file yang umum digunakan untuk menyimpan mannequin Keras/TensorFlow.
3. Penamaan “e50” mungkin mengindikasikan bahwa mannequin ini dilatih untuk 50 epoch.
4. Kode ini mengasumsikan bahwa Anda memiliki akses write ke direktori Google Drive yang ditentukan.

Tujuan utama dari kode ini adalah untuk memindahkan mannequin yang telah disimpan ke lokasi yang lebih permanen di Google Drive Anda, sambil mengubah namanya. Ini berguna untuk organisasi dan manajemen mannequin, terutama jika Anda bekerja di lingkungan seperti Google Colab di mana file lokal mungkin tidak persisten

KODE KE 21

acc = historical past.historical past[‘accuracy’]

val_acc = historical past.historical past[‘val_accuracy’]

loss = historical past.historical past[‘loss’]

val_loss = historical past.historical past[‘val_loss’]

epochs = vary(len(acc))

plt.plot(epochs, acc, ‘r’, label=’Coaching accuracy’)

plt.plot(epochs, val_acc, ‘b’, label=’Validation accuracy’)

plt.title(‘Coaching and validation accuracy’)

plt.xlabel(‘Epoch’)

plt.ylabel(‘Accuracy’)

plt.legend()

plt.determine()

plt.plot(epochs, loss, ‘r’, label=’Coaching Loss’)

plt.plot(epochs, val_loss, ‘b’, label=’Validation Loss’)

plt.title(‘Coaching and validation loss’)

plt.xlabel(‘Epoch’)

plt.ylabel(‘Loss’)

plt.legend()

plt.present()

· acc = historical past.historical past[‘accuracy’] Mengambil knowledge akurasi pelatihan dari objek historical past dan menyimpannya ke variabel acc.

· val_acc = historical past.historical past[‘val_accuracy’] Mengambil knowledge akurasi validasi dan menyimpannya ke val_acc.

· loss = historical past.historical past[‘loss’] Mengambil knowledge loss pelatihan dan menyimpannya ke loss.

· val_loss = historical past.historical past[‘val_loss’] Mengambil knowledge loss validasi dan menyimpannya ke val_loss.

· epochs = vary(len(acc)) Membuat checklist berisi angka dari 0 hingga jumlah epoch pelatihan.

· plt.plot(epochs, acc, ‘r’, label=’Coaching accuracy’) Membuat plot garis merah untuk akurasi pelatihan.

· plt.plot(epochs, val_acc, ‘b’, label=’Validation accuracy’) Membuat plot garis biru untuk akurasi validasi.

· plt.title(‘Coaching and validation accuracy’) Menambahkan judul pada grafik.

· plt.xlabel(‘Epoch’) dan plt.ylabel(‘Accuracy’) Menambahkan label pada sumbu x dan y.

· plt.legend() Menampilkan legenda grafik.

· plt.determine() Membuat determine baru untuk grafik kedua.

· plt.plot(epochs, loss, ‘r’, label=’Coaching Loss’) Membuat plot garis merah untuk loss pelatihan.

· plt.plot(epochs, val_loss, ‘b’, label=’Validation Loss’) Membuat plot garis biru untuk loss validasi.

· plt.title(‘Coaching and validation loss’) Menambahkan judul pada grafik kedua.

· plt.xlabel(‘Epoch’) dan plt.ylabel(‘Loss’) Menambahkan label pada sumbu x dan y grafik kedua.

· plt.present() Menampilkan kedua grafik yang telah dibua

KODE KE 22

dataset_path = “/content material/datasets/”

Variabel:

• Kode ini mendefinisikan sebuah variabel bernama dataset_path.

Nilai:

• Variabel ini diberi nilai string “/content material/datasets/”.

Tujuan:

• Variabel ini biasanya digunakan untuk menyimpan path (jalur) ke lokasi di mana dataset disimpan.

Konteks:

• “/content material/” biasanya merujuk pada direktori root di Google Colab.
• Ini menunjukkan bahwa kode mungkin dijalankan di lingkungan Google Colab.

Penggunaan:

• Variabel ini kemungkinan akan digunakan nanti dalam kode untuk mengakses file-file dataset.
• Misalnya, jika ada file gambar bernama “image1.jpg” di folder datasets, bisa diakses dengan dataset_path + “image1.jpg”.

KODE KE 23

def getLabel(label, model_label):

for i, x in enumerate(model_label):

if x >= 0.6:

return label[i]

else :

return (“Gambar bukan abjad SIBI”)

1. Tujuan: Fungsi ini tampaknya digunakan untuk menginterpretasikan output dari mannequin klasifikasi, mungkin untuk pengenalan huruf SIBI (Sistem Isyarat Bahasa Indonesia).
2. Parameter:

• label: Kemungkinan sebuah checklist yang berisi label-label kelas (misalnya huruf-huruf SIBI).
• model_label: Kemungkinan output dari mannequin, berupa checklist probabilitas untuk setiap kelas.

1. Threshold: Fungsi menggunakan threshold 0.6 (60%) untuk menentukan apakah prediksi cukup yakin.
2. Perilaku:

• Jika ada probabilitas >= 60%, fungsi mengembalikan label yang sesuai.
• Jika tidak ada probabilitas yang mencapai 60%, fungsi menganggap enter bukan huruf SIBI yang legitimate.

1. Batasan: Fungsi ini hanya mengembalikan label pertama yang memenuhi threshold. Jika ada a number of probabilitas di atas 60%, hanya yang pertama yang akan dipertimbangkan.
2. Penggunaan: Fungsi ini mungkin digunakan setelah mannequin membuat prediksi, untuk menginterpretasikan hasil prediksi tersebut ke dalam label yang bermakna.

Fungsi ini memberikan cara sederhana untuk menginterpretasikan output mannequin klasifikasi, dengan mempertimbangkan tingkat keyakinan prediksi.

KODE KE 24

import shutil

model_path = ‘/content material/drive/MyDrive/sibi’

shutil.copy(os.path.be a part of(model_path, “my_model.keras”), “model_sign_e60.keras”)

Tujuan kode ini:

1. Mengakses mannequin yang disimpan di Google Drive.
2. Menyalin mannequin tersebut ke lingkungan Colab saat ini dengan nama baru.

Hal ini berguna ketika Anda ingin menggunakan mannequin yang telah disimpan sebelumnya di Google Drive tanpa mengubah file asli.

KODE KE 25

SibiKlasifikasi = CNN()

SibiKlasifikasi.load_weights(“model_sign_e60.keras”)

· Tujuan: Kode ini bertujuan untuk memuat mannequin CNN yang telah dilatih sebelumnya untuk klasifikasi SIBI (Sistem Isyarat Bahasa Indonesia).

· Proses:

1. Pertama, struktur mannequin didefinisikan ulang dengan memanggil CNN().
2. Kemudian, bobot-bobot yang telah dilatih sebelumnya dimuat ke dalam struktur mannequin ini.

· Mengapa dilakukan seperti ini:

1. Mendefinisikan struktur mannequin terlebih dahulu memastikan bahwa struktur mannequin cocok dengan bobot yang akan dimuat.
2. Memuat bobot yang telah dilatih memungkinkan mannequin untuk langsung melakukan prediksi tanpa perlu dilatih ulang.

· Keuntungan:

1. Menghemat waktu karena tidak perlu melatih mannequin dari awal.
2. Memungkinkan penggunaan mannequin yang telah dioptimalkan dan divalidasi sebelumnya.

KODE KE 26

SibiKlasifikasi.compile(optimizer=’adam’, loss=’categorical_crossentropy’, metrics=[‘accuracy’])

SibiKlasifikasi.abstract()

· Kompilasi Mannequin:

• Meskipun kita telah memuat bobot yang sudah dilatih, kompilasi tetap penting jika kita ingin melakukan evaluasi atau fine-tuning pada mannequin.
• Kompilasi mendefinisikan cara mannequin akan dioptimasikan jika kita memutuskan untuk melatih ulang atau menyesuaikan mannequin.

· Ringkasan Mannequin:

• Mencetak ringkasan mannequin sangat berguna untuk: a. Memverifikasi bahwa struktur mannequin sesuai dengan yang diharapkan. b. Melihat jumlah complete parameter dalam mannequin. c. Memahami bagaimana knowledge mengalir melalui berbagai layer dalam mannequin.

· Penggunaan:

• Kompilasi diperlukan sebelum kita dapat menggunakan metode seperti consider() atau match() pada mannequin.
• Ringkasan mannequin membantu dalam debugging dan memahami arsitektur mannequin.

KODE KE 27

!rm -rf datasets/testingv3/.ipynb_checkpoints

Menghapus folder .ipynb_checkpoints dan semua isinya dari direktori datasets/testingv3/.

Konteks dan penjelasan lebih lanjut:

1. .ipynb_checkpoints adalah folder yang dibuat oleh Jupyter untuk menyimpan versi cadangan dari pocket book.
2. Folder ini sering dihapus karena:

• Bisa mengambil ruang penyimpanan yang tidak perlu.
• Bisa menyebabkan kebingungan saat mengelola file dataset.
• Umumnya tidak diperlukan untuk disimpan atau diversion-contr

KODE KE 28

dataset_path = “/content material/datasets/testingv3”

dir_list = os.listdir(dataset_path)

print(“Information and directories in ‘“, dataset_path, “‘ :”)

print(dir_list)

Tujuan dan konteks kode ini:

1. Memeriksa isi dari direktori dataset pengujian.
2. Memverifikasi bahwa file-file yang diharapkan ada di sana.
3. Memberikan informasi tentang struktur dataset kepada pengguna atau pengembang.

Hasil yang diharapkan:

• Kode ini akan mencetak daftar semua file dan subdirektori yang ada di dalam folder “/content material/datasets/testingv3”.
• Ini bisa termasuk file gambar, subdirektori, atau file lain yang relevan dengan dataset pengujian.

Penggunaan dalam konteks ML:

1. Verifikasi Knowledge: Memastikan bahwa semua file yang diperlukan untuk pengujian ada di tempatnya.
2. Eksplorasi Dataset: Memahami struktur dan konten dataset sebelum memulai proses pengujian.
3. Debugging: Jika ada masalah dengan loading knowledge, ini bisa membantu mengidentifikasi apakah masalahnya ada pada path atau ketersediaan file.

KODE KE 29

data_test = os.listdir(dataset_path)

hasil = []

for x in data_test:

img = cv2.imread(dataset_path + “/” +x)

img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

resize = cv2.resize(img, dsize=(64, 64))

img = np.expand_dims(resize, axis=0)

predict = SibiKlasifikasi.predict(img)

label = (x, getLabel(mlb.classes_, predict[0]))

hasil.append(label)

hasil

Penjelasan :

• Tujuan: Kode ini melakukan prediksi untuk setiap gambar dalam dataset pengujian dan menyimpan hasilnya.
• Proses:

1. Membaca setiap gambar.
2. Pra-pemrosesan gambar (konversi ke grayscale, resize).
3. Melakukan prediksi menggunakan mannequin.
4. Menginterpretasikan hasil prediksi.
5. Menyimpan hasil dalam format (nama_file, prediksi).

1. Mannequin SibiKlasifikasi telah dimuat dan dikompilasi sebelumnya.
2. Fungsi getLabel() telah didefinisikan untuk menginterpretasikan output mannequin.
3. mlb.classes_ mungkin adalah checklist kelas yang digunakan oleh mannequin (mungkin huruf-huruf SIBI).

• Hasil:
• hasil akan berisi checklist tuple, di mana setiap tuple memiliki format (nama_file, prediksi_kelas).
• Penggunaan:
• Kode ini berguna untuk melakukan batch testing pada dataset dan mengumpulkan hasil prediksi untuk analisis lebih lanjut.

KODE KE 30

hasil.kind()

hitung = 0

y_pred = []

true_labels = []

for x in hasil:

keys = x[0]

huruf = keys.cut up(‘ ‘)

y_pred.append(x[1])

true_labels.append(huruf[0])

if huruf[0] == x[1]:

hitung += 1

print(‘True’, keys)

else:

print(‘False’)

print()

print(“Jumlah Prediksi Check benar adalah {}”.format(hitung))

Penjelasan lebih lanjut:

• Tujuan: Kode ini mengevaluasi akurasi prediksi mannequin dengan membandingkan hasil prediksi dengan label sebenarnya yang diasumsikan ada dalam nama file.
• Asumsi:

1. Nama file mengandung label sebenarnya sebagai huruf pertama sebelum spasi.
2. Format tuple dalam hasil adalah (nama_file, prediksi).

1. Mengurutkan hasil untuk konsistensi.
2. Mengekstrak prediksi dan label sebenarnya.
3. Membandingkan prediksi dengan label sebenarnya.
4. Menghitung dan mencetak jumlah prediksi yang benar.

• Output:
• Untuk setiap file, akan dicetak ‘True’ atau ‘False’ tergantung pada kebenaran prediksi.
• Di akhir, jumlah complete prediksi yang benar akan dicetak.
• Catatan:
• Ada indentasi yang tidak tepat dalam kode asli. Blok if seharusnya berada di dalam loop for.
• Variabel keys digunakan dalam print assertion di luar blok if, yang mungkin menyebabkan error.

Perbaikan yang disarankan:

hasil.kind()

hitung = 0

y_pred = []

true_labels = []

for x in hasil:

keys = x[0]

huruf = keys.cut up(‘ ‘)

y_pred.append(x[1])

true_labels.append(huruf[0])

if huruf[0] == x[1]:

hitung += 1

print(‘True’, keys)

else:

print(‘False’, keys)

print()

print(“Jumlah Prediksi Check benar adalah {}”.format(hitung))

Kode ini memberikan evaluasi dasar dari performa mannequin pada dataset pengujian, menghitung jumlah prediksi yang benar dan memberikan gambaran cepat tentang akurasi mannequin.

KODE KE 31

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report

#Testing Report

print(‘Classification Report’)

print(classification_report(true_labels, y_pred))

cm = confusion_matrix(true_labels, y_pred)

Penjelasan lebih lanjut:

1. Classification Report:

• Precision: Proporsi prediksi positif yang benar.
• Recall: Proporsi kasus positif aktual yang diidentifikasi dengan benar.
• F1-score: Rata-rata harmonik dari precision dan recall.
• Help: Jumlah sampel untuk setiap kelas.

1. Confusion Matrix:

• Matrix yang menunjukkan jumlah prediksi benar dan salah untuk setiap kelas.
• Baris menunjukkan label sebenarnya, kolom menunjukkan prediksi.

Kegunaan:

1. Evaluasi Mannequin: Memberikan gambaran menyeluruh tentang performa mannequin pada berbagai metrik.
2. Analisis Per-Kelas: Memungkinkan identifikasi kelas-kelas yang mannequin performanya baik atau buruk.
3. Identifikasi Kesalahan: Confusion matrix membantu memahami jenis kesalahan yang dibuat mannequin.

KODE KE 32

plt.rc(‘font’, measurement=40)

fig, ax = plt.subplots(figsize=(40,40))

disp = ConfusionMatrixDisplay(cm, display_labels=mlb.classes_)

disp = disp.plot(ax=ax)

plt.present()

Penjelasan lebih lanjut:

• Ukuran dan Font:
• Pengaturan ukuran font dan determine yang besar (40) bertujuan untuk membuat plot mudah dibaca, terutama jika ada banyak kelas.
• Confusion Matrix Show:
• Visualisasi ini menunjukkan jumlah prediksi untuk setiap kombinasi label sebenarnya dan prediksi.
• Diagonal utama menunjukkan prediksi yang benar.
• Off-diagonal menunjukkan kesalahan klasifikasi.
• Kegunaan:

1. Visualisasi Performa: Memungkinkan Anda melihat secara cepat di mana mannequin bekerja dengan baik dan di mana terjadi kesalahan.

2. Identifikasi Pola Kesalahan: Membantu mengidentifikasi jika ada kelas-kelas tertentu yang sering salah diklasifikasikan satu sama lain.

3. Evaluasi Mannequin: Memberikan gambaran visible tentang akurasi mannequin secara keseluruhan dan per-kelas.

• Interpretasi:
• Kotak-kotak gelap di diagonal menunjukkan klasifikasi yang akurat.
• Kotak-kotak terang di luar diagonal menunjukkan kesalahan klasifikasi.
• Semakin gelap warnanya, semakin banyak sampel dalam kategori tersebut.
• Catatan:
• mlb.classes_ diasumsikan berisi label-label kelas yang digunakan dalam mannequin. Pastikan ini sesuai dengan urutan kelas dalam confusion matrix.
• Ukuran plot yang sangat besar (40×40 inci) mungkin sulit ditampilkan di beberapa layar. Anda mungkin perlu menyesuaikan ukuran tergantung pada jumlah kelas dan preferensi tampilan.

Visualisasi ini sangat berharga untuk memahami performa mannequin secara mendalam, terutama dalam kasus klasifikasi multi-kelas seperti pengenalan huruf SIBI. Ini memungkinkan Anda untuk dengan cepat mengidentifikasi kekuatan dan kelemahan mannequin Anda.