master thesis -...
TRANSCRIPT
Master Thesis
Face characterisation based on Gabor filters,
Bayes Rule and AdaBoost
UNIVERSITAT ROVIRA I VIRGILI
ESCOLA TECNICA SUPERIOR D’ENGINYERIA (ETSE)
Master’s thesis in Computer Security and Intelligent System
Face characterisation based on Gabor filters, Bayes Rule
and AdaBoost
Tarragona, 2011
A.B.M. NURUL AFSER TALUKDER
Supervisor: Dr. Francesc Serratosa
Research team: SSAI – Sensorial Systems Applied to the Industry
Abstract
In the last two decades, a lot of research has been carried out related to face
identification and localisation. This research has produced a huge amount of papers
and several interesting methods. At the end, this effort has arrived to the society
through very different fields, such as, face localisation in low-cost cameras, security
systems, medical diagnosis, and so on.
The aim of this master thesis is to compare the most common methods used and find
some similarities in their performance. The methods studied in depth are the Bayes
Classifier and AdaBoost. We want to analyse in dept the behaviour of each method and
compare in which cases one of them outperforms the other one.
In general, AdaBoost has to outperform the Bayes Classifier since it has the capacity to
iterative weight the goodness of the samples. Nevertheless, it can fall to minimum
locals that depend on the features of the algorithm instead of the features of the data.
Several methods have been used to extract the features of faces given images. The most
common are Haar Filters and Gabor filters. In this master thesis, we aim to use Gabor
filters since they have a most solid mathematical basis.
Acknowledgement
First of All I thank to the Greatest Almighty for making me able to complete my
master’s course and, as well as, this thesis work successfully.
I would like to express my appreciation to my advisor Prof. Dr. Francesc Serratosa
whose encouragement, supervision and support from the preliminary to the
concluding level enabled me to develop and understanding of the subject. Thanks
for giving me the opportunity to be a part of the SSAI.
I am indebted to the URV for the scholarship I obtained for the educational journey
to this University.
I dedicate this thesis to my parents who unremittingly supported me during my
years of study and for their love through all this long process. They made this work
possible.
Table of Contents
List of Figures: .............................................................................................................................................. 7
Chapter 1: Introduction ............................................................................................................................ 9
Background ................................................................................................................................................ 9
Problem Description........................................................................................................................... 10
Chapter 2: Literature Review ............................................................................................................. 13
Gabor Filter ............................................................................................................................................. 13
Definition ............................................................................................................................................. 13
Elliptical Gabor Filter: .................................................................................................................... 14
Selection of filter parameters:.................................................................................................... 15
Learning Algorithm ............................................................................................................................. 16
Naive Bayes Classifier: ................................................................................................................... 17
AdaBoost .............................................................................................................................................. 19
Chapter 3: Methodology ........................................................................................................................ 23
Selection of filter parameters: ........................................................................................................ 23
The implementation of the Naïve Bayes Classifier: .............................................................. 24
Learning the most discriminant Gabor features by AdaBoost ........................................ 26
Chapter 4: Experimental Results ...................................................................................................... 29
Chapter 5: Conclusion ............................................................................................................................ 37
Appendix A: Terminology .................................................................................................................... 39
Appendix B: Sample codes ................................................................................................................... 41
Bibliography ............................................................................................................................................... 48
7 | P a g e
List of Figures:
Figure 1: Process flow of the proposed work
Figure 2: Four types of rectangular Haar wavelet-like features. A feature is a scalar
calculated by summing up the pixels in the white region and subtracting those in the
dark region
Figure 3: Gabor filter composition for signal (a) sinusoid, (b) a Gaussian kernel, (c)
the corresponding Gabor filter
Figure 4: Implementation steps of Naïve Bayes Classifier
Figure 5: Implementation steps of AdaBoost algorithm
Figure 6: the AdaBoost algorithm
Figure 7: shows the process flow of the Naïve Bayes classifier
Figure 8: shows the probability calculation for construction weak learners
Figure 9: shows the 30 eye image dataset.
Figure 10: shows the 30 non eye image dataset.
Figure 11: shows sample test images set Figure 12: the first row shows the 2D outputs and the second row shows the surface plot of the EGF filter Figure 13: sample plot for probability of being eye (blue) and non-eye (red) for a filter Figure 14: shows the process and the classified output result of Naïve Bayes
Figure 15: the results of classifying the eyes in our face dataset using Naïve Bayes (a-
g) and AdaBoost classifier (h-n)
Figure 16: shows the final eye detection results of the face dataset
8 | P a g e
9 | P a g e
Chapter 1: Introduction
Image processing and computer vision are among the most heavily-researched fields in
computer science, and facial detection and recognition have each been extensively
explored. A wide variety of approaches drawing on many computer science and electrical
engineering disciplines have been applied to these two problems with varying success. In
the recent years, the advancement in the computer technology has put more emphasize on
this research field and the development of different face recognition and characterization
techniques both in 2D and 3D images. The need for this kind of technology in several
different areas keeps pushing the research forward every year. Most commonly used in
practice by law enforcement for human identification purposes, face recognition systems
can also be used in other different significant areas for controlling processes (e.g. an
industrial robot or an autonomous vehicle), detecting events (e.g. for visual surveillance),
organizing information (e.g. for indexing databases of images and image sequences),
modeling objects or environments (e.g. medical image analysis or topographical modeling),
interaction (e.g. as the input to a device for computer-human interaction).
Humans seem to recognize faces in cluttered scenes with relative ease, having the
ability to identify distorted images, coarsely quantized images, and faces with
occluded details. Machine recognition is much more daunting task. Face recognition is a
task so common to humans, that the individual does not even notice the extensive number
of times it is performed every day. Understanding the human mechanisms employed to
recognize faces constitute a challenge for psychologists and neural scientists. Although
research in automated face recognition has been conducted since the 1960’s, it has only
recently caught the attention of the scientific community. Many face analysis and face
modeling techniques have progressed significantly in the last decade [18]. However, the
reliability of face recognition schemes still poses a great challenge to the scientific
community.
Background In the last two decades, a lot of research has been carried out related to face identification
and localization. This research has produced a huge amount of papers and several
interesting methods. The first methods were based on the 2D static and dynamic images.
Nevertheless, at the beginning of the current century, the third dimension contributes to
characterize faces in a better way and so, to increase the quality of the systems. Research
10 | P a g e
activities in the face recognition domain have escalated due to its promising applications,
such as in building/store access control, suspect identification and surveillance. However, a
few can achieve a completely reliable performance due to the wide variations in the
appearance of a particular face with changes in pose, illumination, facial markup and facial
expression, especially when only one prototype face per person is stored.
Problem Description Face detection can be regarded as a more general case of facial feature localization. In facial
feature localization, the task is to find the locations of different facial feature i.e. eyes, nose,
mouth etc and extract the features form a set of images. The main target of this work is to
extract faces from the 2D images using Gabor Filter and for the initial part we considered to
extract eyes from a face. For accomplishing the initial target we have worked with our eye
database extracted from different images from a face database. In order to improve the
real-time and veracity performance of the eye location method, we have chosen the
Elliptical Gabor filter to convolute with the face image to highlight the eye region, which
can be exploited to segment the two pupil regions efficiently [1]. Comparing with other
algorithms, we have chosen this algorithm as it takes less input parameters and faster in
performance. Then we have implemented the Naïve Bayes Classifier and AdaBoost
classifier to classify the eyes from the non-eyes by these two classification methods from
the training set of eye and non-eye images and finally we tried to compare the results to
find out which classification method outperforms.
Figure 1: Process flow of the proposed work
Eye location plays an important role in the image normalization because eyes are the most
salient facial features, holding a comparatively fixed position on the face. The distance
between eyes is not easily influenced by the change of the face pose and expression. Also
the line of eye centre doesn’t bend when the face deflects. So normalizing the feature based
on eyes, the feature will have inflexibility to translation, rotation and scale [2]. As a result,
eye location usually is the first step in the face recognition system.
Eye and Non Eye
Dataset
Gabor Filter
Outputs
Naïve Bayes
Classifier
AdaBoost
Classifier
Compare the
classification
results
11 | P a g e
There are different methods applied in the face detection techniques to extract the facial
features. Although many different algorithms exist to perform face detection, each has its
own weakness and strength. Some use flash tones, some use contours, and other are even
Figure 2: Four types of rectangular Haar wavelet-like features. A feature is a scalar calculated by
summing up the pixels in the white region and subtracting those in the dark region
more complex involving templates, neural networks, or filters. Among these techniques, we
have considered two of them and analyzed their features. One is the Haar classifiers,
devised by Viola and Jones [19], and the other is the Gabor filter.
The core basis for Haar classifier object detection is the Haar-like features. These features,
rather than using the intensity values of a pixel, use the change in contrast values between
adjacent rectangular groups of pixels. The contrast variances between the pixel groups are
used to determine relative light and dark areas. Two or three adjacent groups with a
relative contrast variance form a Haar-like feature. Haar like features, as shown in figure[2]
are used to detect image [20]. Haar features can easily be scaled by increasing or
decreasing the size of the pixel group being examined. This allows features to be used to
detect objects of various sizes.
Gabor Filter, named after Dennis Gabor, is a linear filter used in face detection. Frequency
and orientation representation of Gabor filters are similar to those of the human visual
system, and they have been found to be particularly appropriate for texture representation
and discrimination.
In our work, we have considered the Gabor filter to extract the eyes from the images as the
responses of this filter is much more efficient than the Haar like features to extract the eye
regions from the face. Another reason for choosing the Gabor filter is that there are a lot of
work done with the Haar like features and the AdaBoost classifier, but we would like to
implement the Gabor filter with the AdaBoost classifier and Naïve Bayes classifier.
In the chapter 2, we summarized the literature on Gabor filter, Naïve Bayes Classifier and
AdaBoost classification. In chapter 3, we defined the details methodology applied in our
work to implement the proposed algorithms. In chapter 4, we showed the experimental
results of our work and the comparison of the results of two classification algorithm.
12 | P a g e
Finally, in chapter 5 concluding remarks are stated. Future works, which may follow this
study, are also presented.
13 | P a g e
Chapter 2: Literature Review
This chapter deals with the basic concepts of different methodologies that are implemented
in this thesis work. After reading this chapter you can get the basic ideas of the Gabor filter
which is mostly used in face recognition process, and two different classification methods:
Naïve Bayes classification method and AdaBoost classification method. The face
recognition task is primarily a complex task to be achieved. This process that we have
followed to achieve this task are:
Extract the important features (i.e. eyes in our case) from the image using the Gabor
filtering technique.
Classify the images using the learning technique using the eye and non eye images
with Naïve Bayes Classification technique.
Then classify the images with another learning technique AdaBoost with the same
eye and non eye images.
Finally, compare the results of the two classification method and analyze the results
found in this two classification method.
Gabor Filter
Definition The Gabor filters started gaining popularity in the field of image processing in 1980 when
Gabor [14] first defined, and later extended to two dimensions by Daugman [15] showed
that the kernels exhibit many properties common to mammalian cortical simple cells.
Certain specific bands of frequency components can be extracted by adjusting the
orientation and center frequencies of the Gabor filter. They have enjoyed much attention in
the field of 2D face recognition and associated fields [16, 17] as researchers attempt to
14 | P a g e
emulate and surpass the face recognition capabilities of human being. A Gabor filter is a
complex sinusoid modulated by a Gaussian function. This filter will therefore respond to
some frequency, but only in a localized part of the signal. This is illustrated in figure[3].
(a) (b) (c)
Figure 3: Gabor filter composition for signal (a) sinusoid, (b) a Gaussian kernel, (c) the
corresponding Gabor filter
There are some existing algorithms to locate eyes [2] [3-6]. Gabor filter has also been used
to this realm [7] locates eyes based on the GaborEye model and radial symmetry operator.
The work [8] uses Gabor and a genetic search algorithm to find eyes. Gabor filter and gray
projection are combined to locate eye in [9]. Although all these methods can locate eyes,
but they are not robust enough to illumination odds, face rotation, expression variation and
other problems. The shape of the eye contour is elliptical, so the elliptical filter is devised in
our work.
Elliptical Gabor Filter: The shape of Elliptical Gabor Filter likes an ellipse. Its form is similar to the Traditional
Gabor Filter (TGF), both of which are Gaussian functions modulated by the sine function.
The difference between them is the shape of the sine function. The elliptical Gabor Filter is
defined as follows:
15 | P a g e
where (x’ , y’ ) = (x cos + y sin ,-x sin + y cos) and F is the spatial central frequency of
the filter in the frequency domain, g(x, y) is 2-D Gaussian envelope as follows:
where x and y are variances (scale factors) along x and y axes respectively. (x, y) is the
center of the receptive field in the spatial domain, θ is the rotation angle of the filter.
On the one hand the EGF embodies the orientation selectivity of the TGF; on the other hand
it matches the eye in shape. So the EGF can easily highlight the edge of eyelids.
When the frequency is appropriate, the horizontal EGF can stand out the eye region
efficiently wherever the image is frontal or rotating. So when designing the EGF, only three
parameters of x, y and F are took into account in this paper, which simplifies the filter to
some degree.
Selection of filter parameters:
Similar to Traditional Gabor Filter (TGF), this Elliptical Gabor filter can be configured to
have various shapes, bandwidths, center frequencies and orientations by adjusting certain
parameters. On the one hand the EGF embodies the orientation selectivity of the TGF; on
the other hand it matches the eye in shape. So the EGF can easily highlight the edge of
eyelids.
When the frequency is appropriate, the horizontal EGF can stand out the eye region
efficiently wherever the image is frontal or rotating. So when designing the EGF, only three
parameters of σx , σy and F are took into account in this paper, which simplifies the filter to
some degree.
The Gabor filter design is to choose a group of optimum parameters so as to enhance the
eye region. In general, the frequencies of the useful part in the signal to be processed are
not only. If using one frequency, the result will not be perfect. So a bank of filter with multi-
16 | P a g e
frequency is adopted usually. When the basic frequency of signal is single and stable, a set
of optimal parameter (σx ,σy , F) can be determined to locate eyes.
The gray value of eyes changes more violently in the horizontal direction, including more
edge information. So the width of eyes is used as reference when designing the scale factor
of filter. In our work, in the training process we used eye images of 25x39 pixels. The width
of the eye portion W is about 28-33 pixels. In the scope of [-3σy, 3σy] , The energy that the
Gaussians possess is nearly to 99.7% [11]. In order to ensure that the band of Gabor filter
cover the whole eye width in horizontal direction, σy and W must satisfy the relation: σy / 6
= W . The ratio of the eye width W and eye height H is about 2.2:1, so it is 5σx /66 = W . Thus
the scale of the EGF is determined.
The research on the visual cells of the mammal shows that the spatial frequency bandwidth
in the receptive hold drops into 0.5-2.5 octave, no matter that the cell is simple or
complicate. According to the constraint condition:
Where is frequency bandwidth and {0.5, 2.5}. So the central frequency F [1/12σx ,
5/12σx].
Learning Algorithm
Face recognition is a multi-class problem; therefore we need to classify the images that are
most relevant to the successful recognition process. For this reason we have researched
different classification algorithm which better suffices our problem area. We have selected
two different types of classification algorithm; Naïve Bayes Classifier and the renowned
boosting algorithm AdaBoost. A face recognition system comprises two stages: training and
testing. In practical applications, the small number of available training face images and
complicated facial variations during the testing stage are the most difficult problems for
current face recognition systems.
17 | P a g e
In our work, we have worked with two different types of learning algorithm to get the
classified output extracted from the Gabor filters. In the first approach, we have applied the
Naïve Bayes classifier algorithm and in the next approach, we have implemented the
AdaBoost.
Naive Bayes Classifier: A Bayes classifier is a simple probabilistic classifier based on applying Bayes' theorem
(from Bayesian statistics) with strong (naive) independence assumptions. A more
descriptive term for the underlying probability model would be "independent feature
model".
In simple terms, a naive Bayes classifier assumes that the presence (or absence) of a
particular feature of a class is unrelated to the presence (or absence) of any other feature.
For example, a fruit may be considered to be an apple if it is red, round, and about 4" in
diameter. Even if these features depend on each other or upon the existence of the other
features, a naive Bayes classifier considers all of these properties to independently
contribute to the probability that this fruit is an apple.
Depending on the precise nature of the probability model, naive Bayes classifiers can be
trained very efficiently in a supervised learning setting. In many practical applications,
parameter estimation for naive Bayes models uses the method of maximum likelihood; in
other words, one can work with the naive Bayes model without believing in Bayesian
probability or using any Bayesian methods. For more information a wiki definition of this
classifier can be referred [10].
An advantage of the naive Bayes classifier is that it requires a small amount of training data
to estimate the parameters (means and variances of the variables) necessary for
classification. Because independent variables are assumed, only the variances of the
variables for each class need to be determined and not the entire covariance matrix.
18 | P a g e
The naive Bayes classifier combines this model with a decision rule. One common rule is to
pick the hypothesis that is most probable; this is known as the maximum a posteriori or
MAP decision rule. The corresponding classifier is the function classify defined as follows
(from Wikipedia):
Now this means, that for each possible class label, multiply together the conditional
probability of each feature, given the class label. This means, for us to implement the
classifier, all we need to do, is compute these individual conditional probabilities for each
label, for each feature, p(Fi | Cj), and multiply them together with the prior probability for
that label p(Cj). The label for which we get the largest product, is the label returned by the
classifier.
Figure 4: Implementation steps of Naïve Bayes Classifier
For the parameter estimation, our training data contains a continuous attribute that is the
output for different filters. We first segment the data in two classes; one class represents
the filter outputs given that they contains eyes and other class represents the filter outputs
for non-eye. And then compute the mean and variance of outputs of each class. Let μc be the
mean of the values in x associated with class c, and let be the variance of the values in x
associated with class c. Then, the probability of some value given a class, P(x = v | c), can be
computed by plugging v into the equation for a Normal distribution parameterized by μc
and . That is,
Face Database of
eye and non eye
images
EGF Filter
Naïve Bayes Classifier
Classified Output
19 | P a g e
We have to calculate the probability for each of the class and then we have to compare the
product probability of each class whether the probability of eye or non-eye is greater or
not. If greater then we can classify as an eye and if not then it is a non-eye.
AdaBoost
A large number of experimental studies have shown that classifier combination can exploit
the discriminating power of individual feature sets and classifiers. With the success of
boosting in the application of face detection, boosting, as one of the most commonly used
methods of combining classifiers based on statistical resampling techniques, has shown
strong ability to resolve the two-class problem. In our work, classifying between eye and
non eye terms are used to describe whether two different images are from the same
subject, naturally, AdaBoost, a version of the boosting algorithm, is taken to solve this two-
class problem. Therefore we used AdaBoost for training the weak classifiers to build a
strong classifier.
AdaBoost, short for Adaptive Boosting, is a machine learning algorithm, formulated by Yoav
Freund and Robert Schapire [12]. AdaBoost is adaptive in the sense that subsequent
classifiers built are tweaked in favor of those instances misclassified by previous classifiers.
AdaBoost takes as input a training set S = (x1, y1),…..,(xm, ym) where each instance, xi, belongs
to a domain or instance space X, and each label yi belongs to a finite label space Y. Here we
will only focus on the binary case when Y = {-1, +1}.
Each round, m = 1,…,M, AdaBoost calls a given weak or base learning algorithm which
accepts as an input a sequence of training examples S along with a distribution or set of
weights over the training example, Wt(i). Given such an input the weak learner computes a
weak classifier, ht {-1, +1}. In general, ht has the form ht : X R. We interpret the sign of
ht(x) as the predicted label to be assigned to instance x. Once the weak classifier has been
20 | P a g e
received, AdaBoost chooses a parameter t R that intuitively measures the importance
that it assigns to ht.
Figure 5: Implementation steps of AdaBoost algorithm
The idea of boosting is to use the weak learner to form a highly accurate prediction rule by
calling the weak learner repeatedly on different distributions over the training examples.
Initially, all weights are set equally, but each round the weights of incorrectly classified
examples are increased so that those observations that the previously classifier poorly
predicts receive greater weight on the next iteration. A generalized version of Freund and
Schapire’s AdaBoost algorithm [12] is shown in the figure[6].
Extracting
Gabor feature of
eye images
Extracting
Gabor feature of
non eye images
x = y
x != y
Positive sample
set. All samples
are +1.
Negative sample
set. All samples
are -1.
Ad
aBoost
A strong
classifier
21 | P a g e
Figure 6: the AdaBoost algorithm
22 | P a g e
23 | P a g e
Chapter 3: Methodology
In this part of the paper, we will describe the process of implementing the aforementioned
basics for detecting the eyes from a face image. First we will define the selection procedure
of the parameters of the Gabor filter for getting the desired frequency to extract the eye in
the image. Then we will describe the process to implement the learning algorithms to
classify the eyes from the non eyes. We have used the Naïve Bayes classifier first then the
AdaBoost algorithm. In the following section, we will explain the detailed process for each
of the steps.
Selection of filter parameters: According to the defined selection procedure in chapter 2, we have selected our
parameters and a bank of frequencies for getting better outputs of the Gabor filter. Here in
our work we have selected 15 different frequencies to enhance the eye region. In general,
the frequencies of the useful part in the signal to be processed are not only. If using one
frequency, the result will not be perfect. So a bank of filter with multi-frequency is adopted
usually to get a better solution to get the eye regions separated from other images. The
bank of filter with 15 frequencies that we have chosen for our research work is:
[.145, .152, .155, .1583, .16, .164, .1681, .171, .1732, .175, .178, .1811, .183, .185, .187]
As we have mentioned earlier that we will use only three parameters for simplifying the
filtering process to some degree, we kept the other two parameters fixed and just changing
the frequencies. The value we have chosen for σx , σy are 2.3 and 5.0 respectively according
to the measurement that we have described. And we have considered the other parameter
theta = 0 that means that we are not considering the orientation to keep the work simple.
In figure 1, we can see the filter outputs in 2D and 3D views.
24 | P a g e
After applying the EGF in the input images we tried to train our system with an eye
database and a non-eye database which we have further used to implement the Naïve
Bayes Classifier to classify an image containing a eye and non-eye. In the next section we
will first describe about the classifier and then give the details implementation of our
system.
The implementation of the Naïve Bayes Classifier:
In our work, we have a set of Gabor filter bank result for a set of training images. Now we
will try to classify a new input image using the Naïve classifier to identify the eye regions
using the supervised learning. For this, we have calculated the mean and standard
deviation for each of the Gabor filter outputs for both the eye and the non-eye training
sets. Now take a new image that we want to classify using the Naïve classifier. Calculate the
filter output of this image for each of the Gabor filters and then convolute the image with
the filter output. We have to calculate the probability for each of the outputs of the
convolution given eye and non-eye using the probability distribution function shown in the
naïve classifier definition. When we have got the probabilities for each of the class, we have
to calculate the probability product for the eye and for the non-eye. Now we want to
classify the eye and non-eye regions of the input image that we want to classify. For doing
this, we will compare the production result pixel by pixel and if the probability for a pixel
given eye is greater than or equal to the probability for the same pixel given non-eye, we
will change the value to 255 otherwise changes the value to 0. So the output of the
comparison will give us a binary image containing the values 0 or 255. It means that the
resulting image will be white in portions where the probability of being an eye is grater and
rest of the potions will be black. Form this resulting image we can easily classify the eye
regions of the input image based on the training set.
The process flow for the implementation of Naïve Bayes classifier using the Gabor filter
outputs for the eye and non eye images are shown in the figure. Here we have shown
graphically each phase of the process with the rectangular box and the flow.
25 | P a g e
Figure 7: shows the process flow of the Naïve Bayes classifier
Extract Gabor filters
output G1-G15
Extract Gabor
filters output G1-G15
Resulting matrix of Convolution of each image with the filter output,
a 30x15 matrix.
Compute mean and
standard deviation for
each Gabor filter (,) for
eye images.
Compute mean and
standard deviation for
each Gabor filter (,) for
non eye images.
Resulting matrix of Convolution of each image with the filter output,
a 30x15 matrix.
a vector for mean
a vector for standard
deviation
a vector for mean
a vector for standard
deviation
Calculate the
Probability of eye Calculate the
Probability of non eye
Classified
Output
26 | P a g e
Learning the most discriminant Gabor features by AdaBoost
In our work, we have the Gabor filtered images for both eyes and non eyes, and we have to
use the AdaBoost algorithm to classify the eye images from the non eye images. When we
will finish the boosting procedure, we will get the strong classifiers. For generating the
strong classifiers from the weak classifiers we have used the following procedures:
1. Initialize the yi values for the eyes as +1 and for non eyes as -1.
2. Initialize the weights W for eyes and non eyes as defined in the algorithm.
3. Iterate for each filter:
Calculate the weighted output for each eye images
Calculate the weighted output for each non eye images
Calculate the mean and standard deviation for eye and non eye
Iterate for all images:
o Calculate the probability given it is an eye
o Calculate the probability given it is a non eye
o If probability of being eye is greater than probability of being non eye,
we will tag hm as +1 and otherwise -1.
Calculate the error according to the algorithm.
If m >= 0.5 then stop
Calculate the m according to the algorithm.
Update the weights with the new m and hm and normalize the weight.
4. Finally calculate the strong classifier Hm.
27 | P a g e
Now we have implemented the AdaBoost algorithm for building the strong classifiers from
the weak classifiers but before going to implement the learned strong classifier in our
further implementation we have tried to investigate the formula and results in each step of
the learning phase.
In our work, we have been using the weighted output for eyes and non eyes for calculating
the mean and standard deviation for eye and non eye. Then we have calculated the
probability of each images using the mean and standard deviation of eye which can be
expressed like P(I | Eye) and calculated the probability of each image using the mean and
standard deviation of non eye which can be expressed like P(I | Non Eye). We have used this
calculated probability for constructing the weak learners for implementation of AdaBoost.
The criteria we have used is that for an image if the P(I | Eye) greater than P(I | Non Eye) we
will consider it as a 1 and if not than -1. After finishing this step, we will get the desired
weak classifier for each image. The terminology can be described as the following figure[8].
Figure 8: shows the probability calculation for construction weak learners
When we have constructed the weak learners, the next step is to calculate the error for
each filter. For calculating the error as described in the algorithm, the formula will take into
consider the values those are poorly classified and in each step it will try to minimize the
Should be
greater
Should be
greater Eye Images
Non Eye
Images
P (I | Eye) P (I | Non Eye)
28 | P a g e
error. In each step, if an image is misclassified i.e. [yi ≠ hm(xi)] it will be considered for
calculating the error and the total error is the sum of all the misclassified images. This error
is further used to calculate the m and for updating the weights. The aim of updating the
weights is to give larger weights wi(m) to the harder-to-classify examples (xi, yi) so that in
the next iteration more emphasis is placed on these examples.
When all the iterations have been completed, we get a sequence of best weak classifiers hm
and the best combining weights m which are then used to extract the eyes from full face
images.
29 | P a g e
Chapter 4: Experimental Results
For implementing and testing the algorithms described in the previous sections, we have
used a face database containing 10 different subjects expressing 11 different facial
expressions, total (10x11) 110 face images. As we will concentrate our experiment to
extract the eyes from these images, we have collected different eye and non eye images
from this face database constructing a database of 30 eye images and 30 non eye images.
We have used this image database for implementing the Gabor filter on each of the images
and to train the system for Naïve Bayes and AdaBoost classification. When the training is
done, we have selected 10 different full face images from the original database to test the
system whether it can classify the eye regions properly. In this recognition system, we first
tried to use the images in the exact form but when we have found the result, it was a little
bit frustrating that the hair of the images is affecting the recognition procedure. Finally we
have extracted the face portion of the image to test the final system, and the results are
quite good in respect to the previous. In the figure[9,10,11], we can see the eye and non eye
images and also the test face images used in this work.
In the first step, we have tested the Gabor filter with the bank of parameters to test the
outputs. For each eye and non eye images, we have captured the 2D gray level image. We
have passed each image to the Gabor filter and get the filter output and also the convoluted
output of the image. In the figure[12], we can see some of the 2D output results and surface
plot of the EGF.
Figure 9: shows the 30 eye image dataset.
30 | P a g e
Figure 10: shows the 30 non eye image dataset.
Figure 11: shows sample test images set
The outputs of the EGF are showing that the higher frequency is extracted from the center
of the eye. So when the frequency is appropriate, the horizontal EGF can stand out the eye
region efficiently. For this reason, we have chosen a bank of frequency and pass it to the
EGF to extract the eye regions efficiently.
After getting the filter output of all the images, we have applied the output images in Naïve
Bayes classification algorithm to classify the eyes and the non-eyes so that when we will
apply the algorithm to extract the eyes from the face, it can classify the eyes from other
parts of the image. In the Bayesian analysis, this belief is known as the prior probability.
Prior probabilities are based on previous experience, in this case the probability of being
an eye and non-eye, and often used to predict the outcomes. When we have formulated our
prior probability, we are now ready to classify a new image.
If we plot the probability of being an eye and the probability of being a non-eye, we can
understand that the less they overlap each other the more the classification is perfect. In
our work, we have tried to examine the outputs to find that how the classification
algorithm works for each of the filter. In the figure[13], the blue line shows the probability
of being eye P(I|Eye) and the red line shows the probability of non-eye P(I|NonEye). Here
we can see that the filter output differentiates the eye and non eye but cannot classify them
clearly. This probability outputs are the prior probability for eye and non eye images.
31 | P a g e
Figure 12: the first row shows the 2D outputs and the second row shows the surface plot of the EGF filter
Now we will use this prior probability to classify an image and to do that we have passed
the test images to extract the eye portions from the non eye portions of the complete facial
image. In this process, we have used the mean () and standard deviation () for eyes and
non eyes to get the classified output of an image. From this two classified image, we
computed the difference and the result is the final classified output of the image. This
process is described with a sample image in figure[14].
Figure 13: sample plot for probability of being eye (blue) and non-eye (red) for a filter
32 | P a g e
Figure 14: shows the process and the classified output result of Naïve Bayes
The next step of our work is to implement the AdaBoost algorithm so that we can do a
comparative research on the output of the two classification algorithm. For implementing
the AdaBoost algorithm, we have used the same Gabor filter outputs of the eye and non eye
images. According to the procedures described in the methodology section, we have started
with random weights and after each iteration, we have updated the weights increasing the
weights of the misclassified examples and decreasing the weights of correctly classified
examples. We have continued the process for each filter and after completing the iterations
we have got the m values. Finally, we calculated the strong classifier Hm which is a
Gabor
Filter
1
Gabor
Filter 2
Gabor
Filter 3
….
Gabor
Filter 15
P(Image|Eye) P(Image|NonEye
)
Final
Classified
Image
output
33 | P a g e
weighted majority vote of the m weak hypothesis where m is the weight assigned to hm.
Schapire and Singer [21] showed how AdaBoost and its analysis can be extended to handle
weak hypotheses which output real-valued or confidence-rated predictions. That is, for
each images, the weak hypothesis hm outputs a prediction hm(x) R whose sign is the
predicted label (-1 or +1) and whose magnitude |hm(x)| gives a measure of “confidence” in
the prediction. And the strong classifier Hm contains the final measure of “confidence” of
each individual image set. In the following table, we have showed the final classification
label (+1 or -1) of eye images and non eye images.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
-1 1 -1 1 -1 -1 1 1 1 1 1 1 1 -1 1
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
1 1 1 -1 1 1 1 -1 1 1 1 1 -1 1 -1
Table 1: shows the Hm labels for eye images (+1-correctly classified, -1-misclassified)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 -1 -1 -1
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
1 -1 -1 -1 -1 -1 -1 1 1 -1 -1 1 -1 -1 -1
Table 2: shows the Hm labels for non-eye images (-1-correctly classified, +1-misclassified)
Now we will try to illustrate and compare the obtained classification results using the two
algorithms. In the figure[15], we presented the final outputs of the Naïve Bayes and
AdaBoost classifier so that we can see the difference of the outputs of this two
classification.
In the figure, we can see the output of Naïve Bayes classifier in the first row and in the
second row the outputs of AdaBoost classifier. From the outputs, we can easily find that the
AdaBoost classification outputs are much more reliable and consistent than the Naïve
Bayes classification results.
34 | P a g e
a b c d e f g
h i j k l m n
Figure 15: the results of classifying the eyes in our face dataset using Naïve Bayes (a-g) and
AdaBoost classifier (h-n)
The most basic theoretical property of AdaBoost concerns its ability to reduce the training
error. AdaBoost is adaptive in that it adapts to the error rates of the individual weak
hypothesis and efficiently converts a weak learning algorithm into a strong algorithm. On
the other hand, Naïve Bayes classification is based on the prior probability learning theory
and it tries to classify the problem according to the prior knowledge. Whereas AdaBoost
requires no prior knowledge about the weak learner and so can be flexibly combined with
any method for finding weak hypothesis. In nearly all of the resulting images, AdaBoost
performed as well or significantly better than the results of Naïve Bayes.
We can find that the Naïve Bayes results fails to significantly locate the eye positions form
our face dataset used for this experiment. The Elliptical Gabor filter tries to locate the eye
position in the face image and then we have used the filter results for classifying. But in
Naïve Bayes classifier gives the output where not only the eye positions but some other
portions of the face are extracted as well. The reason behind this problem is that it cannot
classify the eyes from the non eye regions of the face. We may get a better output from this
classification algorithm if we use more eyes and non eyes dataset for increasing the prior
knowledge of this classification method for accurately differentiate the eyes from non eye
regions.
35 | P a g e
Figure 16: shows the final eye detection results of the face dataset
But AdaBoost algorithm is much efficient in this case as it can give us a better classification
result than naïve Bayes with the same dataset with less computational cost. In the resulting
images, we can see that the results of the AdaBoost are proficient in case of extracting the
eyes from the non eye regions of the image. A nice property of AdaBoost is its ability to
identify outlier i.e. examples that are either mislabeled in the training data, or which are
inherently ambiguous and hard to categorize. This ability helps this algorithm to
differentiate the eyes from the non eyes efficiently after each iteration. But Naïve Bayes
algorithm only depends on its prior knowledge i.e. the probability to classify the eyes from
the non eyes which make it less efficient in classifying the eyes from the non eyes.
The experimental result indicates that the classification by AdaBoost is much stronger than
the Naïve Bayes classifier when the classification dataset in limited which is the significant
finding of our work.
Finally, we have tried to locate the eye position from our face datasets so that we can prove
that our system finds the eye location successfully. The eye location is extracted based on
the results of the AdaBoost as we have seen that it can classify the eye positions robustly
than the Naïve Bayes algorithm. We note that when the image has some deflection, the
performance of our system deteriorates a bit, but the results are better. We have tested the
classification on 10 images from which the system can perform well in almost 7 images and
can locate the eye position successfully. In the figure [16], we can see the final result of the
system.
We also note that instead of some variations in the facial expressions, the system can
correctly locate the eye positions. It proves that our work is not affected by the variation of
36 | P a g e
the facial expression as the eye positions remain fixed for different facial expression. So we
can see the system performs well to locate the eye positions successfully based on the
classification result.
37 | P a g e
Chapter 5: Conclusion
The increase in complexity in consumer goods such as automobiles and home appliances
provides for a new market for technologies such as face recognition. Additionally, the
recent events in the world have spurred a public demand for security and safety in public
places; demands that could be partially met by deployment of these technologies.
The objectives of this thesis work were: To discuss and summarize the process of 2D facial
characterization using Gabor filter and some classification methods, to look at currently
available eye location recognition techniques based on 2D Gabor filter, to design and
develop a robust eye location detection system based on AdaBoost and Naïve Bayes
classification algorithm, and finally compare the results of the two classification algorithm
and extract the eye location based on the classification results.
In chapter 2 of this thesis presents a comprehensive literature overview of the Elliptical
Gabor filter (EGF), and two important classification algorithms i.e. Naïve Bayes and
AdaBoost satisfying the two first objectives.
The third objective of this thesis is satisfied by the work presented in chapter 3 by the
methodology for implementing the Gabor filter and other two classification algorithms
based on our eye and non eye dataset.
The last objective is satisfied by the work presented in chapter 4 showing the experimental
results based on the methodology described in the earlier chapter. While presenting the
results, we compared the two classification algorithms with their outputs and finally
concluded with the eye location extraction results from the face dataset.
As eye location extraction was one of our key ideas of this thesis work, we have
implemented a system based on the Gabor filter and two classification algorithms. Besides
this, we have presented the research work about the comparison of the Naïve Bayes and
AdaBoost algorithm. Finally, the system can locate eyes exactly and rapidly. Experiments
show that the performance of this system is robust against the variation of facial
expressions.
As an improvement and projected future work, we can consider the implementation of the
3D Gabor filters as well as 2D and implement the classification algorithms to check that
how much the classification works in case of 3D images. The third dimension contributes to
characterize faces in a better way and so, to increase the quality of the systems. Our
master’s thesis is the first step of a large project. The aim of it is to automatically recognize
38 | P a g e
the probability of some illnesses in foetal that are 22 weeks aged. The features to be
analyzed from the foetal are extracted from 3D images captured inside the uterus. In this
first step, we concentrated to work with the 2D images and implement the classification
algorithms. In the next step, we will concentrate on the 3D images datasets to apply the 3D
Gabor filter as well as classification algorithms. And then continue the work for applying
the system for automatic recognition on the 3D images of the foetal that will significantly a
good work in the improvement of the integration of Information technology and medical
science.
39 | P a g e
Appendix A: Terminology
AdaBoost: short form of Adaptive Boosting, is a machine learning algorithm.
Bandwidth: a measure of the width of a range of frequencies, measures in Hertz.
Bank of Filters: is an array of frequencies to use as the inputs for testing the filter results.
Bayesian Probability: one of the different interpretations of the concept of probability
and belongs to the category of evidential probabilities.
Boosting: a machine learning meta-algorithm for performing supervised learning.
Convolution: a mathematical operation on two functions f and g, producing a third
function that is typically viewed as a modified version of one of the original functions.
Covariance matrix: a matrix whose element in the i, j position is the covariance between
the i th and j th elements of a random vector.
Domain: is the set of entities over which certain variables of interest in some formal
treatment may range.
EGF: Elliptical Gabor Filter
Frequency (F): the number of occurrences of a repeating event per unit time.
Hypothesis: is a proposed explanation for a phenomenon.
Learning algorithm: a scientific discipline concerned with the design and development of
algorithms that allow computers to evolve behaviors based on empirical data, such as from
sensor data or databases.
Mean (): the expected value of a random variable, which is also called the population
mean.
Naïve Bayes classifier: a simple probabilistic classifier based on applying Bayes' theorem
with strong (naïve) independence assumption.
40 | P a g e
Pixel: a single point in a raster image, or the smallest addressable screen element in a
display device.
Prior Probability: often called simply the prior, an uncertain quantity p is the probability
distribution that would express one’s uncertainty about p before the “data” is taken into
account.
Resampling: the process of estimating of the precision of sample statistics (medians,
variances, percentiles) by using subsets of available data or drawing randomly with
replacement from a set of data points.
Strong Learner: is a classifier that is arbitrarily well-correlated with the true classification.
TGF: Traditional Gabor Filter
Theta (): the rotation angle of the filter.
Variance (): a measure of how far the numbers lie from the mean (expected value).
Weak Learner: is defined to be a classifier which is only slightly correlated with the true
classification.
41 | P a g e
Appendix B: Sample codes
EGF_fn.m
function [G, GABOUT] = EGF_fn(I,sx,sy,t,F)
if isa(I,'double')~=1 I=double(I); end
indexX = 1; for x=-12:12 indexY = 1; for y=-19:19 x1=x*cos(t)+y*sin(t); y1=-x*sin(t)+y*cos(t); G(indexX,indexY) = (1/(2*pi*sx*sy))*exp(-0.5*((x1^2/sx^2) +
(y1^2/sy^2)))*... exp(2*pi*j*F*(sqrt(x^2 + y^2))); indexY = indexY + 1; end indexX = indexX + 1; end
GABOUT=conv2(double(I),double(G),'same');
end
main.m
%setting the parameters for Elliptical Gabor Filter sx = 2.3; sy = 5.0; t = 0; f=[.145, .152,.155, .1583, .16, .164, .1681, .171 ,.1732, .175, .178,
.1811,.183,.185,.187];
load colormaps.mat
% Show the grayscale image colormap(grayscale);
matrixouteye = zeros(30,15); matrixoutnoneye = zeros(30,15);
%read images from the Images directory imagedir = 'eyes'; tifffiles = dir([imagedir '/*.jpg']);
42 | P a g e
for k = 1:length(tifffiles) filename = [imagedir '/' tifffiles(k).name]; I = rgb2gray(imread(filename));
adjustedImage = imadjust(I, stretchlim(I),[]);
for i=1:length(f) [G,GABOUT] = EGF_fn(adjustedImage,sx,sy,t,f(i)); R= real(G);
%multiplying the GABOUT and image out = sum(sum(double(R) .* double(I)));
%saving the output in a matrix matrixouteye(k,i) = out;
end end
%read non eyes from the Images directory imagedir = 'noneyes'; tifffiles = dir([imagedir '/*.jpg']); for k = 1:length(tifffiles) filename = [imagedir '/' tifffiles(k).name]; I = rgb2gray(imread(filename));
for i=1:length(f) [G,GABOUT]= EGF_fn(I,sx,sy,t,f(i)); R= real(G);
%multiplying the GABOUT and image out = sum(sum(double(R) .* double(I)));
%saving the output in a matrix matrixoutnoneye(k,i) = out;
end end
%Display the output Matrix of eyes disp('The output Matrix of eyes'); disp(matrixouteye);
%Display the output Matrix of noneyes disp('The output Matrix of noneyes'); disp(matrixoutnoneye);
matrixout = [matrixouteye;matrixoutnoneye];
%calculating the mean of the output Matrix of eyes mean_eye = mean(matrixouteye); disp('The mean values of the output Matrix of eyes'); disp(mean_eye);
43 | P a g e
%calculating the std of the output Matrix of eyes std_eye = std(matrixouteye); disp('The STD values of the output Matrix of eyes'); disp(std_eye);
%calculating the mean of the output Matrix of non eye mean_noneye = mean(matrixoutnoneye); disp('The mean values of the output Matrix of non eyes'); disp(mean_noneye);
%calculating the std of the output Matrix of non eyes std_noneye = std(matrixoutnoneye); disp('The STD values of the output Matrix of non eyes'); disp(std_noneye);
%This is the testing part of the Program to test whether %the trained system can classify a eye region or not
img = rgb2gray(imread('Images/10.jpg'));
outputEye = naiveclassify2(std_eye,mean_eye,f,double(img)); outputNonEye = naiveclassify2(std_noneye,mean_noneye,f,double(img));
%Now compare the two classifier values to detect eye or noneye THRE = 0.0; [x y] = size(img); classifiedOutput = []; diff = [];
for i= 1:x for j = 1:y diff(i,j)= outputEye(i,j)- outputNonEye(i,j); if(diff(i,j)>=THRE) classifiedOutput(i,j)= 255; else classifiedOutput(i,j)= 0; end end end
figure, imshow(classifiedOutput);
44 | P a g e
naiveclassify.m
% this function calculates the class value given a new 128x128 sized % image to classify for a set of Gabor frequency, std and mean vlaues.
function output = naiveclassify(std, mean, f, I)
if isa(I,'double')~=1 I=double(I); end
sx = 2.3; sy = 5.0; t = 0; filterOutputs = [];
for i=1:length(f) [G,GABOUT] = EGF_fn(I,sx,sy,t,f(i)); R= real(G);
if(size(I)== size(double(R))) res = conv2(I,double(R), 'same'); [x y] = size(res); out = res(round(x/2),round(y/2)); else out = conv2(I,double(R), 'same'); end
value = normpdf(out,mean(i),std(i));
[x y] = size(value); minimum = min(min(value)); maximum = max(max(value)); for m = 1:x for n = 1:y norm = (value(m,n)-minimum)/(maximum - minimum); value(m,n) = norm * 255; end end
filterOutputs{i} = value; end
disp(filterOutputs);
[x y] = size(I); output = ones([x,y]); for i=1:length(filterOutputs) output = output.*filterOutputs{i}; end
end
45 | P a g e
adaboost.m
%Adaboost Learning phase
%initializing the y=+1 for eyes and y=-1 for non eyes dataclass_eye = ones(length(matrixouteye),1).* 1 ; dataclass_noneye = ones(length(matrixoutnoneye),1).* -1; dataclass = [dataclass_eye;dataclass_noneye];
%initialize the alpha alpha =ones(1,length(f)).*(1/(length(matrixouteye)+length(matrixoutnoneye)));
%for storing the final values of alpha alpha_zero = 1/(length(matrixouteye)+length(matrixoutnoneye)); %for the first
iteration
%initializing weights for the eyes weight_eye = ones(length(dataclass_eye),1).*(1/(2*length(dataclass_eye)));
%initializing weights for the non eyes weight_noneye =
ones(length(dataclass_noneye),1).*(1/(2*length(dataclass_noneye)));
%initialize the weight matrix 69x1 weight_final = ones(length(dataclass),length(f)); weight = [weight_eye;weight_noneye];
%initializing the 69x15 matrix for storing the values of Hm for each filter Hm = zeros(length(weight),1); hm = zeros(length(dataclass),length(f));
p_eye = zeros(length(dataclass),length(f)); p_noneye = zeros(length(dataclass),length(f));
%forward inclusion phase of Adaboost algorithm for i= 1:length(f)
if(sum(weight,1) ~= 1.0000) z = sum(weight,1); weight = weight./z(ones(size(weight,1), 1), :); end
out_eye = matrixouteye(:,i).*weight(1:30,1); out_noneye = matrixoutnoneye(:,i).*weight(31:end,1); out = [out_eye;out_noneye];
%in each iteration we are calculating the mean and std for eye and %noneye mean_eye = mean(out_eye); std_eye = std(out_eye);
mean_noneye = mean(out_noneye); std_noneye = std(out_noneye);
for j=1:length(dataclass)
46 | P a g e
p_eye(j,i) = normpdf(out(j,1),mean_eye,std_eye); p_noneye(j,i) = normpdf(out(j,1),mean_noneye,std_noneye);
if(j<=30) if(p_eye(j,i) >= p_noneye(j,i)) hm(j,i) = 1; else hm(j,i) = -1; end else if(p_eye(j,i) >= p_noneye(j,i)) hm(j,i) = -1; else hm(j,i) = 1; end end
end
err = sum(weight.*(sign(hm(:,i))~= dataclass(:))); if(err >= 0.5) alpha(1,i) = 0; else alpha(1,i) = log10((1-err)/err); end
for k=1:length(weight) res = dataclass(k,1)* alpha(1,i) * hm(k,i); weight(k,1) = weight(k,1) * exp(-res); end z = sum(weight); weight = weight./z; weight_final(:,i) = weight;
end
for i=1:length(dataclass) for j=1:length(f) Hm(i,1) = Hm(i,1) + alpha(1,j)*hm(i,j)/sum(alpha); end Hm(i,1) = sign(Hm(i,1)); end
%Testing with strong classifier filterOutputs = []; img = rgb2gray(imread('Images/2.jpg'));
if isa(I,'double')~=1 I=double(img); end
47 | P a g e
for i=1:length(f) [G,GABOUT] = EGF_fn(I,sx,sy,t,f(i)); R= real(G);
out = conv2(I,double(R), 'same');
filterOutputs{i} = alpha(1,i).* out;
end
[x y] = size(I); output = zeros([x,y]); for i=1:length(filterOutputs) output = imadd(output,filterOutputs{i}); end
[m n] = size(output); max1= max(max(output));
[svals, idx ] = sort(output(:),'descend'); [II,JJ] = ind2sub([m,n],idx(2));
x = getcoord(max1, output);
if((x(1,2)-JJ)< 50) %find the another highest value which has the distance > 50) i=3; while(abs(x(1,2)-JJ)< 50 && i<=10) [II,JJ] = ind2sub([m,n],idx(i)); i = i+1; end end
image = MidpointCircle(img, 7, x(1,1),x(1,2), 0); image2 = MidpointCircle(image, 7, II,JJ, 0); figure,imshow(image2);
48 | P a g e
Bibliography
[1] Yanfang Zhang, Nongliang Sun, Yang Gao, Maoyong Cao, “A new eye location method based on Ring Gabor Filter”. International Conference on Automation and Logistics Qingdao, China September 2008.
[2] Z. M. Hafed, M. D .Levine, “Face recognition using the discrete cosine transform,” .International Journal of Computer Vision, 2001, 43 (3): 167-188.
[3] H. Zhou, X. Geng. “Projection Functions for Eye Detection,” Pattern Recognition, No. 5, pp. 1049-1056, May 2004.
[4] Y. Ma, X. Ding, Z. Wang, N. Wang, “Robust Precise Eye Location under Probabilistic Framework,” Proc. 6th IEEE Int’l Conf. on Automatic faceand Gesture Recognition (FGR’04), pp.339-344, May 2004.
[5] Z. Niu, S. Shan, S. Yan. X. Chen and W. Gao, “2D Cascaded Adaboost for Eye Location,” 18th Int’1 Conf. on Pattern Recognition,Vol.2,pp.1216-1219, Aug, 2006.
[6] L. Yuille, D. S. Cohen, and P. W. Hallinan, "Feature Extraction from Faces using Deformable Templates," in IEEE Proc. of Computer Visionand Pattern Recognition(CVPR 1989),pp.104-109,Washington,DC,June 1989.
[7] Peng Yang, Bo Du, Shiguang Shan, Wen Gao, “A Novel Pupil Localization Method Based On Gaboreye Model And Radial Symmetry Operator,” Proc. Of ICIP 2004, pp.67-70, 2004.
[8] Lim R, M.J.T.Reinders, Thiang, “Facial landmark detection using a Gabor filter representation and a genetic search algorithm,” In: Proceeding , seminar of intelligent technology and its applications.
[9] Song Li, Danghui Liu, Lansun Shen, “Eye Location Using Gabor Transform”, Measurement and Control Techniques, 2006, 25(5): 27-29.
[10] http://en.wikipedia.org/wiki/Naive_Bayes_classifier
[11] M. A. Webster, R. L. De Valois, “Relationship between spatial frequency and orientation tuning of striate cortex cells,” Journal of the Optical Society of America, 1985, 2(7): 1124-1132.
[12] Yoav Freund, Robert E. Schapire. "A Decision-Theoretic Generalization of on-Line Learning and an Application to Boosting", 1995
[13] Michael J. Jones and Paul Viola. “Face Recognition Using Boosted Local Features”, MERL Technical Reports. TR 2003-25, April 2003. [14] D. Gabor, Theory of communication, IEEE 93 (1946), 429-457.
49 | P a g e
[15] J. Daugman. Uncertainty relation for resolution in space, spatial frequency and
orientation optimized by two-dimensinak visuak cortical filters. Journal of the Optical
Society of America A, 2(7): 1160-1169, 1985.
[16] B. Duc, S. Fischer, and J. Bigun, “Face authentication with gabor information on
deformable graphs,” IEEE Transactions on Image Processing, vol. 8, no. 4, pp. 504–516,
April 1999.
[17] C Liu and H. Wechsler, “Independent Component Analysis of Gabor Features for Face
Recognition,” IEEE Transactions. Neural Networks, vol. 14, no. 4, pp. 919–928, 2003.
[18] X. He, S. Yan, Y. Hu, P. Niyogi, and H. Zhang. Face recognition using Laplacianfaces. IEEE
Transactions on Pattern Analysis and Machine Intelligence, 27(3):328–340, 2005.
[19] Viola, P. and Jones, M. Rapid object detection using boosted cascade of simple features.
IEEE Conference on Computer Vision and Pattern Recognition, 2001.
[20] Open Computer Vision Library Reference Manual. Intel Corporation, USA, 2001.
[21] Robert E. Schapire and Yoram Singer. Improved boosting algorithms using confidence-rated predictions. In Proceedings of the Eleventh Annual Conference on Computational Learning Theory, pages 80–91, 1998. To appear, Machine Learning. [22] S. Z. Li & A. K. Jain (Eds.), “Handbook of Face Recognition”, Springer (chap 1, 2,3)
[23] A.K. Jain, P. Fkynn & A.A. Ross, “handbook of Biometrics”, Springer (chap. 3)