Project Implementasi Ekstraksi Fitur pada Ekspresi Wajah (Dokumentasi Pribadi)

Baca Juga

Tulisan kali ini sebagai jurnal perjalanan saya dalam membuat proyek penelitian, dengan menceritakan langkah-langkah apa yang saya kerjakan. 

Setelah saya dapatkan dataset ekspresi wajah dari dataset Kaggle (https://www.kaggle.com/datasets/msambare/fer2013) sebagai bahan olah. 

Design System

Didalam file tersebut (dataset) terdapat 2 file, yaitu data training dan testing. Langkah standart yang dilakukan adalah preprocessing, lalu ekstraksi dengan fitur HOG lalu Klasifikasi dengan SVM. Ini dilakukan pada data training dan juga data testing. 

Membangun sistem ekstraksi wajah untuk mendeteksi emosi menggunakan ekstraksi fitur HOG (Histogram of Oriented Gradients) dan klasifikasi dengan SVM (Support Vector Machine) adalah proyek yang cukup kompleks dan memerlukan sejumlah langkah. Saya simpulkan sebagai berikut:

Pengumpulan Data Latih: Dalam hal ini, saya mengumpulkan dataset wajah dengan label emosi yang sesuai. Dataset FER13 berisi 35.887 gambar dengan 7 kategori emosi (marah, sedih, jijik, kecewa, terkejut, takut, senang). Saya membagi menjadi 28709 entries sebagai data training dan 7178 entries sebagai data testing (20% dari dataset total 35.887).

Preprocessing Data: Saya melakukan preprocessing data untuk mengubah gambar wajah menjadi format yang dapat digunakan oleh algoritma HOG dan SVM. Ini termasuk resizing gambar, normalisasi, dan konversi ke grayscale jika diperlukan.

Ekstraksi Fitur HOG: Saya gunakan ekstraksi fitur HOG untuk mengekstraksi fitur tekstur dari gambar wajah. Anda dapat menggunakan library seperti OpenCV atau scikit-image untuk ini.

Pelatihan Model SVM dan Evaluasi Model: Pada tahapan ini saya mencoba menvariasikan dengan beberapa parameter kernel, C, dll, sehingga dapat dilihat hasil evaluasi performance model SVM yang telah dilatih. 

Implementasi HOG

Saya akan coba implementasi ekstraksi fitur HOG (Histogram of Oriented Gradients) dari gambar wajah manusia dalam berbagai emosi (misalnya, marah, senang, sedih, dll.), dan kemudian menyimpan fitur-fitur tersebut ke dalam format file CSV.

Terdapat 7 dataset ekspresi,

    'angry': 'marah',
    'disgust': 'jijik',
    'fear': 'takut',
    'happy': 'senang',
    'neutral': 'netral',
    'sad': 'sedih',        
    'surprise': 'terkejut'

Masing-masing data train dan test terdapat 7 dataset tersebut. Berikut kode pyton yang dibuat:

import cv2
import os
import csv
from skimage.feature import hog
import numpy as np

# Fungsi untuk ekstraksi fitur HOG dari gambar
def extract_hog_features(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    features = hog(gray, orientations=9, pixels_per_cell=(8, 8),
                   cells_per_block=(2, 2), visualize=False)
    return features

# Fungsi untuk normalisasi dan pembulatan fitur
def normalize_and_round(features):
    normalized_features = (features - np.min(features)) / (np.max(features) - np.min(features))
    rounded_features = np.round(normalized_features, 2)
    return rounded_features

# Path folder dataset
datasets = {
    'angry': 'marah',
    'disgust': 'jijik',
    'fear': 'takut',
    'happy': 'senang',
    'neutral': 'netral',
    'sad': 'sedih',        
    'surprise': 'terkejut'
}

# List untuk menyimpan fitur HOG dan label
all_features = []
all_labels = []

# Loop melalui setiap dataset
for dataset_folder, emotion_label in datasets.items():
    for filename in os.listdir(dataset_folder):
        if filename.endswith('.jpg'):
            image = cv2.imread(os.path.join(dataset_folder, filename))
            hog_features = extract_hog_features(image)
            normalized_features = normalize_and_round(hog_features)
            all_features.append(normalized_features)
            all_labels.append(emotion_label)

# Simpan fitur dan label dalam format CSV
csv_file = 'hog_features_expression.csv' 
with open(csv_file, 'w', newline='') as csvfile:
    csvwriter = csv.writer(csvfile)
    csvwriter.writerow(['Emotion', 'HOG Features'])
    for label, features in zip(all_labels, all_features):
        csvwriter.writerow([label, *features])
        

Masing-masing dari dataset train dan testing diperlakukan dengan sama, yaitu ekstraksi dengan fitur HOG.

def extract_hog_features(image):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    features = hog(gray, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualize=False)
    return features

menjelaskan kode tersebut adalah definisi dari sebuah fungsi bernama extract_hog_features(image) yang digunakan untuk mengambil fitur HOG (Histogram of Oriented Gradients) dari sebuah gambar. Mari kita jelaskan setiap baris kode dalam fungsi ini:

'gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)`

Baris ini mengubah gambar berwarna (`image`) menjadi gambar skala abu-abu (`gray`) menggunakan fungsi `cv2.cvtColor` dari pustaka OpenCV. Ini diperlukan karena fitur HOG umumnya diekstraksi dari gambar skala abu-abu, bukan gambar berwarna.

`features = hog(gray, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualize=False)`

Baris ini mengambil fitur HOG dari gambar skala abu-abu (`gray`) menggunakan fungsi `hog` dari pustaka scikit-image (`skimage.feature`). Parameter yang digunakan dalam fungsi `hog` adalah sebagai berikut:

• `gray`: Gambar skala abu-abu yang akan digunakan untuk ekstraksi fitur HOG.
• `orientations=9`: Ini adalah jumlah arah (orientasi) yang akan digunakan untuk menghitung gradien. Dalam hal ini, ada 9 orientasi yang digunakan.
• `pixels_per_cell=(8, 8)`: Ini adalah ukuran sel (cell) dalam piksel yang akan digunakan untuk menghitung gradien di dalamnya. Di sini, sel berukuran 8x8 piksel.
• `cells_per_block=(2, 2)`: Ini adalah ukuran blok dalam sel yang akan digunakan untuk normalisasi fitur HOG. Di sini, blok berukuran 2x2 sel.
• `visualize=False`: Parameter ini menunjukkan apakah Anda ingin menghasilkan gambar visualisasi fitur HOG (jika disetel menjadi `True`) atau hanya ingin mengambil fitur HOG itu sendiri (sebagai array) seperti yang dilakukan dalam kasus ini.

`return features`

Baris ini mengembalikan fitur HOG yang telah diekstraksi dari gambar sebagai hasil dari fungsi ini. Fitur HOG ini biasanya berupa array numerik yang digunakan untuk menggambarkan pola tekstur dan arah gradient dalam gambar. Dengan demikian, fungsi `extract_hog_features(image)` ini mengambil gambar berwarna sebagai masukan, mengubahnya menjadi gambar skala abu-abu, dan kemudian menghitung fitur HOG dari gambar tersebut sesuai dengan parameter-parameter yang telah ditentukan, lalu mengembalikan fitur-fitur HOG tersebut.

Pelatihan Model SVM dan Evaluasi Model

Selanjutnya kita lakukan pelatihan model dengan SVM Classification dengan uji parameter 3 kernel, Linier, Polinomial dan RBF. Saya awali uji kernel linier:

import csv
import numpy as np
from sklearn import svm
from sklearn.metrics import accuracy_score, classification_report

# Baca dataset pelatihan dari file CSV
def read_csv_dataset(csv_file):
    features = []
    labels = []
    with open(csv_file, 'r') as csvfile:
        csvreader = csv.reader(csvfile)
        next(csvreader)  # Lewati baris header
        for row in csvreader:
            emotion = row[0]
            hog_features = np.array([float(x) for x in row[1:]])
            features.append(hog_features)
            labels.append(emotion)
    return np.array(features), np.array(labels)

# Load dataset pelatihan
train_csv_file = 'train\hog_features_expression_training.csv'
X_train, y_train = read_csv_dataset(train_csv_file)

# Inisialisasi model SVM
clf = svm.SVC(kernel='linear', C=1.0)

# Latih model SVM pada seluruh dataset pelatihan
clf.fit(X_train, y_train)

# Load dataset pengujian
test_csv_file = 'test\hog_features_expression_testing.csv'
X_test, y_test = read_csv_dataset(test_csv_file)

# Prediksi label pada data pengujian
y_pred = clf.predict(X_test)

# Evaluasi model pada data pengujian
accuracy = accuracy_score(y_test, y_pred)
report = classification_report(y_test, y_pred)

print(f'Accuracy on Test Data: {accuracy}')
print(report)

Hasilnya kita sambung pada artikel selanjutnya. :)