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
iii
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








iv

















vnìvì Iivn vvn ^vviv
,vnv ìc[vn ncnvv]v·iìv ìvn,vì nv[
ìc·]v ìc·v., .cnvnvvì, ìc.vìv·vn, .inìv


v
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.
vi
• 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


vii
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
viii
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
ix
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


x
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


xi
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



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 ( ) y x f , 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 ( ) y x i , dan
( ) y x r , yang digabungkan sebagai perkalian fungsi untuk membentuk fungsi
( ) y x f , . Fungsi ( ) y x f , dapat dituliskan dengan persamaan :
( ) ( ) ( ) y x r y x i y x f , , , ∗ = (2.1)

di mana
( ) ( ) 1 , 0 dan , 0 < < ∞ < < y x r y x i
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 p
r
(r
k
)
adalah probabilitas munculnya level grayscale r
k
di dalam citra.
1 ,..., 1 , 0 1 0 ) ( − = ≤ ≤ = L k dan r
n
n
r p
k
k
k r
(2.2)
di mana L adalah banyaknya level grayscale, n
k
adalah banyaknya pixel dengan
level grayscale r
k
muncul di dalam citra, dan n adalah banyaknya seluruh pixel di
dalam citra.
1 ,..., 1 , 0 1 0 ) (
0 0
− = ≤ ≤ = = =

= =
L k dan r
n
n
n
n
r T s
k
k
j
j
k
j
j
k k
(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 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 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 kulit manusia juga dapat digunakan untuk membantu
memperkirakan area wajah. Namun 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 non-
wajah.
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 s
i
terhadap input eksitasi yang
juga disebut net input net
i
.


− =
) (i pred j
i ij j i
w s net θ (2.4)
dimana pred(i) melambangkan himpunan predesesor dari unit i, w
ij

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 s
i
, dihitung dengan memasukkan net input ke
dalam sebuah fungsi aktivasi non-linear. Biasanya digunakan fungsi logistik
sigmoid:

i
net
i i
e
net f s

+
= =
1
1
) (
log
(2.5)

Salah satu keuntungan dari fungsi ini adalah memiliki derivatif yang mudah
dihitung:
) 1 ( * ) (
log i i i
i
i
s s net f
net
s
− = ′ =


(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]:
1
1
2
) (
log

+
= =

i
net
i i
e
net g s (2.7)

Derivatif dari fungsi tersebut adalah:
) 1 ( * ) 1 (
2
1
) (
log i i i
i
i
s s net g
net
s
− + = ′


(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 x
p
dan vektor target t
p
.
Setelah selesai pelatihan, jika diberikan masukan x
p
seharusnya jaringan
menghasilkan nilai output t
p
. Besarnya perbedaan antara nilai vektor target dengan
output aktual diukur dengan nilai error yang disebut juga dengan cost function:


− =
P p n
p
n
p
n
s t E
2
) (
2
1
(2.9)
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:
ij
i
i ij
w
s
s
E
w
E




=


(2.10)
dan

j i
ij
i
i
i
ij
i
s net f
w
net
net
s
w
s
) (
log
′ =




=


(2.11)
dimana
ij
w adalah bobot penghubung dari neuron j ke neuron i,
i
s adalah output,
dan
i
net adalah jumlah hasilkali pada input dari neuron i.
Untuk menghitung
i
s E ∂ ∂ , yaitu pengaruh output s
i
terhadap error E,
dapat dibedakan menjadi dua kasus berikut:
• jika i adalah unit output, maka:
) (
) (
2
1
2
i i
i
i i
i
s t
s
s t
s
E
− − =

− ∂
=


(2.12)
• jika i bukan unit output, maka perhitungan
i
s E ∂ ∂ menjadi sedikit lebih
kompleks. Di sini digunakan lagi aturan rantai:






=


) (i succ k i
k
k i
s
s
s
E
s
E








=
) (i succ k i
k
k
k
k
s
net
net
s
s
E





=
) (
log
) (
i succ k
ki k
k
w net f
s
E
(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
k
s E ∂ ∂ 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:
) ( ) ( ) 1 ( t w t w t w
ij ij ij
∆ + = + (2.14)
dan
) ( ) ( t
w
E
t w
ij
ij


− = ∆ ε (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
) 1 ( ) ( ) ( − ∆ +


− = ∆ t w t
w
E
t w
ij
ij
ij
µ ε (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 masing-
masing bobot. Perubahan bobot pada algoritma Quickprop dirumuskan sebagai
berikut:
) 1 ( *
) ( ) 1 (
) (
) ( ) ( − ∆


− −




+


− = ∆ t w
t
w
E
t
w
E
t
w
E
t
w
E
t w ε (2.17)
di mana:
19
) (t w ∆ : perubahan bobot
) 1 ( − ∆ t w : perubahan bobot pada epoch sebelumnya
ε : adalah learning rate
) (t
w
E


: derivatif error
) 1 ( −


t
w
E
: derivatif error pada epoch sebelumnya

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.

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.

Gambar 3.2. DFD level 0 Sistem Trainer JST

Hasil
Deteksi
Testing
Data Set
Training
Data Set
Detektor
Wajah
Trainer
JST
Bobot JST
Hasil Training
Citra
Masukan

Sistem
Trainer JST

User
Training Data Set
Tampilan
Proses Training

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.

Gambar 3.3. DFD level 1 Sistem Trainer JST


User
Contoh wajah

User
Citra telah
di-normalisasi
Bobot JST
1.
Histogram
Equalization
Nilai Bobot JST
Tampilan Proses Training
Contoh non-wajah
2.
Masking
3.
Normalisasi
Citra telah
di-masking
Citra telah diproses
hist. equalization
4.
Training
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.


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
Sistem
Detektor
Wajah

User
Lokasi Wajah

User
Citra Masukan
Pilihan Bobot JST
25
saat training. Hasil preprocessing ini dijadikan sebagai input untuk pengklasifikasi
JST. Pengklasifikasi JST ini akan menghasilkan kandidat-kandidat wajah.




















Gambar 3.5. DFD level 1 Sistem Detektor Wajah
Citra Masukan

User
Pilihan
Bobot JST
Bobot JST
Terpilih
Array
Pixel Citra
Lokasi
Wajah
Kandidat
Wajah
Bobot JST
1.
Pilih Bobot
JST

User
Nilai
Bobot JST
3.
Cari
kandidat wajah
4.
Merging
2.
Baca citra
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 multi-
layer 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:
1
1
2
) (
log

+
= =

i
net
i i
e
net g s
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.

Gambar 3.6. Arsitektur Jaringan Syaraf Tiruan

input
20x20
pixel
grid
5x5 pixel
Hidden
Layer
grid
4x4 pixel
Output
Input
Layer
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

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.
Koleksi Contoh
Data Wajah
Data Tambahan
Non-Wajah
Hasil Deteksi
(False Positive)
Koleksi Contoh
Data Non-Wajah
Detektor
Wajah
Trainer
JST
Data Training
Data Awal
Non-Wajah
Pilih
random
Bobot JST
Hasil Training

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

Gambar 3.8. Diagram Alir Bagian Detektor Wajah
Merging Kandidat
Wajah

Simpan
Kandidat
Wajah
Pengklasifikasi
JST
Histogram
Equalization
Perkecil
citra
Geser
window

Window
Terakhir?
Ukuran
citra > 20x20
pixel?
Baca Window
Pertama
Start
Pilih Bobot JST,
Baca Citra
Ya

Ya

Tidak

Tidak

Masking
Normalisasi
Ditemukan
Wajah?
Tidak

Ya

Tampilkan
Lokasi Wajah
End
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 nilai-
nilai 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)y
1
+ t(1 − u)y
2
+ tuy
3
+ (1 − t)uy
4

di mana
y
1
= ya[j][k]
y
2
= ya[j+1][k]
y
3
= ya[j+1][k+1]
y
4
= 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 p
r
(r
k
)
adalah probabilitas munculnya level grayscale r
k
di dalam citra.
1 ,..., 1 , 0 1 0 ) ( − = ≤ ≤ = L k dan r
n
n
r p
k
k
k r

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.
1 ,..., 1 , 0 1 0 ) (
0 0
− = ≤ ≤ = = =

= =
L k dan r
n
n
n
n
r T s
k
k
j
j
k
j
j
k k


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. Lokasi-
lokasi 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 * wh; // bobot pada layer 1 (hidden layer)
double * wo; // bobot pada output layer
double * bh; // bias pada layer 1 (hidden layer)
double 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<nwo1; j++) {
int st = start_16[j];
hsum = (x[st] * wh[st]) + (x[st+1] * wh[st+1]) +
(x[st+2] * wh[st+2]) + (x[st+3] * wh[st+3]) +
(x[st+4] * wh[st+4]) + (x[st+20] * wh[st+20]) +
(x[st+21] * wh[st+21]) + (x[st+22] * wh[st+22]) +
(x[st+23] * wh[st+23]) + (x[st+24] * wh[st+24]) +
(x[st+40] * wh[st+40]) + (x[st+41] * wh[st+41]) +
(x[st+42] * wh[st+42]) + (x[st+43] * wh[st+43]) +
(x[st+44] * wh[st+44]) + (x[st+60] * wh[st+60]) +
(x[st+61] * wh[st+61]) + (x[st+62] * wh[st+62]) +
(x[st+63] * wh[st+63]) + (x[st+64] * wh[st+64]) +
(x[st+80] * wh[st+80]) + (x[st+81] * wh[st+81]) +
(x[st+82] * wh[st+82]) + (x[st+83] * wh[st+83]) +
(x[st+84] * wh[st+84]);
hsum += bh[j];
hout[j] = fa(hsum);
}

// hidden layer 5x5, masing2 menerima 16 input
int n;
for (j=0; j<nwo2; j++) {
hsum = 0.0;
int st = start_25[j];
n = st + 0; hsum += (x[n] * wh[nwh1+n]);
n = st + 1; hsum += (x[n] * wh[nwh1+n]);
n = st + 2; hsum += (x[n] * wh[nwh1+n]);
n = st + 3; hsum += (x[n] * wh[nwh1+n]);
n = st + 20; hsum += (x[n] * wh[nwh1+n]);
n = st + 21; hsum += (x[n] * wh[nwh1+n]);
n = st + 22; hsum += (x[n] * wh[nwh1+n]);
n = st + 23; hsum += (x[n] * wh[nwh1+n]);
n = st + 40; hsum += (x[n] * wh[nwh1+n]);
n = st + 41; hsum += (x[n] * wh[nwh1+n]);
38
n = st + 42; hsum += (x[n] * wh[nwh1+n]);
n = st + 43; hsum += (x[n] * wh[nwh1+n]);
n = st + 60; hsum += (x[n] * wh[nwh1+n]);
n = st + 61; hsum += (x[n] * wh[nwh1+n]);
n = st + 62; hsum += (x[n] * wh[nwh1+n]);
n = st + 63; hsum += (x[n] * wh[nwh1+n]);
hsum += bh[nwo1+j];
hout[nwo1+j] = fa(hsum);
}

// hitung hasil node pada output layer
osum = 0.0;
for (j=0; j<nwo; j++) {
osum = osum + (hout[j] * wo[j]);
}
osum = osum + bo;
y = fa(osum);
return y;
}


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<Ntrd; i++) {
y = yout(aTRD[i].trd_in);
t = aTRD[i].trd_out;
Ep = Ep + pow((t-y),2);
}
Ep = Ep/Ntrd;
return Ep;
}


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<img1height; iy++) {
for (int ix=0; ix<img1width; ix++) {
img1temp[ix][iy] = img1[ix][iy];
// copy image to temporary storage
}
}
// previous image size
w1 = img1width;
h1 = img1height;
// new image size
w2 = new_width;
h2 = new_height;
41
for (y=0; y<h2; y++) {
yy1 = ((double)y/(h2-1))*(h1-1);
k = floor(yy1);
u = yy1-k;
for (x=0; x<w2; x++) {
xx1 = ((double)x/(w2-1))*(w1-1);
j = floor(xx1);
t = xx1-j;
nn1 = img1temp[j][k];
nn2 = img1temp[j+1][k];
nn3 = img1temp[j+1][k+1];
nn4 = img1temp[j][k+1];
g = ((1-t)*(1-u)*nn1) + (t*(1-u)*nn2) +
(t*u*nn3) + ((1-t)*u*nn4);
img1[x][y] = (char)g;
}
}
img1width = w2;
img1height = h2;
}


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<DX; ix++) {
for (iy=0; iy<DY; iy++) {
g = img_in[ix][iy];
nr[g]++;
}
}
for (k=0; k<256; k++) {
s = 0;
for (j=0; j<=k; j++)
s += ((double)nr[j]) / ((double)n_total_pixel);
ns[k] = s * 255;
}
42
for (ix=0; ix<DX; ix++) {
for (iy=0; iy<DY; iy++) {
g = img_in[ix][iy];
img_out[ix][iy] = (unsigned char)ns[g];
}
}
}


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 kandidat-
kandidat wajah. Penggabungan (merging) dilakukan untuk menyatukan kandidat-
kandidat 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
Detection
Rate
False
Positif
Support vector machines (SVM) [Osuna, 1997] 74,2% 20
Distribution-based dan clustering [Sung, Poggio, 1994] 79,9% 5
Neural Networks [Rowley, 1998] 84,5% 8
Kullback relative information [Lew, Huijsmans, 1996] 94,1% 64

