🌻Lab 4

Klasifikasi Siang dan Malang dengan ANN

Pengantar

Pada lab ini, mahasiswa akan mempelajari cara membangun model klasifikasi citra siang dan malam menggunakan Artificial Neural Network (ANN). Model akan dilatih menggunakan fitur HOG (Histogram of Oriented Gradients) yang diekstraksi dari citra. Mahasiswa akan menjalani alur lengkap mulai dari membaca data, pra pengolahan citra, ekstraksi fitur, normalisasi, membangun model, hingga evaluasi.

Dataset

Gunakan dataset citra siang dan malam pada lab Lab 5

Langkah 1 - Import Library

Import library yang dibutuhkan

from pathlib import Path
import numpy as np
import matplotlib.pyplot as plt
import cv2

from skimage.feature import hog
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report

import tensorflow as tf
from tensorflow.keras import layers, models

Langkah 2 - Load Dataset

Gunakan fungsi berikut dan load dataset. Pastikan direktori dataset telah sesuai.

# Load images and labels from a directory structure
def load_dataset(img_dir):
    p = Path(img_dir)
    img_list = []
    for folder in p.glob('*'):
        label = folder.name
        for file in folder.glob('*.jpg'):
            img = cv2.imread(str(file))
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            img_list.append((img, label))
    return img_list

train_dir = "images/training/"
test_dir  = "images/test/"

train_img = load_dataset(train_dir)
test_img  = load_dataset(test_dir)

Langkah 2 - Pra Pengolahan

Risize dan lakukan pelabelan data

# Preprocess images: resize and encode labels
def resize_image(img, size=(256,256)):
    return cv2.resize(img, size)

def label_encoder(label):
    return 1 if label == 'day' else 0

def preprocess(img_list):
    X = []
    y = []
    for img, label in img_list:
        img_std = resize_image(img)
        X.append(img_std)
        y.append(label_encoder(label))
    return X, y

X_train_img, y_train = preprocess(train_img)
X_test_img,  y_test  = preprocess(test_img)

Langkah 3 - Ekstraksi Fitur

Selanjut, lakukan proses ekstraksi fitur. Fitur yang akan digunakan adalah HoG. Pelajari HoG lebih lanjut pada https://scikit-image.org/docs/0.25.x/auto_examples/features_detection/plot_hog.html

# Extract HOG features
def extract_hog(X_imgs):
    feats = []
    for img in X_imgs:
        gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
        hog_feat = hog(gray,
                       orientations=9,
                       pixels_per_cell=(8,8),
                       cells_per_block=(2,2),
                       block_norm='L2-Hys',
                       visualize=False,
                       feature_vector=True)
        feats.append(hog_feat)
    return np.array(feats)

X_train_feat = extract_hog(X_train_img)
X_test_feat  = extract_hog(X_test_img)

Langkah 4 - Standardisasi Fitur

# Normalize features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train_feat)
X_test_scaled  = scaler.transform(X_test_feat)

Langkah 5 - Buat Data Latih dan Validasi

X_train, X_val, y_train, y_val = train_test_split(
    X_train_scaled, y_train,
    test_size=0.2,
    random_state=42
)

# Convert label ke numpy array
y_train = np.array(y_train)
y_val   = np.array(y_val)
y_test  = np.array(y_test)

Langkah 6 - Buat Model ANN

Arsitektur model yang digunakan adalah,

• Input Layer

• Hidden Layer 1 - 128 Nodes - ReLU

• Hidden Layer 2 - 64 Nodes - ReLu

• Output Layer - 2 Nodes - Sigmoid

input_dim = X_train.shape[1]

model = models.Sequential([
    layers.Input(shape=(input_dim,)),
    layers.Dense(128, activation='relu'),
    layers.Dense(64, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

model.summary()

Anda akan mendapatkan summary dari arsitektur model. Informasi ini penting untuk mengetahui bentuk dari arsitektur ANN dan jumlah parameter yang dilatih.

Langkah 7 - Latih Model

history = model.fit(
    X_train, y_train,
    epochs=20,
    batch_size=32,
    validation_data=(X_val, y_val)
)

Anda dapat mengakses ulang performansi model dengan menggunakan variabel history yang telah dibuat.

Langkah 8 - Evaluasi Model dengan Data Test

test_loss, test_acc = model.evaluate(X_test_scaled, y_test)
print("Akurasi Test:", test_acc)

Langkah 9 - Buat Laporan Performansi Model

y_pred_prob = model.predict(X_test_scaled)
y_pred = (y_pred_prob > 0.5).astype(int)

print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

Langkah 10 - Visualisasi Proses Training

Visualisasi ini penting untuk proses monitoring performa model. Visualisasi menggunakan konsep Receiver Operating Characteristic (ROC) untuk mengetahui performa model tiap epoch.

plt.plot(history.history['accuracy'], label='Train Acc')
plt.plot(history.history['val_accuracy'], label='Val Acc')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

Hasilnya,

Dari grafik tersebut, apa yang bisa Anda interpretasikan?

Langkah 11 - Simpan Model

Simpan model untuk kebutuhan produksi.

model.save('day_night_classifier_model.h5')