Topeng Bali adalah salah satu warisan budaya yang kaya dan mendalam dari Indonesia, merepresentasikan berbagai karakter dan cerita dalam upacara dan pertunjukan tradisional. Dalam period digital ini, teknologi machine studying dapat membantu kita untuk lebih memahami dan mengklasifikasikan jenis-jenis topeng tersebut dengan lebih efektif. Pada artikel ini, kita akan membahas bagaimana menggunakan mannequin VGG16 yang telah dilatih dengan bobot dari ImageNet untuk mengklasifikasikan topeng Bali berdasarkan dataset yang tersedia di Kaggle.
Bali, dengan segala keindahan dan kekayaan budayanya, memiliki berbagai bentuk seni yang unik, salah satunya adalah topeng. Topeng-topeng ini tidak hanya digunakan dalam seni pertunjukan, tetapi juga memiliki makna non secular dan ritual yang mendalam. Mengingat keragaman dan kompleksitas dari jenis-jenis topeng Bali, pengenalan otomatis menggunakan teknologi machine studying menjadi tantangan yang menarik sekaligus penting.
Pada proyek ini, saya menggunakan dataset dari Kaggle yang terdiri dari tujuh kelas topeng Bali: bujuh, dalem, keras, penasar, sidakarya, tua, dan wijil. Dengan menggunakan arsitektur jaringan syaraf konvolusional (Convolutional Neural Community — CNN) yang populer, VGG16, dan memanfaatkan bobot yang sudah dilatih sebelumnya dari ImageNet, kita akan membangun mannequin klasifikasi yang mampu mengenali dan membedakan jenis-jenis topeng ini.
Proses yang akan dibahas dalam artikel ini mencakup persiapan dataset, preprocessing gambar, dan pelatihan mannequin menggunakan VGG16. Dengan demikian, kita akan mendapatkan pemahaman yang lebih baik tentang bagaimana teknologi dapat digunakan untuk mendukung pelestarian dan pemahaman budaya kita.
Proses yang dilakukan dalam undertaking ini adalah untuk mempersiapkan dataset yang akan digunakan untuk pelatihan mannequin klasifikasi topeng Bali menggunakan VGG16. Berikut adalah langkah-langkah yang diambil beserta penjelasannya:
- Import Library dan Definisi Path
import os
import matplotlib.pyplot as plt
import shutil
from sklearn.model_selection import train_test_split
import numpy as np
from PIL import Picture
Pada langkah ini, kita mengimpor library yang diperlukan untuk manipulasi file, visualisasi knowledge, dan pengelolaan gambar. Library yang digunakan antara lain adalah os untuk operasi file, matplotlib.pyplot untuk visualisasi grafis, shutil untuk operasi file system, sklearn.model_selection.train_test_split untuk membagi dataset menjadi prepare set, validation set, dan take a look at set, numpy untuk manipulasi knowledge numerik, dan PIL.Picture untuk manipulasi gambar.
2. Visualisasi Jumlah Gambar dalam Setiap Kelas
# Baca nama folder (kelas) dan hitung jumlah gambar dalam setiap kelas
class_folders = os.listdir(image_path)
class_counts = []for class_folder in class_folders:
class_path = os.path.be a part of(image_path, class_folder)
if os.path.isdir(class_path):
num_images = len(os.listdir(class_path))
class_counts.append((class_folder, num_images))
# Visualisasikan nama kelas beserta jumlah gambar dalam grafik
plt.determine(figsize=(10, 6))
bars = plt.bar([x[0] for x in class_counts], [x[1] for x in class_counts], shade='skyblue')
plt.xlabel('Kelas')
plt.ylabel('Jumlah Gambar')
plt.title('Jumlah Gambar dalam Setiap Kelas')
# Tambahkan label jumlah gambar pada setiap batang
for bar in bars:
yval = bar.get_height()
plt.textual content(bar.get_x() + bar.get_width()/2, yval, int(yval), va='backside')
plt.xticks(rotation=45, ha='proper')
plt.tight_layout()
plt.present()
Langkah ini bertujuan untuk menghitung dan memvisualisasikan jumlah gambar yang ada dalam setiap kelas (folder) di dataset awal. Grafik bar menunjukkan distribusi gambar per kelas, memberi pemahaman awal tentang seberapa seimbang atau tidaknya dataset.
3. Pembersihan dan Pembagian Dataset
def clean_folders():
for folder in [train_path, valid_path, test_path]:
if os.path.exists(folder):
shutil.rmtree(folder)clean_folders()
for path in [train_path, valid_path, test_path]:
os.makedirs(path, exist_ok=True)
for class_folder in class_folders:
class_path = os.path.be a part of(image_path, class_folder)
if os.path.isdir(class_path):
recordsdata = os.listdir(class_path)
train_files, test_valid_files = train_test_split(recordsdata, test_size=0.4, random_state=42)
valid_files, test_files = train_test_split(test_valid_files, test_size=0.5, random_state=42)
for file in train_files:
src = os.path.be a part of(class_path, file)
dest = os.path.be a part of(train_path, class_folder)
os.makedirs(dest, exist_ok=True)
shutil.copy(src, dest)
for file in valid_files:
src = os.path.be a part of(class_path, file)
dest = os.path.be a part of(valid_path, class_folder)
os.makedirs(dest, exist_ok=True)
shutil.copy(src, dest)
for file in test_files:
src = os.path.be a part of(class_path, file)
dest = os.path.be a part of(test_path, class_folder)
os.makedirs(dest, exist_ok=True)
shutil.copy(src, dest)
Di sini, kita memastikan bahwa folder prepare, legitimate, dan take a look at dibersihkan terlebih dahulu sebelum membagi dataset. Kemudian, dataset dipecah menjadi prepare set, validation set, dan take a look at set dengan mempertahankan proporsi jumlah gambar setiap kelas. Penggunaan train_test_split dari sklearn.model_selection memastikan bahwa proses pembagian dilakukan secara acak dengan mempertahankan distribusi yang seimbang antara setiap kelas.
4. Visualisasi Jumlah Gambar per Kelas di Setiap Folder
class_counts = {'prepare': {}, 'legitimate': {}, 'take a look at': {}}def count_images_per_class(folder_path, folder_name):
class_folders = os.listdir(folder_path)
for class_folder in class_folders:
class_path = os.path.be a part of(folder_path, class_folder)
if os.path.isdir(class_path):
num_images = len(os.listdir(class_path))
class_counts[folder_name][class_folder] = num_images
count_images_per_class(train_path, 'prepare')
count_images_per_class(valid_path, 'legitimate')
count_images_per_class(test_path, 'take a look at')
Langkah ini bertujuan untuk menghitung kembali jumlah gambar per kelas setelah dibagi ke dalam prepare set, validation set, dan take a look at set. Dengan melakukan ini, kita dapat memastikan bahwa dataset yang dibagi memiliki distribusi yang seimbang, yang penting untuk melatih mannequin yang baik.
Berikut adalah langkah-langkah untuk melatih mannequin klasifikasi topeng Bali menggunakan arsitektur VGG16 dan TensorFlow:
- Import Library dan Definisi Path
import os
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.picture import ImageDataGenerator
from tensorflow.keras.functions import VGG16
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.fashions import Mannequin
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau, CSVLogger# Menonaktifkan verifikasi sertifikat SSL secara international (hanya untuk tujuan demonstrasi, bukan praktek yang disarankan)
tf.keras.utils.get_file = lambda *args, **kwargs: get_file(*args, **kwargs, ssl_verify=False)
Di sini, kita mengimpor semua library yang dibutuhkan untuk membangun dan melatih mannequin, termasuk TensorFlow, ImageDataGenerator untuk preprocessing gambar, arsitektur VGG16 dari keras.functions, serta komponen-komponen lain seperti Dense layers untuk output, dan callbacks seperti EarlyStopping, ModelCheckpoint, ReduceLROnPlateau, dan CSVLogger untuk monitoring dan manajemen pelatihan.
2. Pengaturan ImageDataGenerator dan Mills untuk Dataset
# Definisikan path ke folder dataset
dataset_path = 'dataset'# Inisialisasi ImageDataGenerator untuk preprocessing gambar
datagen = ImageDataGenerator(
rescale=1./255, # Normalisasi knowledge gambar
rotation_range=20, # Rentang rotasi gambar
width_shift_range=0.2, # Pergeseran lebar gambar
height_shift_range=0.2, # Pergeseran tinggi gambar
shear_range=0.2, # Pergeseran gambar
zoom_range=0.2, # Zoom gambar
horizontal_flip=True, # Putar gambar secara horizontal
fill_mode='nearest' # Mode pengisian untuk gambar yang diubah
)
# Membuat generator untuk setiap set knowledge (prepare, validation, take a look at)
train_generator = datagen.flow_from_directory(
os.path.be a part of(dataset_path, 'prepare'),
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
shuffle=True
)
valid_generator = datagen.flow_from_directory(
os.path.be a part of(dataset_path, 'legitimate'),
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
shuffle=False
)
test_generator = datagen.flow_from_directory(
os.path.be a part of(dataset_path, 'take a look at'),
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
shuffle=False
)
Pada langkah ini, kita menggunakan ImageDataGenerator untuk melakukan augmentasi knowledge seperti rotasi, pergeseran, dan flip pada gambar. Generator-generator yang dibuat (train_generator, valid_generator, test_generator) akan digunakan untuk memasukkan knowledge gambar ke dalam mannequin selama pelatihan, validasi, dan pengujian.
3. Membangun Mannequin VGG16
# Membuat mannequin VGG16
base_model = VGG16(weights='imagenet', include_top=False) # Mengambil output layer dari mannequin
x = base_model.output
# Menambahkan international common pooling layer
x = GlobalAveragePooling2D()(x)
# Menambahkan totally related layer dengan 1024 neuron
x = Dense(1024, activation='relu')(x)
# Menambahkan output layer dengan 7 neuron (sesuaikan dengan jumlah kelas Anda)
predictions = Dense(7, activation='softmax')(x)
# Membuat mannequin dengan enter dari base mannequin dan output dari layer yang baru ditambahkan
mannequin = Mannequin(inputs=base_model.enter, outputs=predictions)
# Membekukan semua layer di mannequin VGG16 agar tidak terlatih ulang
for layer in base_model.layers:
layer.trainable = False
# Kompilasi mannequin dengan optimizer Adam dan loss perform categorical crossentropy
mannequin.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
Di sini, kita membangun arsitektur mannequin dengan menggunakan VGG16 sebagai base mannequin, mengambil output dari base mannequin, menambahkan layer-layer tambahan seperti GlobalAveragePooling2D dan Dense layers untuk output, dan kemudian membuat mannequin dengan Mannequin API dari TensorFlow. Kita juga membekukan semua layer di VGG16 agar tidak terlatih ulang (switch studying).
4. Pelatihan Mannequin
# Menambahkan EarlyStopping untuk menghentikan pelatihan jika tidak ada peningkatan dalam validasi loss
early_stopping = EarlyStopping(monitor='val_loss', verbose=1, endurance=3, restore_best_weights=True)# Menyimpan bobot terbaik selama pelatihan
checkpoint = ModelCheckpoint('best_model.h5', verbose=1, monitor='val_loss', save_best_only=True, mode='min')
# Menyimpan log pelatihan ke file CSV
csv_logger = CSVLogger('training_log.csv')
# Mengurangi studying fee jika tidak ada peningkatan dalam validasi loss
reduce_lr = ReduceLROnPlateau(monitor='val_loss', issue=0.2, endurance=5, min_lr=0.001)
# Melatih mannequin dengan generator knowledge, menyimpan callback untuk monitoring dan mengatur epochs
historical past = mannequin.match(
train_generator,
epochs=50,
validation_data=valid_generator,
callbacks=[early_stopping, checkpoint, csv_logger, reduce_lr]
)
Langkah ini melibatkan proses pelatihan mannequin menggunakan generator knowledge yang telah disiapkan sebelumnya. Kita menggunakan EarlyStopping untuk menghentikan pelatihan jika tidak ada peningkatan dalam validasi loss, ModelCheckpoint untuk menyimpan bobot mannequin terbaik, CSVLogger untuk mencatat log pelatihan ke file CSV, dan ReduceLROnPlateau untuk mengurangi studying fee jika tidak ada peningkatan dalam validasi loss.
5. Evaluasi Mannequin dan Visualisasi Performa
# Memuat bobot terbaik untuk evaluasi
mannequin.load_weights('best_model.h5')# Evaluasi mannequin pada knowledge validasi
valid_predictions = mannequin.predict(valid_generator)
valid_pred_classes = np.argmax(valid_predictions, axis=1)
valid_true_classes = valid_generator.lessons
# Menghitung metrik-metrik evaluasi seperti accuracy, precision, recall, dan F1-score
accuracy = accuracy_score(valid_true_classes, valid_pred_classes)
precision = precision_score(valid_true_classes, valid_pred_classes, common='weighted')
recall = recall_score(valid_true_classes, valid_pred_classes, common='weighted')
f1 = f1_score(valid_true_classes, valid_pred_classes, common='weighted')
print("Accuracy:", accuracy)
print("Precision:", precision)
print("Recall:", recall)
print("F1 Rating:", f1)
Output :
3/3 [==============================] — 13s 3s/step
Accuracy: 1.0
Precision: 1.0
Recall: 1.0 F1 Rating: 1.0
Pada tahap ini, kita mengambil bobot terbaik dari mannequin yang telah dilatih dan mengevaluasi performanya pada knowledge validasi menggunakan metrik-metrik evaluasi seperti accuracy, precision, recall, dan F1-score.
6. Visualisasi Loss dan Accuracy selama Pelatihan
# Membaca log pelatihan dari file CSV
import pandas as pd
log_data = pd.read_csv('training_log.csv')# Membuat grafik untuk visualisasi loss dan accuracy selama pelatihan
plt.determine(figsize=(12, 6))
# Plot loss
plt.subplot(1, 2, 1)
plt.plot(log_data['epoch'], log_data['loss'], label='Coaching Loss')
plt.plot(log_data['epoch'], log_data['val_loss'], label='Validation Loss')
plt.title('Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
# Plot accuracy
plt.subplot(1, 2, 2)
plt.plot(log_data['epoch'], log_data['accuracy'], label='Coaching Accuracy')
plt.plot(log_data['epoch'], log_data['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.present()
Visualisasi ini membantu kita untuk melihat bagaimana loss dan accuracy mannequin berubah selama proses pelatihan, baik pada knowledge pelatihan maupun validasi.
7. Confusion Matrix dan Classification Report
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns# Melakukan prediksi pada knowledge uji
y_pred = mannequin.predict(test_generator)
y_pred_classes = np.argmax(y_pred, axis=1)
# Mendapatkan label sebenarnya dari knowledge uji
true_classes = test_generator.lessons
class_labels = record(test_generator.class_indices.keys())
# Menampilkan laporan klasifikasi
print(classification_report(true_classes, y_pred_classes, target_names=class_labels))
# Membuat confusion matrix
conf_matrix = confusion_matrix(true_classes, y_pred_classes)
# Menampilkan confusion matrix menggunakan heatmap
plt.determine(figsize=(10, 8))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=class_labels, yticklabels=class_labels)
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.title('Confusion Matrix')
plt.present()
Output :
Langkah ini melibatkan evaluasi lebih lanjut dari performa mannequin dengan melihat classification report yang mencakup precision, recall, dan F1-score untuk setiap kelas, serta confusion matrix untuk melihat seberapa baik mannequin memprediksi setiap kelas.
Dengan langkah-langkah ini, Anda dapat membangun, melatih, dan mengevaluasi mannequin klasifikasi menggunakan arsitektur VGG16 untuk dataset klasifikasi topeng Bali. Pastikan untuk menyesuaikan jumlah kelas, dataset, dan pengaturan lainnya sesuai kebutuhan proyek Anda.
Dalam proyek ini, saya berhasil mengembangkan dan melatih mannequin klasifikasi menggunakan arsitektur VGG16 untuk mengidentifikasi tujuh jenis topeng Bali yang berbeda. Melalui langkah-langkah yang sistematis, dimulai dari persiapan dataset hingga evaluasi akhir, saya mencapai hasil yang sangat memuaskan.
Hasil evaluasi menunjukkan bahwa mannequin saya mencapai tingkat akurasi, presisi, recall, dan F1-score sebesar 1.0 untuk setiap kelas, menandakan kemampuannya yang sangat baik dalam mengenali dan membedakan setiap jenis topeng. Keberhasilan ini tidak hanya menunjukkan kehandalan arsitektur deep studying VGG16, tetapi juga memvalidasi pendekatan saya dalam membagi dataset, melakukan augmentasi gambar, dan mengimplementasikan teknik-teknik pengelolaan mannequin yang efektif.
Penerapan mannequin ini dapat memberikan kontribusi signifikan dalam pelestarian dan pemahaman lebih lanjut terhadap budaya topeng Bali. Dengan kemampuannya untuk secara otomatis mengidentifikasi topeng berdasarkan gambar, mannequin ini berpotensi menjadi alat yang berharga dalam studi seni, pendidikan budaya, serta dalam upaya pelestarian warisan budaya.
Kesimpulan ini menegaskan bahwa integrasi teknologi deep studying dengan budaya lokal bukan hanya berpotensi untuk mempertahankan identitas budaya, tetapi juga memperluas penggunaan teknologi fashionable dalam mendukung tujuan sosial dan kebudayaan yang lebih luas.
