Sistem Pendeteksi Wajah Manusia pada Citra Digital
Tesis Untuk memenuhi sebagian persyaratan Mencapai derajat Sarjana S-2 Program Studi Ilmu Komputer Jurusan Ilmu-Ilmu Matematika dan Pengetahuan Alam
Diajukan oleh: Setyo Nugroho 18661/I-4/1445/02
PROGRAM PASCA SARJANA UNIVERSITAS GADJAH MADA JOGJAKARTA 2004
PERNYATAAN
Dengan ini saya menyatakan bahwa dalam tesis ini tidak terdapat karya yang pernah diajukan untuk memperoleh gelar kesarjanaan di suatu Perguruan Tinggi, dan sepanjang pengetahuan saya tidak terdapat karya atau pendapat yang pernah ditulis atau diterbitkan oleh orang lain, kecuali yang secara tertulis diacu dalam naskah ini dan disebutkan di dalam daftar pustaka.
Jogjakarta,
Maret 2004
SETYO NUGROHO
iii
iv
KATA PENGANTAR
Dengan mengucap Alhamdulillahirabbil’alamin kami memanjatkan puji syukur ke hadirat Allah swt, atas rahmat, nikmat dan hidayah-Nya sehingga kami dapat menyelesaikan penulisan tugas akhir ini. Tugas akhir ini disusun untuk memenuhi sebagian persyaratan mencapai derajat sarjana S-2 dalam bidang Ilmu Komputer di Program Pascasarjana Universitas Gadjah Mada Jogjakarta. Selama penulisan tesis ini kami menyadari banyak pihak telah memberikan bantuannya, sehingga pada kesempatan ini kami ingin mengucapkan terima kasih yang tulus kepada: •
Drs. Agus Harjoko, M.Sc, Ph.D, selaku pembimbing tesis yang telah memberikan bimbingannya dengan penuh kesabaran.
•
Drs. Retantyo Wardoyo, M.Sc, Ph.D, selaku pengelola program studi Pascasarjana S2 Ilmu Komputer UGM Jogjakarta.
•
Drs. Satria Dharma, selaku Ketua STMIK STIKOM Balikpapan yang telah memberikan kesempatan kepada penulis untuk menempuh studi lanjut dan selalu memberikan semangat kepada penulis untuk terus maju.
•
Dian Farida Anies dan Nadia Fitri Zafira, istri dan anakku tercinta, yang dengan tulus telah memberikan kesempatan, dukungan, doa, pengorbanan, pengertian, kesabaran dan ketabahan yang luar biasa, sehingga penulis dapat menyelesaikan semua ini.
•
Ibu bapak di Wonogiri dan di Surabaya, serta seluruh keluarga yang telah memberikan dukungan dan doanya.
v
•
Teman-teman yang telah memberikan banyak bantuan, pelajaran dan pengalaman baru bagi penulis selama tinggal di Jogja: Murinto, Umar, Nusirwan, Eman, Yudhi, Hesti, Pak Nana, Aziz, Sari, Pak Jumhadi, Joko, Tito, Mbak Lia, Bernard, Pak Manik, Bu Umi, Pak Sugeng, Eko, Rika, Eny, Adib, Harry, Robby, Devan, Dody, Jose, Dila, Iche, Leli, Dewi, Desti, Rama, Kevin.
•
Pihak-pihak lain yang tidak bisa kami sebutkan satu-persatu yang telah memberikan bantuannya selama ini. Akhir kata, kami sadar bahwa kami masih memiliki keterbatasan dan
kekurangan sehingga karya ini mungkin masih jauh dari sempurna. Untuk itu saran dan kritik yang membangun akan kami terima dengan tangan terbuka.
Jogjakarta, Maret 2004
Setyo Nugroho
vi
DAFTAR ISI Halaman Halaman Judul .....................................................................................................i Halaman Pengesahan .........................................................................................ii Pernyataan .........................................................................................................iii Halaman Persembahan ......................................................................................iv Kata Pengantar ................................................................................................... v Daftar Isi ...........................................................................................................vii Daftar Gambar ....................................................................................................x Daftar Tabel ......................................................................................................xi Intisari ..............................................................................................................xii Abstract ...........................................................................................................xiii BAB I. Pendahuluan .......................................................................................... 1 1.1. Latar Belakang .............................................................................. 1 1.2. Perumusan Masalah ...................................................................... 2 1.3. Batasan Masalah ........................................................................... 2 1.4. Keaslian Penelitian ........................................................................ 2 1.5. Manfaat Penelitian ........................................................................ 3 1.6. Tujuan Penelitian .......................................................................... 4 1.7. Tinjauan Pustaka ........................................................................... 4 1.8. Sistematika Penulisan ................................................................... 5
vii
BAB II. Landasan Teori...................................................................................... 6 2.1. Citra Digital .................................................................................. 6 2.2. Deteksi Wajah ............................................................................... 7 2.2.1. Knowledge-Based Method .................................................... 9 2.2.2. Feature Invariant Approach ................................................. 10 2.2.3. Template Matching ............................................................. 11 2.2.4. Appearance-Based Method ................................................. 12 2.3. Jaringan Syaraf Tiruan .................................................................. 12 2.3.1. Multi-Layer Perceptron ........................................................ 13 2.3.2. Supervised Learning ............................................................ 14 2.3.3. Algoritma Backpropagation ................................................ 15 2.3.4. Variasi pada Algoritma Backpropagation ........................... 17 2.3.5. Algoritma Quickprop .......................................................... 18 BAB III. Perancangan dan Implementasi Sistem ............................................. 20 3.1. Data dan Peralatan Penelitian ........................................................ 20 3.2. Perancangan Sistem ....................................................................... 21 3.2.1. Diagram Aliran Data (Data Flow Diagram) ........................ 22 3.2.2. Jaringan Syaraf Tiruan ........................................................ 26 3.2.3. Pelatihan Active Learning ................................................... 28 3.2.4. Detektor Wajah ................................................................... 30 3.2.4.1. Ekstraksi Subcitra ................................................... 32 3.2.4.2. Resizing .................................................................. 32 3.2.4.3. Histogram Equalization ........................................... 33
viii
3.2.4.4. Masking .................................................................. 34 3.2.4.5. Penggabungan (Merging) Kandidat Wajah ............. 34 3.2.4.6. User Interface .......................................................... 35 3.3. Implementasi Sistem ..................................................................... 35 3.3.1. Jaringan Syaraf Tiruan ........................................................ 36 3.3.2. Window Scanning ................................................................ 39 3.3.3. Resizing................................................................................ 40 3.3.4. Histogram Equalization........................................................ 41 3.3.5. Masking ............................................................................... 42 3.3.6. Penggabungan (Merging) Kandidat Wajah ......................... 45 BAB IV. Hasil dan Pembahasan ...................................................................... 47 4.1. Pengukuran Evaluasi Unjuk Kerja ................................................ 47 4.2. Hasil Deteksi Kandidat Wajah ...................................................... 47 4.3. Hasil Deteksi ................................................................................. 48 4.4. Pengaruh Jumlah Data Training yang Digunakan ........................ 52 4.5. Pengaruh Algoritma Quickprop pada Kecepatan Training............ 53 4.6. Pengaruh Metode Active Learning ............................................... 53 BAB V. Kesimpulan Dan Saran ...................................................................... 55 5.1. Kesimpulan ................................................................................... 55 5.2. Saran .............................................................................................. 56 Daftar Pustaka Lampiran
ix
DAFTAR GAMBAR Halaman Gambar 3.1. Sistem Deteksi Wajah................................................................ 22 Gambar 3.2. DFD level 0 Sistem Trainer JST .............................................. 22 Gambar 3.3. DFD level 1 Sistem Trainer JST .............................................. 23 Gambar 3.4. DFD level 0 Sistem Detektor Wajah ........................................ 24 Gambar 3.5. DFD level 1 Sistem Detektor Wajah ........................................ 25 Gambar 3.6. Arsitektur Jaringan Syaraf Tiruan ............................................ 27 Gambar 3.7. Metode Pelatihan Active Learning ........................................... 29 Gambar 3.8. Diagram Alir Bagian Detektor Wajah ...................................... 31 Gambar 3.9. Contoh Citra dan Histogramnya ............................................... 42 Gambar 3.10. Contoh citra yang telah mengalami proses resizing, histogram equalization, dan masking ......................... 44 Gambar 3.11. Beberapa contoh data wajah yang telah mengalami preprocessing ............................................................................ 44 Gambar 4.1. Hasil deteksi sebelum dan sesudah proses merging ................. 48 Gambar 4.2. Contoh Hasil Deteksi Wajah .................................................... 50 Gambar 4.3. Contoh Hasil Deteksi dengan False Positive dan Wajah yang Tidak Terdeteksi ............................................ 51
x
DAFTAR TABEL Halaman Tabel 4.1. Beberapa hasil deteksi pada data uji MIT-23 .................................. 49 Tabel 4.2. Pengaruh Jumlah Data Training pada Unjuk Kerja Deteksi Wajah ................................................................................. 52 Tabel 4.3. Pengaruh Algoritma Quickprop pada Kecepatan Training ............. 53 Tabel 4.4. Pengaruh Active Learning pada Unjuk Kerja Deteksi Wajah ........ 54
xi
INTISARI Pendeteksian wajah (face detection) adalah salah satu tahap awal yang sangat penting dalam sistem pengenalan wajah (face recognition) yang digunakan dalam identifikasi biometrik. Deteksi wajah juga dapat digunakan untuk pencarian atau pengindeksan data wajah dari citra atau video yang berisi wajah dengan berbagai ukuran, posisi, dan latar belakang. Dalam penelitian ini diimplementasikan sistem deteksi wajah yang menggunakan jaringan syaraf tiruan multi-layer perceptron dan algoritma Quickprop. Sistem deteksi wajah memperoleh kemampuan deteksinya dengan cara belajar dari contoh (learning by examples). Pelatihan dilakukan dengan metode active learning untuk meminimalkan banyaknya data yang digunakan untuk pelatihan. Hasil penelitian menunjukkan bahwa akurasi dari sistem deteksi wajah sangat tergantung pada jumlah dan jenis data yang digunakan dalam pelatihan. Algoritma Quickprop dan teknik active learning dapat dimanfaatkan untuk membantu mempercepat proses pelatihan. (Kata kunci: deteksi wajah, jaringan syaraf tiruan, Quickprop, active learning)
ABSTRACT Face detection is one of the most important preprocessing step in face recognition systems used in biometric identification. Face detection can also be used in searching and indexing still image or video containing faces in various size, position, and background. This paper describes a face detection system using multi-layer perceptron and Quickprop algorithm. The system achieves its ability by means of learning by examples. The training is performed using active learning method to minimize the amount of data used in training. Experimental results show that the accuracy of the system strongly depends on the quality and quantity of the data used in training. Quickprop algorithm and active learning method can improve the training speed significantly. (Keywords: face detection, neural networks, quickprop, active learning)
1
BAB I PENDAHULUAN 1.1. Latar Belakang Masalah Teknologi pengenalan wajah semakin banyak dimanfaatkan, antara lain untuk sistem pengenalan biometrik (di samping fitur biometrik yang lain seperti sidik jari dan suara), sistem pencarian dan pengindeksan database citra digital dan database video digital, sistem keamanan kontrol akses area terbatas, konferensi video, dan interaksi manusia dengan komputer. Pendeteksian wajah (face detection) adalah salah satu tahap awal yang sangat penting sebelum dilakukan proses pengenalan wajah (face recognition). Pada kasus seperti pemotretan untuk pembuatan KTP, SIM, dan kartu kredit, citra yang didapatkan umumnya hanya berisi satu wajah dan memiliki latar belakang seragam dan kondisi pencahayaan yang telah diatur sebelumnya sehingga deteksi wajah dapat dilakukan dengan lebih mudah. Namun pada kasus lain sering didapatkan citra yang berisi lebih dari satu wajah, memiliki latar belakang yang bervariasi, kondisi pencahayaan yang tidak tentu, dan ukuran wajah yang bervariasi di dalam citra. Contohnya adalah citra yang diperoleh di bandara, terminal, pintu masuk gedung, pusat perbelanjaan, dan citra yang didapatkan dari foto di media massa atau hasil rekaman video.
2
1.2. Perumusan Masalah Masalah deteksi wajah dapat dirumuskan sebagai berikut: diberikan masukan sebuah citra digital sembarang, maka sistem akan mendeteksi apakah ada wajah manusia di dalam citra tersebut. Jika ada maka sistem akan memberitahu berapa wajah yang ditemukan dan lokasi wajah-wajah tersebut di dalam citra. Keluaran dari sistem adalah posisi subcitra berisi wajah yang berhasil dideteksi.
1.3. Batasan Masalah Untuk menjaga fokus dari penelitian ini, maka beberapa batasan yang diberikan adalah sebagai berikut : •
Wajah yang akan dideteksi adalah wajah yang menghadap ke depan (frontal), dalam posisi tegak, dan tidak terhalangi sebagian oleh objek lain.
•
Metode yang dipakai adalah jaringan syaraf tiruan multi-layer perceptron dengan algoritma pelatihan Quickprop.
•
Citra yang dideteksi menggunakan format BMP atau JPG.
1.4. Keaslian Penelitian Penelitian tentang deteksi wajah dan pengenalan wajah telah dilakukan sebelumnya, antara lain dengan menggunakan metode Eigenface [Turk dan Pentland, 1991], dengan distribusi Gaussian dan clustering [Sung dan Poggio, 1994], dengan jaringan syaraf tiruan dan arbitrasi [Rowley et al., 1998], dengan
3
support vector machine [Osuna et al., 1997], dan dengan metode statistik dan wavelet [Schneiderman, 2000]. Pada penelitian [Rowley et al., 1998] digunakan jaringan syaraf tiruan yang dilatih dengan menggunakan algoritma backpropagation standar dengan momentum. Sedangkan pada tesis ini akan dibuat sistem pendeteksi wajah yang menggunakan jaringan syaraf tiruan dan dilatih dengan menggunakan algoritma Quickprop. Algoritma Quickprop ini pertama kali diperkenalkan pada [Fahlman, 1988] dengan tujuan untuk mempercepat proses training pada jaringan syaraf tiruan. Kemudian akan dilakukan penelitian pada pengaruh berbagai parameter yang digunakan terhadap unjuk kerja dari sistem. Parameter-parameter yang digunakan misalnya banyaknya data training, penggunaan algoritma Quickprop pada kecepatan training, dan penggunaan metode active learning pada hasil pelatihan.
1.5. Manfaat Penelitian Manfaat dari penelitian ini adalah : •
Dapat digunakan untuk mendeteksi wajah manusia pada citra digital.
•
Dapat dimanfaatkan sebagai salah satu tahap praproses dari sistem pengenalan wajah atau verifikasi wajah.
•
Dapat digunakan untuk mengumpulkan data wajah secara otomatis dari citra yang berisi wajah dengan berbagai ukuran, posisi, dan latar belakang.
4
1.6. Tujuan Penelitian Tujuan dari penelitian ini adalah untuk membuat sistem deteksi wajah dengan masukan berupa citra digital sembarang. Sistem ini akan menghasilkan subcitra berisi wajah-wajah yang berhasil dideteksi.
1.7. Tinjauan Pustaka Deteksi wajah dapat dipandang sebagai masalah klasifikasi pola dimana dengan input berupa citra masukan akan ditentukan output berupa label kelas dari citra tersebut. Dalam hal ini terdapat dua label kelas, yaitu wajah dan non-wajah [Sung, 1996]. Teknik-teknik pengenalan wajah yang dilakukan selama ini banyak yang menggunakan asumsi bahwa data wajah yang tersedia memiliki ukuran yang sama dan latar belakang yang seragam. Di dunia nyata, asumsi ini tidak selalu berlaku karena wajah dapat muncul di dalam citra dengan berbagai ukuran, berbagai posisi, dan latar belakang yang bervariasi [Hjelmas, Low, 2001]. Pendeteksian wajah (face detection) adalah salah satu tahap awal (preprocessing) yang sangat penting sebelum dilakukan proses pengenalan wajah (face recognition). Bidang-bidang penelitian yang juga berkaitan dengan pemrosesan
wajah
(face
processing)
adalah
autentikasi
wajah
(face
authentication), lokalisasi wajah (face localization), penjejakan wajah (face tracking), dan pengenalan ekspresi wajah (facial expression recognition) [Yang, 2002].
5
1.8. Sistematika Penulisan Sistematika penulisan terdiri dari : BAB I. Pendahuluan Bab ini menguraikan tentang latar belakang, perumusan masalah, batasan masalah, keaslian penelitian, manfaat penelitian, tujuan penelitian, tinjauan pustaka, dan sistematika penulisan. BAB II. Landasan Teori Bab ini membahas dasar-dasar teori dari citra digital, deteksi wajah, jaringan syaraf tiruan, algoritma backpropagation, algoritma Quickprop, dan metode pelatihan active learning. BAB III. Perancangan dan Implementasi Sistem Bab ini membahas tentang data dan peralatan penelitian, perancangan dan implementasi sistem deteksi wajah. BAB IV. Hasil dan Pembahasan Bab ini membahas tentang hasil pengujian dan pembahasan dari sistem deteksi wajah. BAB V. Kesimpulan dan Saran Bab ini menguraikan kesimpulan dari penelitian dan saran-saran.
6
BAB II LANDASAN TEORI
2.1. Citra Digital Citra digital adalah suatu citra f(x,y) yang memiliki koordinat spatial, dan tingkat kecerahan yang diskrit. Citra yang terlihat merupakan cahaya yang direfleksikan dari sebuah objek. Fungsi f ( x, y ) dapat dilihat sebagai fungsi dengan dua unsur. Unsur yang pertama merupakan kekuatan sumber cahaya yang melingkupi pandangan kita terhadap objek (illumination). Unsur yang kedua merupakan besarnya cahaya yang direfleksikan oleh objek ke dalam pandangan kita (reflectance components). Keduanya dituliskan sebagai fungsi i ( x, y ) dan
r ( x, y ) yang digabungkan sebagai perkalian fungsi untuk membentuk fungsi f ( x, y ) . Fungsi f ( x, y ) dapat dituliskan dengan persamaan : f ( x, y ) = i ( x, y ) ∗ r ( x , y )
(2.1)
di mana
0 < i ( x, y ) < ∞ dan 0 < r ( x, y ) < 1 Citra digital merupakan suatu matriks yang terdiri dari baris dan kolom, dimana setiap pasangan indeks baris dan kolom menyatakan suatu titik pada citra. Nilai matriksnya menyatakan nilai kecerahan titik tersebut. Titik-titik tersebut dinamakan sebagai elemen citra, atau pixel (picture elemen). [Gonzales and Woods, 1992].
7
Histogram equalization Histogram equalization digunakan untuk melakukan perluasan kontras citra (contrast strecthing) secara otomatis. Setelah melalui histogram equalization, citra akan memiliki histogram yang lebih seragam [Gonzalez, 1992]. Misalkan r adalah nilai graylevel pixel citra yang akan diproses, dan pr(rk) adalah probabilitas munculnya level grayscale rk di dalam citra. p r (rk ) =
nk n
0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1
(2.2)
di mana L adalah banyaknya level grayscale, nk adalah banyaknya pixel dengan level grayscale rk muncul di dalam citra, dan n adalah banyaknya seluruh pixel di dalam citra. s k = T (rk ) =
k
nj
j =0
n
=
k
nj
j =0
n
0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1
(2.3)
2.2. Deteksi Wajah Deteksi wajah dapat dipandang sebagai masalah klasifikasi pola dimana inputnya adalah citra masukan dan akan ditentukan output yang berupa label kelas dari citra tersebut. Dalam hal ini terdapat dua label kelas, yaitu wajah dan nonwajah [Sung, 1996]. Teknik-teknik pengenalan wajah yang dilakukan selama ini banyak yang menggunakan asumsi bahwa data wajah yang tersedia memiliki ukuran yang sama dan latar belakang yang seragam. Di dunia nyata, asumsi ini tidak selalu berlaku karena wajah dapat muncul dengan berbagai ukuran dan posisi di dalam citra dan dengan latar belakang yang bervariasi [Hjelmas, Low, 2001].
8
Pendeteksian wajah (face detection) adalah salah satu tahap awal yang sangat penting sebelum dilakukan proses pengenalan wajah (face recognition). Bidang-bidang penelitian yang berkaitan dengan pemrosesan wajah (face processing) adalah [Yang, 2002]:
•
Pengenalan wajah (face recognition) yaitu membandingkan citra wajah masukan dengan suatu database wajah dan menemukan wajah yang paling cocok dengan citra masukan tersebut.
•
Autentikasi wajah (face authentication) yaitu menguji keaslian/kesamaan suatu wajah dengan data wajah yang telah diinputkan sebelumnya.
•
Lokalisasi wajah (face localization) yaitu pendeteksian wajah namun dengan asumsi hanya ada satu wajah di dalam citra
•
Penjejakan wajah (face tracking) yaitu memperkirakan lokasi suatu wajah di dalam video secara real time.
•
Pengenalan ekspresi wajah (facial expression recognition) untuk mengenali kondisi emosi manusia. Tantangan yang dihadapi pada masalah deteksi wajah disebabkan oleh
adanya faktor-faktor berikut [Yang, 2002]:
•
Posisi wajah. Posisi wajah di dalam citra dapat bervariasi karena posisinya bisa tegak, miring, menoleh, atau dilihat dari samping.
•
Komponen-komponen pada wajah yang bisa ada atau tidak ada, misalnya kumis, jenggot, dan kacamata.
•
Ekspresi wajah. Penampilan wajah sangat dipengaruhi oleh ekspresi wajah seseorang, misalnya tersenyum, tertawa, sedih, berbicara, dan sebagainya.
9
•
Terhalang objek lain. Citra wajah dapat terhalangi sebagian oleh objek atau wajah lain, misalnya pada citra berisi sekelompok orang.
•
Kondisi pengambilan citra. Citra yang diperoleh sangat dipengaruhi oleh faktor-faktor seperti intensitas cahaya ruangan, arah sumber cahaya, dan karakteristik sensor dan lensa kamera. Penelitian dari [Yang, 2002] mengelompokkan metode deteksi wajah
menjadi empat kategori, yaitu: 1. Knowledge-based method. Metode ini kebanyakan digunakan untuk lokalisasi wajah. 2. Feature invariant approach. Metode ini kebanyakan digunakan untuk lokalisasi wajah. 3. Template matching method. Metode ini digunakan untuk lokalisasi wajah maupun deteksi wajah. 4. Appearance-based method. Metode ini kebanyakan digunakan untuk deteksi wajah.
2.2.1. Knowledge-Based Method Metode ini menggunakan dasar aturan-aturan yang biasanya digunakan oleh manusia untuk menentukan apa saja yang membentuk suatu wajah. Pada pendekatan ini, metode deteksi wajah dikembangkan berdasar pada aturan (rule) yang didapat dari pengetahuan para peneliti tentang wajah manusia. Sebagai contoh, suatu wajah di dalam citra biasanya memiliki dua buah mata yang simetris, sebuah hidung, dan sebuah mulut. Relasi antara fitur-fitur
10
tersebut dapat direpresentasikan sebagai jarak atau posisi. Pada tahap pertama fitur-fitur wajah diekstraksi lebih dulu, kemudian kandidat wajah ditentukan berdasarkan aturan yang dipakai. Masalah
utama
pada
pendekatan
ini
adalah
kesulitan
dalam
menerjemahkan pengetahuan manusia ke dalam aturan yang akan dipakai. Jika aturannya terlalu detail (strict), maka akan sering gagal mendeteksi wajah yang tidak memenuhi aturan tersebut. Jika aturannya terlalu umum (general), akan menghasilkan terlalu banyak false positive. Masalahnya akan bertambah sulit jika harus mendeteksi wajah dengan pose yang bervariasi karena aturan yang dipakai harus dapat menghadapi semua kemungkinan yang ada. Metode ini biasanya hanya dapat bekerja dengan baik pada wajah frontal dan tegak dengan latar belakang sederhana.
2.2.2. Feature Invariant Approach Algoritma pada metode ini bertujuan untuk menemukan fitur-fitur struktural dari wajah yang tetap eksis meskipun terdapat variasi pose, sudut pandang, dan kondisi cahaya. Pada pendekatan ini, para peneliti mencoba menemukan fitur-fitur yang tidak berubah (invariant) pada wajah. Asumsi ini didasarkan pada observasi bahwa manusia dapat dengan mudah mendeteksi wajah dengan berbagai pose dan kondisi cahaya, sehingga disimpulkan bahwa pasti ada sifat-sifat atau fitur-fitur yang bersifat invariant. Fitur wajah seperti alis, mata, hidung, mulut, biasanya diekstraksi dengan edge detector. Selanjutnya dibentuk
11
suatu model statistik yang mendeskripsikan hubungan antara fitur-fitur tersebut untuk menentukan ada tidaknya wajah. Warna memperkirakan
kulit
manusia
area wajah.
juga Namun
dapat
digunakan
untuk
membantu
biasanya deteksi warna kulit ini
dikombinasikan dengan metode lainnya seperti shape analysis dan motion information [Yang, 1998].
2.2.3. Template Matching Pada metode ini akan disimpan beberapa pola wajah standar untuk mendeskripsikan wajah secara keseluruhan maupun bagian-bagiannya. Pada saat pendeteksian akan dihitung korelasi antara citra input dengan citra pola wajah yang tersimpan sebelumnya. Pada pendekatan ini, para peneliti mencoba menemukan fitur-fitur yang tidak berubah (invariant) pada wajah. Asumsi ini didasarkan pada observasi bahwa manusia dapat dengan mudah mendeteksi wajah dengan berbagai pose dan kondisi cahaya, sehingga tentunya ada sifat-sifat atau fitur-fitur yang bersifat invariant. Fitur wajah seperti alis, mata, hidung, mulut, biasanya diekstraksi dengan edge detector. Selanjutnya dibentuk suatu model statistik yang mendeskripsikan hubungan antara fitur-fitur tersebut untuk menentukan ada tidaknya wajah.
12
2.2.4. Appearance-Based Method Pada metode ini, model wajah dipelajari melalui proses training dengan menggunakan satu set data pelatihan yang berisi contoh-contoh wajah. Kemudian hasil training ini digunakan untuk mendeteksi wajah. Secara umum metode ini menggunakan teknik-teknik dari analisa statistik dan machine learning untuk menemukan karakteristik-karakteristik yang relevan dari wajah maupun nonwajah. Yang termasuk dalam kelompok ini antara lain adalah metode Eigenfaces [Kirby, Sirovich, 1990], distribution-based dan clustering [Sung, Poggio, 1994], jaringan syaraf tiruan [Rowley, 1998], support vector machines (SVM) [Osuna, 1997], Sparse Network of Winnows (SNoW) [Yang, 2000], Naive Bayes Classifier [Schneiderman, 1998], Hidden Markov Model (HMM) [Nefian, 1998], Kullback relative information [Colmenarez, 1997], dan decision trees [Huang, 1996].
2.3. Jaringan Syaraf Tiruan Jaringan syaraf tiruan adalah suatu sistem pemrosesan informasi yang cara kerjanya memiliki kesamaan tertentu dengan jaringan syaraf biologis [Fausett, 1994]. Jaringan syaraf tiruan dikembangkan sebagai model matematis dari syaraf biologis dengan berdasarkan asumsi bahwa: 1. Pemrosesan terjadi pada elemen-elemen sederhana yang disebut neuron. 2. Sinyal dilewatkan antar neuron melalui penghubung. 3. Setiap penghubung memiliki bobot yang akan mengalikan sinyal yang lewat.
13
4. Setiap neuron memiliki fungsi aktivasi yang akan menentukan nilai sinyal output. Jaringan syaraf dapat digolongkan menjadi berbagai jenis berdasarkan pada arsitekturnya, yaitu pola hubungan antara neuron-neuron, dan algoritma trainingnya, yaitu cara penentuan nilai bobot pada penghubung.
2.3.1. Multi-Layer Perceptron Multi-Layer Perceptron adalah jaringan syaraf tiruan feed-forward yang terdiri dari sejumlah neuron yang dihubungkan oleh bobot-bobot penghubung. Neuron-neuron tersebut disusun dalam lapisan-lapisan yang terdiri dari satu lapisan input (input layer), satu atau lebih lapisan tersembunyi (hidden layer), dan satu lapisan output (output layer). Lapisan input menerima sinyal dari luar, kemudian melewatkannya ke lapisan tersembunyi pertama, yang akan diteruskan sehingga akhirnya mencapai lapisan output [Riedmiller, 1994]. Setiap neuron i di dalam jaringan adalah sebuah unit pemrosesan sederhana yang menghitung nilai aktivasinya yaitu si terhadap input eksitasi yang juga disebut net input neti.
net i = dimana
pred(i)
s wij − θ i
(2.4)
j j∈ pred (i )
melambangkan
himpunan
predesesor
dari
unit
i,
wij
melambangkan bobot koneksi dari unit j ke unit i, dan θ i adalah nilai bias dari unit i. Untuk membuat representasi menjadi lebih mudah, seringkali bias digantikan dengan suatu bobot yang terhubung dengan unit bernilai 1. Dengan demikian bias dapat diperlakukan secara sama dengan bobot koneksi.
14
Aktivasi dari unit i, yaitu si , dihitung dengan memasukkan net input ke dalam sebuah fungsi aktivasi non-linear. Biasanya digunakan fungsi logistik sigmoid:
si = f log (net i ) =
1 1 + e − neti
(2.5)
Salah satu keuntungan dari fungsi ini adalah memiliki derivatif yang mudah dihitung:
∂si ′ (net i ) = s i * (1 − s i ) = f log ∂net i
(2.6)
Nilai dari fungsi sigmoid di atas memiliki nilai output antara 0 dan 1. Jika diinginkan nilai output antara –1 dan 1, dapat digunakan fungsi bipolar sigmoid berikut [Fausett, 1994]: si = g log (net i ) =
2 −1 1 + e − neti
(2.7)
Derivatif dari fungsi tersebut adalah:
∂si 1 ′ (net i ) = (1 + si ) * (1 − si ) g log ∂net i 2
(2.8)
2.3.2. Supervised Learning Tujuan pada pembelajaran supervised learning adalah untuk menentukan nilai bobot-bobot koneksi di dalam jaringan sehingga jaringan dapat melakukan pemetaan (mapping) dari input ke output sesuai dengan yang diinginkan. Pemetaan ini ditentukan melalui satu set pola contoh atau data pelatihan (training data set).
15
Setiap pasangan pola p terdiri dari vektor input xp dan vektor target tp. Setelah selesai pelatihan, jika diberikan masukan xp seharusnya jaringan menghasilkan nilai output tp. Besarnya perbedaan antara nilai vektor target dengan output aktual diukur dengan nilai error yang disebut juga dengan cost function:
E=
1 2 p∈P
(t np − s np ) 2
(2.9)
n
di mana n adalah banyaknya unit pada output layer. Tujuan dari training ini pada dasarnya sama dengan mencari suatu nilai minimum global dari E.
2.3.3. Algoritma Backpropagation Salah satu algoritma pelatihan jaringan syaraf tiruan yang banyak dimanfaatkan dalam bidang pengenalan pola adalah backpropagation. Algoritma ini umumnya digunakan pada jaringan syaraf tiruan yang berjenis multi-layer feed-forward, yang tersusun dari beberapa lapisan dan sinyal dialirkan secara searah dari input menuju output. Algoritma pelatihan backpropagation pada dasarnya terdiri dari tiga tahapan [Fausett, 1994], yaitu: 1. Input nilai data pelatihan sehingga diperoleh nilai output 2. Propagasi balik dari nilai error yang diperoleh 3. Penyesuaian bobot koneksi untuk meminimalkan nilai error Ketiga tahapan tersebut diulangi terus-menerus sampai mendapatkan nilai error yang diinginkan. Setelah training selesai dilakukan, hanya tahap pertama yang diperlukan untuk memanfaatkan jaringan syaraf tiruan tersebut.
16
Secara
matematis
[Rumelhart,
1986],
ide
dasar
dari
algoritma
backpropagation ini sesungguhnya adalah penerapan dari aturan rantai (chain rule) untuk menghitung pengaruh masing-masing bobot terhadap fungsi error: ∂E ∂E ∂s i = ∂wij ∂s i ∂wij
(2.10)
∂s i ∂s i ∂net i ′ (net i ) s j = = f log ∂wij ∂net i ∂wij
(2.11)
dan
dimana wij adalah bobot penghubung dari neuron j ke neuron i, s i adalah output, dan net i adalah jumlah hasilkali pada input dari neuron i. Untuk menghitung ∂E ∂s i , yaitu pengaruh output si terhadap error E, dapat dibedakan menjadi dua kasus berikut: •
jika i adalah unit output, maka: ∂E 1 ∂ (t i − si ) 2 = = −(t i − s i ) ∂s i 2 ∂s i
•
(2.12)
jika i bukan unit output, maka perhitungan ∂E ∂s i menjadi sedikit lebih kompleks. Di sini digunakan lagi aturan rantai:
∂E ∂s i
=
∂E ∂s k k∈succ ( i ) ∂s k ∂s i
=
∂E ∂s k ∂net k ∂s i k∈succ ( i ) ∂s k ∂net k
=
∂E ′ (net k ) wki f log k∈succ ( i ) ∂s k
(2.13)
17
di mana succ(i) melambangkan semua unit k yang ada di dalam layer berikutnya ke arah output layer. Persamaan (2.11) memiliki asumsi bahwa nilai ∂E ∂s k untuk unit di layer berikutnya yang terhubung dengan unit i telah diketahui nilainya. Untuk itu perhitungan dilakukan mulai dari output layer, kemudian baru menghitung derivatif unit-unit di layer sebelumnya dengan menggunakan persamaan (2.11). Dengan kata lain, informasi error dipropagasikan secara berurutan bermula dari output layer dan berakhir pada input layer, sehingga algoritma ini diberi nama backpropagation [Riedmiller, 1994]. Setelah didapatkan derivatif parsial dari setiap bobot penghubung, maka untuk meminimisasi fungsi error dilakukan metode gradient descent: wij (t + 1) = wij (t ) + ∆wij (t )
(2.14)
dan
∆wij (t ) = −ε
∂E (t ) ∂wij
(2.15)
Pilihan nilai learning rate ε akan sangat berpengaruh pada proses training. Jika ε terlalu kecil, training akan memerlukan iterasi yang banyak sehingga lama untuk mencapai konvergen. Jika ε terlalu besar, bisa timbul osilasi sehingga tidak akan mencapai nilai error yang diharapkan.
2.3.4. Variasi pada Algoritma Backpropagation Salah satu metode paling awal yang diusulkan untuk mengatasi masalah lamanya waktu training adalah dengan menambahkan term momentum:
18
∆wij (t ) = −ε
∂E (t ) + µ∆wij (t − 1) ∂wij
(2.16)
di mana parameter momentum µ akan menentukan besarnya pengaruh perubahan bobot pada iterasi sebelumnya. Cara ini dapat bekerja dengan baik pada kasus tertentu, namun tidak bersifat umum. Kadang-kadang malah diperoleh hasil yang lebih baik tanpa menggunakan momentum sama sekali [Riedmiller, 1994]. Ada beberapa algoritma yang telah diusulkan untuk mempercepat proses training pada jaringan multi-layer perceptron. Di antaranya adalah algoritma Quickprop [Fahlman, 1988], resilient propagation (RPROP) [Riedmiller, 1993], dan Scaled Conjugate Gradient (SCG) [Moller, 1990].
2.3.5. Algoritma Quickprop Pada algoritma Quickprop dilakukan pendekatan dengan asumsi bahwa kurva fungsi error terhadap masing-masing bobot penghubung berbentuk parabola yang terbuka ke atas, dan gradien dari kurva error untuk suatu bobot tidak terpengaruh oleh bobot-bobot yang lain [Fahlman, 1988]. Dengan demikian perhitungan perubahan bobot hanya menggunakan informasi lokal pada masingmasing bobot. Perubahan bobot pada algoritma Quickprop dirumuskan sebagai berikut:
∂E (t ) ∂E ∂w ∆w(t ) = −ε (t ) + * ∆w(t − 1) ∂E ∂E ∂w (t − 1) − (t ) ∂w ∂w di mana:
(2.17)
19
∆w(t ) : perubahan bobot ∆w(t − 1) : perubahan bobot pada epoch sebelumnya
ε : adalah learning rate ∂E (t ) : derivatif error ∂w ∂E (t − 1) : derivatif error pada epoch sebelumnya ∂w Pada eksperimen dengan masalah XOR dan encoder/decoder [Fahlman, 1988], terbukti bahwa algoritma Quickprop dapat meningkatkan kecepatan training. Eksperimen dari [Schiffmann, 1993] juga menunjukkan peningkatan kecepatan training dan unjuk kerja yang signifikan.
20
BAB III PERANCANGAN DAN IMPLEMENTASI SISTEM
3.1. Data dan Peralatan Penelitian Data yang digunakan dalam penelitian ini terdiri dari sekumpulan citra untuk pelatihan (training data set) dan sekumpulan citra untuk pengujian (testing data set). Citra untuk pelatihan maupun untuk pengujian diperoleh dari berbagai sumber seperti foto, majalah, koran, televisi, dan internet. Citra yang akan digunakan untuk pengujian tidak akan digunakan dalam pelatihan. Citra yang digunakan memiliki 256 level keabuan (grayscale). Data citra untuk pelatihan dan pengujian yang diperoleh dari internet antara lain berasal dari: -
“The ORL Database of Faces”, AT&T Laboratories Cambridge (URL: http://www.uk.research.att.com/pub/data/att_faces.tar.Z),
-
“Test Images for the Face Detection Task” dari MIT dan CMU (URL: http://www.cs.cmu.edu/~har/faces.html),
-
“CBCL Face Database #1”, MIT Center For Biological and Computation Learning (URL: http://www.ai.mit.edu/projects/cbcl),
-
“UMIST
Face
Database”
[Graham,
Allinson,
1998]
(URL:
http://images.ee.umist.ac.uk/danny/index.html). Jumlah citra data wajah yang digunakan sebanyak 1000 citra wajah berukuran 20x20 pixel. Proses pemotongan (cropping) bagian wajah dari citra dilakukan secara manual. Kemudian dilakukan preprocessing yang berupa
21
resizing, histogram equalization, dan masking. Dari 1000 citra wajah tersebut juga dibuat 2000 citra tambahan dengan cara melakukan proses pencerminan dan rotasi dari 5 sampai 10 derajat terhadap citra asal secara random, sehingga secara keseluruhan diperoleh 3000 citra wajah. Citra non-wajah diambil dari 96 file citra yang tidak terdapat wajah di dalamnya. Contoh citra non-wajah adalah gambar pemandangan dalam dan luar ruangan, pepohonan, bunga, batuan, bangunan, dan lain-lain. Jika diambil seluruhnya, akan didapatkan lebih dari 36 juta subcitra berukuran 20x20 pixel. Tidak semua subcitra non-wajah tersebut akan diambil untuk pelatihan, namun dipilih secara otomatis dengan teknik active learning sebagaimana akan dijelaskan kemudian. Peralatan yang digunakan dalam penelitian ini adalah seperangkat komputer dengan prosesor Intel Celeron 667 MHz, memori 256 MB SDRAM, harddisk 20 GB, dan scanner. Implementasi perangkat lunaknya ditulis dengan menggunakan bahasa program C++ dengan compiler Borland C++ Builder.
3.2. Perancangan Sistem Secara garis besar sistem deteksi wajah yang dibangun di sini dibagi menjadi dua bagian utama, yaitu: -
Trainer JST (Jaringan Syaraf Tiruan), digunakan untuk pelatihan yang akan menghasilkan nilai bobot-bobot penghubung jaringan syaraf tiruan.
-
Detektor wajah, digunakan untuk mendeteksi wajah di dalam citra setelah pelatihan selesai dilakukan.
22
Gambar berikut menunjukkan perancangan sistem deteksi wajah secara garis besar.
Training Data Set
Trainer JST
Testing Data Set
Bobot JST Hasil Training
Citra Masukan
Detektor Wajah
Hasil Deteksi
Gambar 3.1. Sistem Deteksi Wajah
3.2.1. Diagram Aliran Data (Data Flow Diagram) Diagram aliran data (DFD) dari sistem deteksi wajah terdiri dari 2 bagian utama, yaitu: Sistem Trainer JST dan Sistem Detektor Wajah. Gambar 3.2 menunjukkan DFD level 0 dari Sistem Trainer JST.
User
Training Data Set
Sistem Trainer JST
Tampilan Proses Training
Gambar 3.2. DFD level 0 Sistem Trainer JST
User
23
Sistem Trainer JST dijabarkan lebih lanjut dengan DFD level 1 yang ditunjukkan pada gambar 3.3. Training data set terdiri dari contoh wajah maupun non-wajah berukuran 20x20 pixel. Training data set akan mengalami preprocessing berupa histogram equalization, masking, dan normalisasi. Hasil dari preprocessing ini dijadikan sebagai input untuk proses training yang menggunakan jaringan syaraf tiruan. Setelah proses training selesai, akan dihasilkan nilai bobot jaringan syaraf tiruan yang disimpan di dalam suatu struktur data. Selanjutnya nilai bobot ini akan disimpan ke dalam file yang dikehendaki oleh user. File ini nantinya akan digunakan di dalam proses deteksi wajah.
Contoh wajah User Contoh non-wajah Citra telah di-masking 3. Normalisasi
1. Histogram Equalization Citra telah diproses hist. equalization 2. Masking
Citra telah di-normalisasi Tampilan Proses Training
4. Training Nilai Bobot JST
Bobot JST
Gambar 3.3. DFD level 1 Sistem Trainer JST
User
24
Gambar 3.4 menunjukkan DFD level 0 dari Sistem Detektor Wajah. Sedangkan penjabaran lebih lanjut dari Sistem Detektor Wajah yang berupa DFD level 1 ditunjukkan pada gambar 3.5.
Citra Masukan User
Pilihan Bobot JST
Sistem Detektor Wajah
Lokasi Wajah User
Gambar 3.4. DFD level 0 Sistem Detektor Wajah
User memberikan masukan kepada sistem detektor wajah berupa citra masukan yang akan dideteksi dan file bobot JST yang diperoleh dari hasil training. Citra masukan ini akan dibaca dan dikonversi menjadi array. Selanjutnya pada citra tersebut dilakukan pencarian kandidat wajah. Pencarian kandidat wajah dilakukan dengan ekstraksi subcitra menggunakan window berukuran 20x20. Window ini digeser ke seluruh daerah citra, mulai dari sudut kiri atas sampai sudut kanan bawah, dengan tujuan agar dapat mendeteksi wajah di semua posisi di dalam citra. Pada proses ekstraksi subcitra ini citra juga akan diperkecil secara berulang dengan perbandingan 1:1.2 dengan tujuan agar dapat mendeteksi wajah dengan semua ukuran di dalam citra. Selanjutnya subcitra 20x20 pixel tersebut akan mengalami preprocessing berupa histogram equalization, masking, dan normalisasi yang sama seperti pada
25
saat training. Hasil preprocessing ini dijadikan sebagai input untuk pengklasifikasi JST. Pengklasifikasi JST ini akan menghasilkan kandidat-kandidat wajah.
User
Citra Masukan
2. Baca citra
Pilihan Bobot JST
Bobot JST
Array Pixel Citra
Nilai Bobot JST
1. Pilih Bobot JST
User
Lokasi Wajah Bobot JST Terpilih
4. Merging
3. Cari kandidat wajah
Kandidat Wajah
Gambar 3.5. DFD level 1 Sistem Detektor Wajah
26
Selanjutnya kandidat-kandidat wajah ini akan mengalami proses merging untuk mendapatkan hasil akhir berupa lokasi dan ukuran wajah yang terdeteksi. Hasil akhir deteksi ini akan ditampilkan kepada user, dan dapat disimpan ke dalam file jika diinginkan oleh user.
3.2.2. Jaringan Syaraf Tiruan Jaringan syaraf yang digunakan pada sistem ini menggunakan jenis multilayer perceptron. Arsitektur yang digunakan diadaptasi dari hasil penelitian [Rowley, 1998] dengan sedikit modifikasi. Susunan unit dari jaringan ini ditunjukkan pada gambar 3.6. Lapisan input terdiri dari 400 unit input, yang menerima masukan dari nilai grayscale pixel 20x20 dari subcitra yang akan dideteksi. Sebelum dijadikan input untuk JST, nilai grayscale yang berkisar dari 0 sampai 255 dinormalisasi menjadi antara –1 dan 1. Cara ini disarankan oleh [LeCun, 1998] yang menunjukkan bahwa konvergensi umumnya akan lebih cepat tercapai jika nilai rata-rata dari input data training mendekati nol. Lapisan output terdiri dari sebuah unit dengan nilai keluaran berkisar antara –1 dan 1. Pada training data set didefinisikan nilai 1 untuk data wajah dan – 1 untuk data non-wajah. Agar nilai output dari JST memiliki range antara –1 sampai dengan 1, digunakan fungsi aktivasi sigmoid bipolar: si = g log (net i ) =
2 −1 1 + e − neti
Lapisan tersembunyi (hidden layer) terdiri dari total 25+16=41 unit. Bagian pertama terhubung dengan lapisan input yang membentuk 25 area
27
berukuran 4x4 pixel. Bagian kedua terhubung dengan lapisan input yang membentuk 16 area berukuran 5x5 pixel. Susunan koneksi seperti ini dipilih dengan tujuan agar unit-unit tersembunyi dapat mendeteksi fitur-fitur lokal dari wajah yang berperan dalam membedakan antara citra wajah dengan non-wajah. Susunan semacam ini juga umum digunakan pada kasus pengenalan suara dan karakter [Rowley, 1998]. Secara keseluruhan jaringan ini memiliki 883 bobot penghubung, sudah termasuk bias. Pada sistem [Rowley, 1998] yang lebih kompleks, jumlah bobot penghubungnya mencapai 4357. Dengan jumlah bobot yang semakin besar diperlukan data pelatihan yang lebih banyak, waktu training yang lebih lama, dan waktu deteksi yang lebih lama.
Input Layer
Hidden Layer
grid 5x5 pixel
Output input 20x20 pixel
grid 4x4 pixel
Gambar 3.6. Arsitektur Jaringan Syaraf Tiruan
28
Untuk meningkatkan kecepatan proses pelatihan digunakan algoritma Quickprop. Algoritma Quickprop ini pertama kali diperkenalkan pada [Fahlman, 1988] sebagai salah satu alternatif dari algoritma backpropagation untuk melakukan pelatihan pada multi-layer perceptron. Hasil akhir training yang berupa nilai bobot-bobot penghubung akan disimpan ke suatu file. File ini nantinya akan digunakan oleh detektor wajah untuk melakukan tugasnya.
3.2.3. Pelatihan Active Learning Pada saat pelatihan, relatif mudah untuk memilih contoh citra wajah yang akan digunakan. Namun untuk memilih contoh citra non-wajah adalah lebih sulit, karena jenis objek non-wajah di dunia ini jauh lebih banyak daripada objek wajah. Karena itu pelatihan dilakukan dengan menggunakan teknik yang disebut dengan active learning yang juga digunakan pada [Sung, 1996]. Cara ini disebut juga dengan bootstrapping pada [Rowley, 1998]. Pada teknik active learning ini training dilakukan secara bertahap. Pada tahap pertama training dimulai dengan menggunakan sedikit data non-wajah. Pada tahap berikutnya, data training non-wajah ditambah sedikit demi sedikit. Namun data tambahan tersebut diseleksi hanya untuk data tertentu saja, yaitu data yang yang dideteksi sebagai wajah (false positive) pada hasil training tahap sebelumnya.
29
Koleksi Contoh Data Wajah
Data Training
Data Awal Non-Wajah
Pilih random
Koleksi Contoh Data Non-Wajah
Trainer JST
Data Tambahan Non-Wajah
Bobot JST Hasil Training
Detektor Wajah
Hasil Deteksi (False Positive)
Gambar 3.7. Metode Pelatihan Active Learning Dengan cara ini, data tambahan yang terpilih untuk training hanya data yang belum berhasil diklasifikasi dengan benar oleh jaringan syaraf tiruan. Data yang sudah dapat diklasifikasi dengan baik oleh jaringan syaraf tiruan tidak perlu ditambahkan sebagai data training. Dengan demikian jumlah data training yang digunakan untuk jaringan syaraf tiruan akan lebih sedikit. Karena data training yang digunakan lebih sedikit, waktu yang diperlukan untuk proses training juga lebih singkat.
30
Pada tahap pertama, bobot awal yang digunakan untuk jaringan syaraf tiruan dipilih secara random. Pada tahap berikutnya, bobot awal yang digunakan adalah bobot yang dihasilkan pada tahap sebelumnya.
3.2.4. Detektor Wajah Bagian detektor wajah ini menggunakan arsitektur jaringan syaraf yang sama dengan yang digunakan untuk training. Bobot penghubung yang digunakan diambil dari bobot terakhir yang dihasilkan pada proses training dengan menggunakan teknik active learning. Hasil deteksi akan diputuskan sebagai wajah jika output dari JST lebih dari 0, dan diputuskan sebagai non-wajah jika output JST kurang dari atau sama dengan 0. Gambar 3.8 menunjukkan diagram alir bagian detektor wajah.
31
Pilih Bobot JST, Baca Citra
Start
Baca Window Pertama Perkecil citra
Histogram Equalization
Masking Geser window
Normalisasi
Pengklasifikasi JST
Simpan Kandidat Wajah
Ya
Ditemukan Wajah? Tidak
Window Terakhir?
Tidak
Ya Ukuran citra > 20x20 pixel?
Ya
Tidak Merging Kandidat Wajah
Tampilkan Lokasi Wajah
End
Gambar 3.8. Diagram Alir Bagian Detektor Wajah
32
3.2.4.1. Ekstraksi Subcitra Pada citra yang akan dideteksi, posisi wajah bisa berada di mana saja. Pengklasifikasi jaringan syaraf tiruan pada detektor wajah memerlukan input citra 20x20 pixel. Karena itu digunakan window 20x20 pixel yang digeser melalui seluruh daerah citra. Detektor akan memeriksa satu persatu subcitra yang dilalui oleh window tersebut. Pada citra yang dideteksi, wajah bisa memiliki ukuran yang bervariasi. Karena itu citra akan diperkecil secara bertahap dengan skala perbandingan 1:1,2 sebagaimana dilakukan pada [Rowley, 1998]. Pada setiap ukuran citra yang diperkecil, window 20x20 pixel akan digeser melalui seluruh area citra. Dengan demikian detektor dapat mendeteksi wajah dengan berbagai ukuran. Cara ini juga dilakukan pada [Sung, 1996] dan [Rowley, 1998].
3.2.4.2. Resizing Proses resizing digunakan baik pada citra data pelatihan maupun pada citra yang akan dideteksi. Pada citra data pelatihan, citra wajah yang diperoleh dari berbagai sumber memiliki ukuran yang beragam, karena itu harus diseragamkan sehingga memiliki ukuran 20x20 pixel. Proses resizing atau resampling dilakukan dengan menggunakan metode bilinear interpolation [Press, 1992]. Di sini citra digital dengan dimensi m x n pixel dapat dianggap sebagai matriks dua dimensi. Matriks tersebut memiliki nilai ya[1..m][1..n] yang isinya adalah level grayscale dari pixel-pixel di dalam citra. Informasi lokasi dari pixel-
33
pixel tersebut disimpan dalam array x1a[1..m] dan x2a[1..n]. Relasi antara nilainilai tersebut dapat dituliskan sebagai: ya[j][k] = y(x1a[j], x2a[k]) Dengan interpolasi, akan diestimasi nilai fungsi y(x1, x2) pada suatu lokasi (x1,x2) di mana x1 dan x2 bukan nilai integer di antara 1..m dan 1..n. Formula untuk melakukan bilinear interpolasi adalah: t = (x1 − x1a[j]) / (x1a[j+1]− x1a[j]) u = (x2 − x2a[k]) / (x2a[k+1]− x2a[k]) dan y(x1, x2) = (1 − t)(1 − u)y1 + t(1 − u)y2 + tuy3 + (1 − t)uy4 di mana y1 = ya[j][k] y2 = ya[j+1][k] y3 = ya[j+1][k+1] y4 = ya[j][k+1] yaitu titik-titik yang berada di sekeliling titik yang akan diinterpolasi.
3.2.4.3. Histogram Equalization Histogram equalization digunakan untuk melakukan perluasan kontras citra (contrast strecthing) secara otomatis. Setelah melalui histogram equalization, citra akan memiliki histogram yang mendekati sama [Gonzalez, 1992].
34
Misalkan r adalah nilai graylevel pixel citra yang akan diproses, dan pr(rk) adalah probabilitas munculnya level grayscale rk di dalam citra. p r (rk ) =
nk n
0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1
di mana L adalah banyaknya level grayscale, nk adalah banyaknya pixel dengan level grayscale rk muncul di dalam citra, dan n adalah banyaknya seluruh pixel di dalam citra. sk
= T (rk )
=
k
nj
j =0
n
=
k
nj
j =0
n
0 ≤ rk ≤ 1 dan
k = 0,1,..., L − 1
3.2.4.4. Masking Proses masking dilakukan untuk menutup bagian sudut-sudut citra sehingga mengurangi kemungkinan variasi data yang muncul pada bagian-bagian tersebut. Dengan demikian dimensi dari data juga akan menjadi lebih kecil. Proses ini juga dilakukan pada penelitian [Sung, 1996] dan [Rowley, 1998].
3.2.4.5. Penggabungan (Merging) Kandidat Wajah Pada saat mendeteksi wajah di suatu citra, seringkali pengklasifikasi JST mendeteksi wajah di beberapa lokasi yang bersinggungan untuk sebuah wajah yang sama. Untuk itu dilakukan penggabungan (merging) pada hasil deteksi yang bersinggungan tersebut dengan mengambil nilai rata-rata dari posisi dan ukuran window dimana wajah tersebut dideteksi. Proses penggabungan ini juga dilakukan pada penelitian [Rowley, 1998].
35
3.2.4.6. User Interface Dari sudut pandang pemakai, masukan dari detektor wajah adalah file citra dengan format BMP atau JPG. File citra tersebut dapat dipilih melalui suatu kotak dialog di mana pemakai dapat memilih drive dan folder yang diinginkan. Output dari hasil deteksi adalah lokasi-lokasi wajah yang berhasil dideteksi. Area di mana wajah terdeteksi juga akan ditandai dengan kotak. Lokasilokasi wajah yang terdeteksi dapat disimpan ke suatu file, sehingga di lain waktu dapat dilihat kembali tanpa harus mengulangi proses deteksi. Pemakai dapat memilih set nilai bobot penghubung yang diinginkan. Jika trainer JST menjalani training lebih lanjut dengan tambahan data training baru, maka akan dihasilkan nilai bobot yang baru. Nilai bobot yang baru ini dapat digunakan untuk melakukan deteksi wajah dengan menggunakan program yang sama. Sistem detektor wajah ini juga dirancang agar dapat melakukan deteksi wajah pada beberapa citra sekaligus secara batch, dan menyimpan informasi hasil deteksinya di suatu file. Dengan cara ini, pemakai dapat membiarkan program melakukan deteksi untuk sejumlah file citra sekaligus, kemudian baru mengamati hasil deteksinya setelah seluruh citra selesai di deteksi.
3.3. Implementasi Sistem Untuk mengimplementasikan sistem, dibuat program aplikasi dengan menggunakan bahasa C++. User interface dibuat dengan menggunakan fasilitas komponen visual yang disediakan Borland C++ Builder.
36
3.3.1. Jaringan Syaraf Tiruan Jaringan syaraf yang digunakan diimplementasikan sebagai objek pada C++. Sebuah kelas abstrak untuk jaringan syaraf tiruan dibuat agar dapat diturunkan menjadi kelas-kelas baru yang memiliki susunan unit dan koneksi yang berbeda-beda. Kelas ini mendefinisikan fungsi-fungsi yang harus diimplementasikan pada setiap jaringan syaraf tiruan. Berikut ini kelas abstrak yang digunakan: class NNBaseClass // abstract class { public: double dTargetValueFace; virtual void SetInitWeightFileName(AnsiString sInitWeightFileName) = 0; virtual void SetTrngDataFileName(AnsiString sTrngDataFileName) = 0; virtual int StartTrainingQuickprop() = 0; virtual int StartTraining() = 0; virtual bool InitWeight() = 0; virtual void SaveNNWeights(AnsiString sNNWFileName) = 0; virtual double yout(double *x) = 0; virtual ~NNBaseClass() {}; private: TrainingDataClass *aTRD; int Ntrd; int wrongClass; int wrongClassFace; int wrongClassNonFace; int nDiffSign; AnsiString m_sInitWeightFileName; AnsiString m_sTrngDataFileName; AnsiString className; double CalcError(); void DumpFinalOutput(); };
Training data set dan bobot jaringan syaraf tiruan diimplementasikan dengan struktur data sebagai berikut: struct TrainingDataClass { double trd_out; double trd_in[400]; };
37
... double double double double
* wh; // bobot pada layer 1 (hidden layer) * wo; // bobot pada output layer * bh; // bias pada layer 1 (hidden layer) bo; // bias pada layer output
Output dari jaringan syaraf tiruan dihitung dengan lebih dulu menghitung nilai dari unit-unit pada hidden layer. Implementasi program untuk menghitung nilai output dari jaringan syaraf tiruan adalah sebagai berikut:
double NN1dClass::yout(double *x) // hitung actual output utk 1 pattern { int j; double hsum, osum, y; // hitung hasil node pada hidden layer // hitung hout[] // hidden layer 4x4, masing2 menerima 25 input for (j=0; j
+ + + + + + + + +
38
n = st + 42; hsum += (x[n] n = st + 43; hsum += (x[n] n = st + 60; hsum += (x[n] n = st + 61; hsum += (x[n] n = st + 62; hsum += (x[n] n = st + 63; hsum += (x[n] hsum += bh[nwo1+j]; hout[nwo1+j] = fa(hsum);
* * * * * *
wh[nwh1+n]); wh[nwh1+n]); wh[nwh1+n]); wh[nwh1+n]); wh[nwh1+n]); wh[nwh1+n]);
} // hitung hasil node pada output layer osum = 0.0; for (j=0; j
Implementasi program untuk menghitung nilai MSE (mean square error) dari jaringan syaraf tiruan adalah sebagai berikut: double NN1dClass::CalcError() { static int i; static double Ep, y, t; Ep = 0; for (i=0; i
Implementasi program untuk melakukan pelatihan jaringan syaraf tiruan dengan menggunakan algoritma Quickprop dapat dilihat pada Lampiran 1.
39
3.3.2. Window Scanning Proses window scanning dilakukan pada saat akan melakukan deteksi wajah pada citra sembarang. Proses ini diikuti dengan proses resizing untuk melakukan scanning pada skala ukuran citra yang berbeda. Implementasi programnya dapat dilihat pada kutipan kode berikut: void __fastcall TForm1::DetectFaces1Click(TObject *Sender) { ... ... nFaceFound = 0; nscale = 0; nwindow_allscale = 0; while (true) { nwindow = 0; ntotal_window_currentsize = (w-19)*(h-19); iy = 0; while (true) { // shift 20x20 window vertically ix = 0; while (true) { // shift 20x20 window horizontally // crop/copy 20x20 image window to img2[][] for (int jy=0; jy<20; jy++) { for (int jx=0; jx<20; jx++) { img2[jx][jy] = img1[ix+jx][iy+jy]; } } // begin proses this window // ix, iy is window position in current (resized) image ProcessImageWindow(ix, iy); // end proses this window nwindow++; nwindow_allscale++; ix++; if (blAbortDetection) break; if (blPauseDetection) { ShowMessage("Detection paused. Press OK to continue."); blPauseDetection = false; } if ((ix+20)>w) break; } iy++; if (blAbortDetection) break; if ((iy+20)>h) break; } // resampling image to a smaller size, get new height & width // rescaling original image size img0[][] by 1:1.2 (Rowley, 1998), nscale++; w = (double)img0width * pow((1/RESIZE_IMAGE_BY),nscale); h = (double)img0height * pow((1/RESIZE_IMAGE_BY),nscale); if (blAbortDetection) break; if ((w<20) || (h<20)) // we have reached the smallest possible resized image
40
break; else { // save result in img1[][] ResizeImage(w, h); // update img1width, img1height, img1[][] } } ... }
3.3.3. Resizing Proses resizing digunakan untuk menyiapkan data training maupun pada saat proses deteksi wajah. Contoh citra wajah yang diperoleh dari berbagai sumber memiliki ukuran yang beragam. Sebelum proses training, resizing dilakukan pada contoh citra wajah untuk menghasilkan citra data pelatihan yang berukuran 20x20 pixel. Pada proses deteksi wajah, resizing dilakukan pada citra yang akan dideteksi dengan tujuan agar dapat mendeteksi wajah dalam berbagai ukuran di dalam citra. Implementasi program untuk resizing dapat dilihat pada kutipan kode berikut: void ResizeImage(int new_width, int new_height) { // input: img1[][], output: img1[][] int w1, h1, w2, h2; int x, y, g; int j, k; int nn1, nn2, nn3, nn4; // four nearest neighborhood pixels double xx1, yy1, t, u; static unsigned char img1temp[1400][1400]; // temporary resized image for (int iy=0; iy
41
for (y=0; y
3.3.4. Histogram Equalization Histogram equalization digunakan untuk melakukan perluasan kontras citra (contrast strecthing) secara otomatis. Dengan demikian citra yang akan dideteksi maupun yang digunakan untuk pelatihan memiliki kontras yang seragam. Implementasi dari histogram equalization dapat dilihat pada kutipan program berikut: void HistogramEqualize() { // histogram equalization static int nr[256]; static int ns[256]; int i, k, ix, iy; unsigned char g; // build histogram table for (i=0; i<256; i++) nr[i]=0; for (ix=0; ix
42
for (ix=0; ix
Gambar berikut menunjukkan contoh hasil proses histogram equalization pada suatu citra.
Gambar 3.9. Contoh Citra dan Histogramnya
3.3.5. Masking Proses masking dilakukan untuk menutup bagian sudut-sudut citra sehingga mengurangi kemungkinan variasi yang timbul pada bagian-bagian tersebut. Implementasi dari histogram equalization dapat dilihat pada kutipan program berikut:
43
inline bool isMaskPosition_(int x,int y) { if ((x>4) && (x<15)) return false; if ((y>4) && (y<15)) return false; // kiri atas if ((x+y)<=4) return true; // kiri bawah if ((y-x)>=15) return true; // kanan atas if ((x-y)>=15) return true; // kanan bawah if ((x+y)>=34) return true; // otherwise return false; } //-------------------------------------------------------------------------void InitWindowMaskInfo() // inisialisasi informasi mask pada 4 sudut image window { int n = 0; for (int iy=0; iy<20; iy++) { for (int ix=0; ix<20; ix++) { if (isMaskPosition_(ix,iy)) { bl_isMask[ix][iy] = true; uc_isMask[n] = 0x00; } else { bl_isMask[ix][iy] = false; uc_isMask[n] = 0xFF; } n++; } } }
Gambar 3.10 menunjukkan contoh citra yang telah mengalami proses resizing, histogram equalization, dan masking. Sedangkan gambar 3.11 menunjukkan beberapa contoh data wajah yang telah mengalami preprocessing.
44
Gambar 3.10. Contoh citra yang telah mengalami proses resizing, histogram equalization, dan masking
Gambar 3.11. Beberapa contoh data wajah yang telah mengalami preprocessing
45
3.3.6. Penggabungan (Merging) Kandidat Wajah Hasil deteksi dari pengklasifikasi jaringan syaraf tiruan adalah kandidatkandidat wajah. Penggabungan (merging) dilakukan untuk menyatukan kandidatkandidat wajah yang bersinggungan (overlapped) dengan cara mengambil nilai rata-rata dari posisi dan ukuran kandidat-kandidat wajah tersebut. Tujuannya adalah agar satu wajah yang sama tidak dideteksi sebagai beberapa wajah. Implementasi dari proses ini dapat dilihat pada kutipan program berikut: void __fastcall TForm1::Merge1Click(TObject *Sender) { TRect r; bool blRectMerged; double pctOverlappedPixel; if (nFaceFound==0) { nMergedFaceFoundStage1 = 0; return; } for (int i=0; i<1000; i++) rMergedFace1[i].nRect = 1; rMergedFace1[1].rect = cFace.rect[1]; rMergedFace1[1].totalNNvalue = cFace.value[1]; nMergedFaceFoundStage1 = 1; for (int i=2; i<=nFaceFound; i++) { blRectMerged = false; for (int j=1; j<=nMergedFaceFoundStage1; j++) { TRect newOverlappedRect; CalcOverlappedRect(cFace.rect[i], rMergedFace1[j].rect, newOverlappedRect, pctOverlappedPixel, dummy); if (pctOverlappedPixel > THRESHOLD_PCT_OVERLAPPEDPIXEL) { // merge to previous face rMergedFace1[j].rect = newOverlappedRect; rMergedFace1[j].nRect++; rMergedFace1[j].totalNNvalue += cFace.value[i]; blRectMerged = true; break; } } if (!blRectMerged) { // not merged to any previous face nMergedFaceFoundStage1++; rMergedFace1[nMergedFaceFoundStage1].rect = cFace.rect[i]; rMergedFace1[nMergedFaceFoundStage1].totalNNvalue cFace.value[i]; } } for (int j=1; j<=nMergedFaceFoundStage1; j++) rMergedFace2[j].rect = rMergedFace1[j].rect; nMergedFaceFound = nMergedFaceFoundStage1; AnsiString s = AnsiString("nMergedFaceFoundStage1=") nMergedFaceFoundStage1; Memo1->Lines->Add(s);
=
+
46
// draw boxes on merged face Image1b->Picture->Assign(Image1->Picture); for (int j=1; j<=nMergedFaceFound; j++) { r = rMergedFace1[j].rect; Form1->Image1b->Canvas->Brush->Style = bsClear; Form1->Image1b->Canvas->Pen->Mode = pmCopy; Form1->Image1b->Canvas->Pen->Color = clWhite; Form1->Image1b->Canvas->Rectangle(r.Left, r.Top, r.Right, r.Bottom); Form1->Image1b->Canvas->Pen->Color = clBlack; Form1->Image1b->Canvas->Rectangle(r.Left-1, r.Top-1, r.Right+1, r.Bottom+1); } Image1->Hide(); Image1b->Show(); Label6->Caption = AnsiString(nFaceFound) + " ---> " + nMergedFaceFound; }
47
BAB IV HASIL DAN PEMBAHASAN
4.1. Pengukuran Evaluasi Unjuk Kerja Untuk mengukur evaluasi unjuk kerja dari detektor wajah, pada umumnya digunakan dua parameter, yaitu detection rate dan false positive rate [Yang, 2002]. Detection rate adalah perbandingan antara jumlah wajah yang berhasil dideteksi dengan jumlah seluruh wajah yang ada. Sedangkan false positive rate adalah banyaknya subcitra non-wajah yang dideteksi sebagai wajah.
4.2. Hasil Deteksi Kandidat Wajah Pada saat dilakukan deteksi wajah pada citra, biasanya sebuah wajah terdeteksi pada beberapa lokasi yang berdekatan. Lokasi-lokasi ini disebut dengan kandidat wajah. Untuk menentukan lokasi final dari wajah perlu dilakukan proses penggabungan (merging) sebagaimana telah dijelaskan pada bab 3. Gambar 4.1. adalah contoh hasil deteksi sebelum dan sesudah proses merging. Tampak bahwa sebelum dilakukan proses merging, terdapat beberapa lokasi kandidat wajah yang terdeteksi, sedangkan kenyataannya hanya terdapat satu wajah di dalam citra tersebut. Setelah dilakukan proses merging, hanya satu lokasi yang dianggap sebagai lokasi wajah yang terdeteksi.
48
Gambar 4.1. Hasil deteksi sebelum dan sesudah proses merging
4.3. Hasil Deteksi Gambar 4.2. dan 4.3. menunjukkan contoh-contoh hasil deteksi yang dilakukan pada beberapa citra pengujian. Untuk membandingkan dengan hasil penelitian yang telah dilakukan sebelumnya, dilakukan pengujian dengan data citra standar yang sering digunakan dalam penelitian di bidang deteksi wajah. Data citra standar yang digunakan berasal dari MIT yang terdiri dari 23 file citra yang secara keseluruhan berisi 149 wajah (MIT-23). Kumpulan citra standar ini pertama kali dipublikasikan pada [Sung, 1994]. Pada data uji ini diperoleh hasil detection rate sebesar 71,14% dan false positives sebanyak 62. Hasil ini diperoleh dengan melakukan training yang menggunakan 3000 data wajah dan 5200 data non-wajah.
49
Tabel 4.1 menunjukkan hasil deteksi yang pernah dilakukan oleh para peneliti lain dengan menggunakan data uji MIT-23. Namun demikian harus diingat bahwa menurut [Hjelmas, 2001] perbandingan ini tidak bisa dijadikan patokan mutlak untuk menyimpulkan bahwa satu metode lebih baik dari metode yang lain, karena faktor-faktor berikut: •
data set yang digunakan untuk training tidak sama
•
jumlah data yang digunakan untuk training tidak sama Sebagai contoh, pada sistem [Sung, 1994] digunakan 4150 data wajah dan
6189 data non-wajah. Pada sistem [Rowley, 1998] dilaporkan menggunakan sekitar 16000 data wajah dan 8000 data non-wajah. Pada sistem [Osuna, 1997] digunakan 50000 data, namun tidak dilaporkan berapa banyaknya data wajah dan non-wajah. Pada sistem yang lain tidak dilaporkan berapa jumlah data yang digunakan.
Metode Support vector machines (SVM) [Osuna, 1997] Distribution-based dan clustering [Sung, Poggio, 1994] Neural Networks [Rowley, 1998] Kullback relative information [Lew, Huijsmans, 1996]
Detection Rate 74,2% 79,9% 84,5% 94,1%
Tabel 4.1 Beberapa hasil deteksi pada data uji MIT-23
False Positif 20 5 8 64
50
Gambar 4.2. Contoh Hasil Deteksi Wajah
51
Gambar 4.3. Contoh Hasil Deteksi dengan False Positive dan Wajah yang Tidak Terdeteksi
52
4.4. Pengaruh Jumlah Data Training yang Digunakan Tabel 4.2 menunjukkan pengaruh jumlah data training yang digunakan terhadap hasil deteksi. Tabel ini berdasarkan hasil deteksi pada suatu citra berisi 15 wajah dan memiliki total 790.797 window. Terlihat bahwa semakin banyak data training non-wajah yang digunakan, semakin kecil angka false positive yang dihasilkan. Hal ini menunjukkan bahwa dengan data yang semakin lengkap, hasil belajar sistem akan semakin baik.
Jumlah data training nonwajah total wajah 1000 400 1400 1000 600 1600 1000 800 1800 1000 1000 2000 1000 1200 2200 1000 1400 2400 1000 1600 2600 1000 1800 2800 1000 2000 3000 1000 2200 3200 1000 2400 3400 1000 2600 3600 1000 2800 3800 1000 3000 4000 1000 3200 4200 1000 3400 4400 1000 3600 4600 1000 3800 4800 1000 4000 5000
Detection Rate
False Positif
9/15 12/15 14/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15 15/15
64 51 44 42 32 31 24 23 19 10 5 4 2 2 2 2 1 1 1
Tabel 4.2 Pengaruh Jumlah Data Training pada Unjuk Kerja Deteksi Wajah
53
4.5. Pengaruh Algoritma Quickprop pada Kecepatan Training Tabel 4.3 menunjukkan perbandingan waktu training yang diperlukan antara training yang menggunakan algoritma backpropagation standar dengan training yang menggunakan algoritma Quickprop. Terlihat bahwa dengan jumlah data training yang semakin besar, algoritma Quickprop memberikan peningkatan kecepatan yang signifikan.
Jumlah Data training
MSE Error
2000 3000 4000
0.05 0.05 0.05
Waktu training (detik) Backprop standar 49 649 4664
Quickprop 12 96 867
Tabel 4.3 Pengaruh Algoritma Quickprop pada Kecepatan Training
4.6. Pengaruh Metode Active Learning Kami mencoba membandingkan hasil yang diperoleh antara training dengan menggunakan data yang didapatkan melalui metode active learning, dengan training yang menggunakan data yang diambil secara random. Jumlah data yang digunakan adalah sama. Tabel 4.4 menunjukkan hasilnya. Terlihat bahwa teknik active learning berguna dalam memilih data training yang benar-benar perlu ditambahkan, sehingga dapat meminimalkan jumlah data training yang digunakan.
54
Data training wajah 3000 3000
nonwajah 5200 3000
Random Data total 8200 6000
Detection Rate 63,76% 62,42%
False Positive 732 1160
Active Learning Detection Rate 71,14% 71,14%
False Positive 62 201
Tabel 4.4 Pengaruh Active Learning pada Unjuk Kerja Deteksi Wajah
55
BAB V KESIMPULAN DAN SARAN
5.1. Kesimpulan Dari hasil penelitian dan pembahasan yang telah dilakukan menunjukkan bahwa jaringan syaraf tiruan dapat dimanfaatkan untuk melakukan deteksi wajah pada citra digital. Dengan menggunakan data uji standar (MIT-23) yang terdiri dari 23 file citra berisi 149 wajah, dengan total jumlah window yang dideteksi sebanyak 9.720.932, didapatkan hasil detection rate 71,14% dan false positive 62. Pada sistem deteksi wajah yang berbasis contoh, hasil yang diperoleh sangat dipengaruhi oleh banyaknya contoh data dan kualitas data yang digunakan dalam training. Pada proses training dengan menggunakan data yang berjumlah besar, algoritma Quickprop dapat memberikan peningkatan kecepatan yang signifikan terhadap algoritma backpropagation standar. Metode active learning dapat digunakan untuk memilih tambahan data training secara selektif. Metode ini bermanfaat untuk meminimalkan jumlah data training yang digunakan sehingga membantu mempercepat proses training.
56
5.2. Saran Untuk meningkatkan unjuk kerja dari sistem pendeteksi wajah, dapat dilakukan dengan memberikan pelatihan lebih lanjut dengan tambahan data training yang lebih banyak dan lebih bervariasi. Pada kasus pendeteksian wajah di dalam citra berwarna, akurasi dapat ditingkatkan dengan mengkombinasikan sistem ini dengan sistem pendeteksi warna kulit. Kecepatan deteksi juga dapat ditingkatkan dengan bantuan pendeteksi warna kulit, karena dengan demikian deteksi dengan jaringan syaraf tiruan hanya perlu dilakukan pada area yang mengandung warna kulit. Teknologi deteksi wajah adalah salah satu bidang penelitian yang masih terus berkembang. Hasil dari deteksi wajah ini dapat dimanfaatkan lebih lanjut untuk membangun sistem pengenalan wajah (face recognition).
DAFTAR PUSTAKA Fahlman, S.E., 1988, “ An Empirical Study of Learning Speed in BackPropagation Networks” , Technical Report CMU-CS-88-162, Carnegie Mellon University, USA. Fausett, L., 1994, Fundamentals of Neural Networks: Architectures, Algorithms, and Applications, Prentice-Hall Inc., USA. Gibb, J., 1996, Back Propagation Family Album, ftp://ftp.mpce.mq.edu.au/comp/ techreports/960005.gibb.ps, Macquarie University, Australia. Gonzalez, R.C., Woods, R.E., 1992, Digital Image Processing, Addison-Wesley Publishing Company, USA. Graham, D. B., Allinson, N. M., 1998, “ Characterizing Virtual Eigensignatures for General Purpose Face Recognition” , (in) Face Recognition: From Theory to Applications, NATO ASI Series F, Computer and Systems Sciences, Vol. 163. H. Wechsler, P. J. Phillips, V. Bruce, F. FogelmanSoulie and T. S. Huang (eds), pp 446-456. Haykin, S., 1994, Neural Networks: A Comprehensive Foundation, Macmillan College Publishing Company, USA. Hjelmas, E., Low, B.K., 2001, “ Face Detection: A Survey” , Computer Vision and Image Understanding. 83, pp. 236-274. LeCun, Y., Bottou, L., Orr, G.B., Muller, K.R., 1998, “ Efficient BackProp” , Neural Networks: tricks of the trade, Springer. Lew, M. S., Huijsmans, N., 1996, “ Information Theory and Face Detection” , Proc. of International Conference on Pattern Recognition 1996. Osuna, E., Freund, R., Girosi, F., 1997, “ Training Support Vector Machines: An Application to Face Detection” , Proc. IEEE Conf. Computer Vision and Pattern Recognition 1997. Press, W.H., 1992, Numerical Recipes In C: The Art Of Scientific Computing, Cambridge University Press, USA. Riedmiller, M., 1994, “ Advanced Supervised Learning in Multi-Layer Perceptrons – From Backpropagation to Adaptive Learning Algorithms” , Int. Journal of Computer Standards and Interfaces (16) 1994.
Rowley, H., Baluja, S., Kanade, T., 1998, “ Neural Network-Based Face Detection” , IEEE Trans. Pattern Analysis and Machine Intelligence, vol. 20, no. 1. Rumelhart, D.E., Hinton, G.E., Williams, R.J., 1986, “ Learning Internal Representations by Error Propagation” , Parallel Distributed Processing, chapter 8, MIT Press, Cambridge, MA. Sarle, W.S., ed., 2002, Neural Network FAQ, URL: ftp://ftp.sas.com/pub/neural/ FAQ.html Schiffmann, W., Joost, M., Werner, R., 1993, “ Comparison of Optimized Backpropagation Algorithms” , Proc. of the European Symposium on Artificial Neural Networks (ESANN) ’93, Brussels. Schneiderman, H., 2000, “ A Statistical Approach to 3D Object Detection Applied to Faces and Cars” , CMU-RI-TR-00-06, Robotics Institute Carnegie Mellon University. Schneiderman, H., Kanade, T., 2000, “ A Statistical Approach to 3D Object Detection Applied to Faces and Cars” , Proc. IEEE Conf. Computer Vision and Pattern Recognition vol. 1. Sung, K.K., 1996, “ Learning and Example Selection for Object and Pattern Detection” , AITR 1572, Massachusetts Institute of Technology AI Lab. Sung, K.K., Poggio, T., 1994, “ Example-Based Learning for View-Based Human Face Detection” , Technical Report AI Memo 1521, Massachusetts Institute of Technology AI Lab. Turk, M., Pentland, A., 1991, “ Eigenfaces for Recognition” , J. Cognitive Neuroscience, vol. 3, no.1. Yang, M.H., Kriegman, D., Ahuja, N., 2002, “ Detecting Faces in Images: A Survey” , IEEE Trans. Pattern Analysis and Machine Intelligence, vol. 24, no. 1.
LAMPIRAN 1 Listing program implementasi algoritma Quickprop: int NN1dClass::StartTrainingQuickprop() { /************************************************************ USE QUICKPROP ALGORITHM (reference: Fahlman, 1988) Variable name convention: w => weight, b => bias ***********************************************************/ double Ep; // Error double mju; // learning rate double mgf; // maximum growth factor (denoted mju in some literature) double * xi; // pointer to input training data double t, dfa_y, ynet, del_o, dfa_h, sigma_x; double del_h; int i,j,k; mju = Form1->editLearnRate->Text.ToDouble(); mgf = Form1->editMGF->Text.ToDouble(); nMAX_EPOCH = Form1->editMaxEpoch->Text.ToInt(); errorGoal = Form1->editErrorGoal->Text.ToDouble(); dTargetValueFace = Form1->editTargetValueFace->Text.ToDouble(); max_wrongClass = Form1->edit_max_wrongClass->Text.ToIntDef(0); epoch = 0; TDateTime t1, t2; AnsiString s; s = Form1->edit_Ntrd->Text; Ntrd = s.ToIntDef(0); if (Ntrd<0) Ntrd=0; t1 = Now(); if (Ntrd==0) {ShowMessage("Ntrd = 0!"); return(0);} if (!InitWeight()) return(0); if (!InitTrainingInputDataSet()) return(0); Form1->Memo5->Clear(); // dE_dw_wlayer1 --> dE/dw utk layer 1, ... dst double * dE_dw_wlayer1 = new double[nwh]; double * dE_dw_blayer1 = new double[nbh]; double * dE_dw_wlayer2 = new double[nwo]; double dE_dw_blayer2; // dE_dw_wlayer1_prev --> previous dE/dw utk layer 1, ... dst double * dE_dw_wlayer1_prev = new double[nwh]; double * dE_dw_blayer1_prev = new double[nbh]; double * dE_dw_wlayer2_prev = new double[nwo]; double dE_dw_blayer2_prev; // dwo, dwh, dbo, dbh --> weight changes // old_dwo, old_dwh, old_dbo, old_dbh --> previous weight changes double dbo, old_dbo; double * dwo = new double[nwo]; double * old_dwo = new double[nwo]; double * dwh = new double[nwh]; double * old_dwh = new double[nwh]; double * dbh = new double[nbh]; double * old_dbh = new double[nbh]; wrt1("=====> Start training (quickprop) ..."); wrt1(AnsiString("# of weights: ") + numofWeights + "; class: " + className); // dump additional information s = Format("Info: Ntrd:%d; MAX_EPOCH:%d; Error goal:%8.2e; VLR:%d; batch_update:%d.", ARRAYOFCONST((Ntrd, nMAX_EPOCH, errorGoal, VLR, batch_update)));
wrt1(s); wrtNNWComments(s); DumpWeight("Before training:"); Form1->PageControl1->ActivePage = Form1->TabSheet1; Screen->Cursor = crHourGlass; blStoppedByUser = false; blPausedByUser = false; wrt1("Epoch/LR/Ep/wrong:"); while (1) { Ep = CalcError(); if ((epoch % SHOW_STEP_EVERY)==0) { Application->ProcessMessages(); // write in log. wrt1(Format(" %5d , %15g, %15g, %6d", ARRAYOFCONST((epoch, mju, Ep, wrongClass)))); } if (epoch==nMAX_EPOCH) { wrt1("Max epoch reached!"); break; } if (Ep < errorGoal) { wrt1("Error goal reached!"); break; } if (wrongClass <= max_wrongClass) { wrt1("Maximum wrong class reached!"); break; } if (blStoppedByUser) { wrt1("Aborted by user!"); break; } if (blPausedByUser) { ShowMessage("Training paused. Press OK to continue."); blPausedByUser = false; } // Reset semua delta Error for (j=0; j
int st = start_16[j]; dE_dw_wlayer1[st] += (del_h*xi[st]); dE_dw_wlayer1[st+1] += (del_h*xi[st+1]); dE_dw_wlayer1[st+2] += (del_h*xi[st+2]); dE_dw_wlayer1[st+3] += (del_h*xi[st+3]); dE_dw_wlayer1[st+4] += (del_h*xi[st+4]); dE_dw_wlayer1[st+20] += (del_h*xi[st+20]); dE_dw_wlayer1[st+21] += (del_h*xi[st+21]); dE_dw_wlayer1[st+22] += (del_h*xi[st+22]); dE_dw_wlayer1[st+23] += (del_h*xi[st+23]); dE_dw_wlayer1[st+24] += (del_h*xi[st+24]); dE_dw_wlayer1[st+40] += (del_h*xi[st+40]); dE_dw_wlayer1[st+41] += (del_h*xi[st+41]); dE_dw_wlayer1[st+42] += (del_h*xi[st+42]); dE_dw_wlayer1[st+43] += (del_h*xi[st+43]); dE_dw_wlayer1[st+44] += (del_h*xi[st+44]); dE_dw_wlayer1[st+60] += (del_h*xi[st+60]); dE_dw_wlayer1[st+61] += (del_h*xi[st+61]); dE_dw_wlayer1[st+62] += (del_h*xi[st+62]); dE_dw_wlayer1[st+63] += (del_h*xi[st+63]); dE_dw_wlayer1[st+64] += (del_h*xi[st+64]); dE_dw_wlayer1[st+80] += (del_h*xi[st+80]); dE_dw_wlayer1[st+81] += (del_h*xi[st+81]); dE_dw_wlayer1[st+82] += (del_h*xi[st+82]); dE_dw_wlayer1[st+83] += (del_h*xi[st+83]); dE_dw_wlayer1[st+84] += (del_h*xi[st+84]); dE_dw_blayer1[j] = dE_dw_blayer1[j] + (del_h);
} // hidden layer 5x5, masing2 menerima 16 input int n; for (j=0; j
} // update bobot & bias if (epoch==0) { // reset nilai old_dwh, old_dbh, old_dwo, old_dbo for (int jj=0; jj
old_dbo = 0.0; // Reset semua delta prev Error zeros1d(dE_dw_wlayer1_prev, nwh); zeros1d(dE_dw_blayer1_prev, nbh); zeros1d(dE_dw_wlayer2_prev, nwo); dE_dw_blayer2_prev = 0;
} // update bobot & bias output layer // mgf --> maximum growth factor (mju in some literature (Fahlman)) // in this program mju is the learning rate. // update bobot output layer for (j=0; j
0) { deltaw = 0; if (dE > 0) { deltaw = mju * dE; } if (dE > (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else if (deltaw_prev < 0) { deltaw = 0; if (dE < 0) { deltaw = mju * dE; } if (dE < (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else { deltaw = mju * dE; } wo[j] = wo[j] + dwo[j]; } // update bias output layer #define dE dE_dw_blayer2 #define dE_prev dE_dw_blayer2_prev #define deltaw dbo #define deltaw_prev old_dbo if (deltaw_prev > 0) { deltaw = 0; if (dE > 0) { deltaw = mju * dE; } if (dE > (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) /
}
(dE_prev - dE));
} else if (deltaw_prev < 0) { deltaw = 0; if (dE < 0) { deltaw = mju * dE; } if (dE < (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else { deltaw = mju * dE; } bo = bo + dbo; // update bobot & bias hidden layer // update bobot hidden layer #define dE dE_dw_wlayer1[k] #define dE_prev dE_dw_wlayer1_prev[k] #define deltaw dwh[k] #define deltaw_prev old_dwh[k] for (k=0; k 0) { deltaw = 0; if (dE > 0) { deltaw = mju * dE; } if (dE > (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else if (deltaw_prev < 0) { deltaw = 0; if (dE < 0) { deltaw = mju * dE; } if (dE < (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else { deltaw = mju * dE; } wh[k] = wh[k] + dwh[k]; } // update bias hidden layer #define dE dE_dw_blayer1[k] #define dE_prev dE_dw_blayer1_prev[k] #define deltaw dbh[k]
#define deltaw_prev old_dbh[k] for (k=0; k 0) { deltaw = 0; if (dE > 0) { deltaw = mju * dE; } if (dE > (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else if (deltaw_prev < 0) { deltaw = 0; if (dE < 0) { deltaw = mju * dE; } if (dE < (mgf/(1+mgf)) * dE_prev ) { deltaw = deltaw + (mgf * deltaw_prev); } else { deltaw = deltaw + ((dE * deltaw_prev) / (dE_prev - dE)); } } else { deltaw = mju * dE; } bh[k] = bh[k] + dbh[k]; } } // if (batch_update==1) // simpan delta bobot terakhir, utk dipakai pada epoch berikutnya for (int j=0; j
/
%g
/
%d",
s = "Finished: " + t2.DateTimeString(); wrt1(s); wrtNNWComments(s); wrt1("============================== Training finished."); DumpWeight("After training:"); // dump final output double y, diff; int nDataFace=0, nDataNonFace=0; wrongClass=0; AnsiString dflag; wrt3("------- Final output using training dataset as input:"); wrt3("(Pattern # starts from 0)"); wrt3("Pattern # Target Output |Target-Output|"); for (int i=0; i=0.9) { dflag = "*****"; wrongClass++; } else dflag = " "; if (Form1->rgDumpOutput->ItemIndex==1) { if (diff>=1) wrt3(Format("%4d %10g %20g %10.4f %s", ARRAYOFCONST((i, aTRD[i].trd_out, y, diff, dflag)))); } if (Form1->rgDumpOutput->ItemIndex==2) { wrt3(Format("%4d %10g %20g %10.4f %s", ARRAYOFCONST((i, aTRD[i].trd_out, y, diff, dflag)))); } // hitung jumlah data training utk face dan non face if (aTRD[i].trd_out > 0) nDataFace++; } nDataNonFace = Ntrd - nDataFace; s = Format("Training data: %6d (face: %6d; non-face:%6d).", ARRAYOFCONST((Ntrd, nDataFace, nDataNonFace))); wrt1(s); wrtNNWComments(s); s = Format("wrongClass: %4d", ARRAYOFCONST((wrongClass))); wrt3(s); wrtNNWComments(s); Screen->Cursor = crDefault; wrt1(""); delete [] dwo; delete [] old_dwo; delete [] dwh; delete [] old_dwh; delete [] dbh; delete [] old_dbh; delete [] aTRD; delete [] dE_dw_wlayer1; delete [] dE_dw_blayer1; delete [] dE_dw_wlayer2; delete [] dE_dw_wlayer1_prev; delete [] dE_dw_blayer1_prev; delete [] dE_dw_wlayer2_prev; return(1); }