Tabel 4.1 Beberapa hasil deteksi pada data uji MIT-23


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
wajah
non-
wajah
total
Detection
Rate
False Positif
1000 400 1400 9/15 64
1000 600 1600 12/15 51
1000 800 1800 14/15 44
1000 1000 2000 15/15 42
1000 1200 2200 15/15 32
1000 1400 2400 15/15 31
1000 1600 2600 15/15 24
1000 1800 2800 15/15 23
1000 2000 3000 15/15 19
1000 2200 3200 15/15 10
1000 2400 3400 15/15 5
1000
2600 3600 15/15 4
1000
2800 3800 15/15 2
1000
3000 4000 15/15 2
1000
3200 4200 15/15 2
1000
3400 4400 15/15 2
1000
3600 4600 15/15 1
1000
3800 4800 15/15 1
1000
4000 5000 15/15 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.

Waktu training (detik)
Jumlah
Data training
MSE
Error Backprop
standar
Quickprop
2000 0.05 49 12
3000 0.05 649 96
4000 0.05 4664 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 Random Data Active Learning
wajah
non-
wajah
total
Detection
Rate
False
Positive
Detection
Rate
False
Positive
3000 5200 8200 63,76% 732 71,14% 62
3000 3000 6000 62,42% 1160 71,14% 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 Back-
Propagation 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. Fogelman-
Soulie 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<nwh; j++) {
dE_dw_wlayer1[j] = 0;
}
zeros1d(dE_dw_blayer1, nwo);
zeros1d(dE_dw_wlayer2, nwo);
dE_dw_blayer2 = 0;
// batch update method
if (batch_update==1) {
// hitung update bobot
for (i=0; i<Ntrd; i++) {
xi = aTRD[i].trd_in;
t = aTRD[i].trd_out;
ynet = yout(xi);
// hitung update bobot utk output layer
dfa_y = dfa(ynet);
del_o = dfa_y*(t-ynet);
for (j=0; j<nwo; j++) {
dE_dw_wlayer2[j] += (del_o * hout[j]);
}
dE_dw_blayer2 = dE_dw_blayer2 + (del_o);
// hitung delta Error utk update bobot utk hidden layer
// hidden layer 4x4, masing2 menerima 25 input
for (j=0; j<nwo1; j++) {
dfa_h = dfa(hout[j]); //% derivative of sigmoid function
// hanya ada 1 output
sigma_x = (del_o * wo[j]);
del_h = dfa_h*sigma_x;
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<nwo2; j++) {
dfa_h = dfa(hout[nwo1+j]); //% derivative of sigmoid function
// hanya ada 1 output
sigma_x = (del_o * wo[nwo1+j]);
del_h = dfa_h*sigma_x;
int st = start_25[j];
n = st + 0; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 1; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 2; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 3; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 20; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 21; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 22; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 23; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 40; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 41; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 42; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 43; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 60; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 61; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 62; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
n = st + 63; dE_dw_wlayer1[nwh1+n] += (del_h*xi[n]);
dE_dw_blayer1[nwo1+j] += (del_h);
}
}
// update bobot & bias
if (epoch==0) {
// reset nilai old_dwh, old_dbh, old_dwo, old_dbo
for (int jj=0; jj<nwh; jj++)
old_dwh[jj] = 0.0;
zeros1d(old_dbh, nwo);
zeros1d(old_dwo, nwo);
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<nwo; j++) {
#define dE dE_dw_wlayer2[j]
#define dE_prev dE_dw_wlayer2_prev[j]
#define deltaw dwo[j]
#define deltaw_prev old_dwo[j]
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;
}
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<nwh; k++) {
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;
}
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<nwo; k++) {
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;
}
bh[k] = bh[k] + dbh[k];
}
} // if (batch_update==1)
// simpan delta bobot terakhir, utk dipakai pada epoch berikutnya
for (int j=0; j<nwh; j++) {
old_dwh[j] = dwh[j];
}
for (int k=0; k<nwo; k++) {
old_dwo[k] = dwo[k];
old_dbh[k] = dbh[k];
}
old_dbo = dbo;
// simpan semua delta Error terakhir, utk dipakai pada epoch berikutnya
for (int j=0; j<nwh; j++) {
dE_dw_wlayer1_prev[j] = dE_dw_wlayer1[j];
}
for (int i=0; i<nwo; i++) {
dE_dw_blayer1_prev[i] = dE_dw_blayer1[i];
dE_dw_wlayer2_prev[i] = dE_dw_wlayer2[i];
}
dE_dw_blayer2_prev = dE_dw_blayer2;
epoch = epoch+1; // go to next epoch...
}
// iterasi training selesai
wrt1("Finished.");
s = Format("Final state: Epoch/LR/Ep/wrongClass = %d / %g / %g / %d",
ARRAYOFCONST((epoch, mju, Ep,wrongClass)));
wrt1(s); wrtNNWComments(s);
t2 = Now();
s = "Started: " + t1.DateTimeString();
wrt1(s); wrtNNWComments(s);
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<Ntrd; i++) {
y = yout(aTRD[i].trd_in);
diff = fabs(aTRD[i].trd_out-y); // selisih target dg actual output
if (diff>=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);
}

Sign up to vote on this title
UsefulNot useful