Anda di halaman 1dari 78

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.

nk
p r (rk ) = 0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1 (2.2)
n

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.

k nj k nj
s k = T (rk ) = = 0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1 (2.3)
j =0 n j =0 n

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 si terhadap input eksitasi yang

juga disebut net input neti.

net i = s wij − θ i
j (2.4)
j∈ pred (i )

dimana 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:

1
si = f log (net i ) = (2.5)
1 + e − neti

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

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]:

2
si = g log (net i ) = −1 (2.7)
1 + e − neti

Derivatif dari fungsi tersebut adalah:


∂si 1
′ (net i ) = (1 + si ) * (1 − si )
g log (2.8)
∂net i 2

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:

1
E= (t np − s np ) 2 (2.9)
2 p∈P 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
= (2.10)
∂wij ∂s i ∂wij

dan

∂s i ∂s i ∂net i
= ′ (net i ) s j
= f log (2.11)
∂wij ∂net i ∂wij

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 ) (2.12)
∂s i 2 ∂s i

• jika i bukan unit output, maka perhitungan ∂E ∂s i menjadi sedikit lebih

kompleks. Di sini digunakan lagi aturan rantai:

∂E ∂E ∂s k
=
∂s i k∈succ ( i ) ∂s k ∂s i

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

∂E
= ′ (net k ) wki
f log (2.13)
k∈succ ( i ) ∂s k
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

∂E
∆wij (t ) = −ε (t ) (2.15)
∂wij

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

∂E
∆wij (t ) = −ε (t ) + µ∆wij (t − 1) (2.16)
∂wij

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:

∂E
(t )
∂E ∂w
∆w(t ) = −ε (t ) + * ∆w(t − 1) (2.17)
∂w ∂E ∂E
(t − 1) − (t )
∂w ∂w

di mana:
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 Trainer
Data Set JST

Testing Bobot JST


Data Set Hasil Training

Citra Detektor Hasil


Masukan Wajah 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.

Tampilan
Training Data Set Proses Training
User Sistem User
Trainer JST

Gambar 3.2. DFD level 0 Sistem Trainer JST


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
1.
User Histogram
Equalization
Contoh non-wajah
User
Citra telah diproses
Citra telah hist. equalization
di-masking
3. 2.
Normalisasi Masking

Citra telah
di-normalisasi

4. Tampilan Proses Training


Training

Nilai Bobot JST


Bobot JST

Gambar 3.3. DFD level 1 Sistem Trainer JST


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
Sistem Lokasi Wajah
User Detektor
Pilihan Bobot JST User
Wajah

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.

Citra Masukan 2.
User Baca citra

Pilihan
Bobot JST

Array
Pixel Citra
Bobot JST

Nilai
Bobot JST

1. User
Pilih Bobot
JST

Lokasi
Wajah

Bobot JST
Terpilih
4.
Merging

Kandidat
3. Wajah
Cari
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 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:

2
si = g log (net i ) = −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 Hidden
Layer 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 Trainer Data Tambahan
JST Non-Wajah

Pilih
random Bobot JST
Hasil Training

Koleksi Contoh Detektor


Data Non-Wajah 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,


Start
Baca Citra

Baca Window
Pertama

Perkecil
citra
Histogram
Equalization

Masking

Geser
Normalisasi window

Pengklasifikasi
JST

Simpan
Ya Ditemukan
Kandidat
Wajah?
Wajah

Tidak

Tidak
Window
Terakhir?

Ya

Ukuran Ya
citra > 20x20
pixel?

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 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)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.

nk
p r (rk ) = 0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1
n

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.

k nj k nj
sk = T (rk ) = = 0 ≤ rk ≤ 1 dan k = 0,1,..., L − 1
j =0 n j =0 n

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.

Detection False
Metode
Rate 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


Detection
non- False Positif
wajah total Rate
wajah
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 MSE
Data training Error Backprop
Quickprop
standar
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


non- Detection False Detection False
wajah total
wajah Rate Positive Rate 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);
}