Parallel Processing for Automatic Face Recognition using Eigenfaces
Yong-Seok Cheon and Chang-Sung Jeong
Department of Electronic Engineering
Korea University, Anam-dong 5-1, Sungbuk-gu
Seoul, Korea
e-mail: [email protected]
Abstract
In this paper, we present a parallel face recognition algorithm based on \eigenfaces", which are known
as the signicant features because they are the eigenvectors(principal components) of a set of face images. Our
work is composed of two phases: eigenface construction
and face recognition. For the construction of eigenfaces,
a solution of eigenvalue/eigenvector problem using parallel Jacobi transformation is suggested. In recognition
phase, a set of weight components is calculated in parallel by projecting a input face image onto each of precomputed eigenfaces at each processing elements(PE's).
Our parallel face recognition approach were implemented
and evaluated on the transputer based parallel computer
using grey scale face images with moderately cluttered
backgrounds. Experimental results reveals that time
taken for both eigenface construction and recognition is
sharply decreased as the number of PE's are increased.
Keywords
Face recognition, parallel algorithm, high performance computing, parallel linear algebra
1. Introduction
Automatic face recognition is emerging as an active research area spanning several disciplines such as image
processing, pattern recognition and computer vision. A
general statement of the problem can be formulated as
follows: Given still or video image of a scene, identify one
or more persons in the scene using a stored database of
faces. The solution of the problem involves segmentation
of faces from cluttered scenes, extraction of features from
the face region, identication, and matching. In this paper, we are concerned with the parallel face recognition
based on eigenface approach.
Automatic human face recognition can be broadly
categorized into two major branches, one which relies on
a 3-D input image, while the other works with a 2-D
representation(intensity data) of the image[2]. Though
3-D face recognition approaches have demonstrated some
advantages, proponents of a 2-D face recognition scheme
would cite the abundance of data present in the world
today, from police mug shots to newspaper photographs,
as a major incentive to do research on face recognition
based on 2-D data. Brunelli and Poggio discussed the
classication of automatic face recognition methods into
This
paper was supported by Korea Sanhak Foundation, 1995
two broad classes of techniques: geometric feature based
matching and template matching[4]. Geometric feature
based matching involves decomposing the face image into
pertinent features like eyes, nose, mouth, chin, etc[6, 7].
The general idea behind template matching approach is
the construction of an articial template to match with
the prominent features of the face. Yuille et al.[5] described two such templates, one for the eye and the other
for the mouth.
Another work, slightly dierent from those mentioned above, is used by Turk and Pentland[1]. They
adopted matching using \eigenfaces," i.e. template
matching using the Karhunen-Loeve transformation of
a set of face images[3]. In their approach face images are
projected onto a feature space called the \face space".
The face space is dened by \eigenfaces", which are determined by the set of eigenvectors of the set of training faces. A new target face is projected onto this face
space. The norm is used as the measure for matching.
This method does not rely on features such as eyes, ears
and noses within the face for matching. This approach
has advantages over other face recognition schemes in its
speed and simplicity, learning capacity, and insensitivity
to small or gradual changes in the face image.
In this paper, we present a parallel face recognition
algorithm based on eigenfaces. Our algorithm is basically composed of two phases: eigenface construction
and face recognition. For construction of eigenfaces, a
solution of eigenvalue/eigenvector problem using parallel Jacobi transformation is suggested. In recognition
phase, a set of weight components is calculated in parallel by projecting the input face image onto each of precomputed eigenfaces at each processing elements(PE's).
The organization of this paper is as follows. In
section 2, we describe eigenface approach for face recognition. In section 3 and 4, we shall present a parallel
face recognition algorithm using eigenfaces and its experimental results respectively. Finally, in section 5, we
give a conclusion.
2. Eigenface Approach
The idea of using eigenfaces was motivated by a technique developed by Sirovich and Kirby[3] for eciently
representing pictures of faces using principal component
analysis. The scheme is based on an information theory approach that decomposes face images called \eigen-
eigenvalues, respectively, of the covariance matrix
C = M1
M
X
n=1
nTn = AAT
where the matrix A = [1 2 : : : M ].
Consider the eigenvectors vi of AT A such that
T
A Avi = i vi . Premultiplying both sides by A, we have
AAT Avi = i Avi fromTwhich we see that Avi are the
eigenvectors of C = AA .
Following this analysis, we construct the M by M
matrix L = AT A, where Lmn = Tm n , and nd the
M eigenvectors, vl , of L. These vectors determine linear
combinations of the M training set face images to form
the eigenfaces ul .
Figure 1: Eigenfaces
faces," which may be thought of as the principal components of the initial training set of face images. Recognition is performed by projecting a new image onto the
subspace spanned by the eigenfaces (\face space") and
then classifying the face by comparing its position in face
space with the positions of known individuals. This approach to face recognition involves the following initialization and eigenface construction operations and recognition operations.
2.1 Eigenface construction
Let an image be a two-dimensional N by N array of
intensity values. The image may also be considered as
a vector of dimension N 2 , or equivalently, a point in
N 2 -dimensional space. Image of faces, being similar in
overall conguration, will not be randomly distributed in
the huge image space and can be described by a relatively
low dimensional subspace. The eigenfaces resulted from
the eort to nd the vectors that best account for the
distribution of face images within the entire image space.
Let the training set of face images be ?1 , ?2 , ?3 ,
: : :,P?M . The average face of the set is dened by =
1 M
M n=1 ?n . Each face diers from the average by the
vector i = ?i ? . This set of very large vectors is then
subject to principal component analysis, which seeks a
set of M orthonormal vectors, un , which best describes
the distribution of the data. The kth vector, uk , is chosen such that
M
X
1
k = M (uTk n )2
n=1
is a maximum, subject to
uTl uk = lk =
1; if l = k
0; otherwise
The vectors uk and scalars k are the eigenvectors and
ul =
M
X
k=1
vlk k ;
l = 1; : : : ; M
2.2 Classcation and recognition using eigenfaces
A new face image(?) is transformed into its eigenface
components (projected into \face space") by a simple
operation,
!k = uTk (? ? )
for k = 1; : : : ; M . The weights form a vector T =
[!1 !2 : : : !M ] which describes the contribution of each
eigenface in representing the input face image, treating
the eigenfaces as a basis set for face images.
The simplest method for determining which face
class provides the best description of an input face image
is to nd the face class k that minimizes the Euclidian
distance
k = k(
? k )k2
where k is a vector describing the kth face class. The
face classes i are calculated by averaging the results
of the eigenface representation over a small number of
face images of each individual. A face is classied as
belonging to class k when the minimum k is below some
chosen threshold e . Otherwise the face is classied as
\unknown" or \not a face".
3. Parallel Algorithm
3.1 Parallel face recognition
In this section we shall describe a parallel algorithm for
automatic face recognition using eigenfaces. The algorithm can be described as follows: First, M face images of the training set are distributed over M PE's,
and M eigenfaces is computed in parallel. Since the
eigenface computation involves typical symmetric eigenvalue/eigenvector problem, sequential method is very
costly. We present a parallel Jacobi transformation to
solve the eigenvalue/eigenvector problem to make eigenfaces. After the eigenfaces are ready, M face classes
based on M face images in the training set are constructed using the eigenfaces. Each face class has a
pattern vector which describes the contribution of the
eigenfaces in representing the related face image in the
6). Determine if ? is a face at all by checking to see if
the image is suciently close to \face space" using
the appropriate threshold value.
7). If it is a face, classify the weight pattern as either a
known person or as unknown as follows : Compute,
for each PE (i), Euclidian distance i of the pattern
vector T for the new face image ? from the pattern vector i in parallel. The face with the minimum distance to T is the identication result. If
the minimum distance is above the threshold value,
the input face image is determined as \unknown".
3.2 Parallel Jacobi transformation
(a) input image
(b) matched image
Figure 2: Recognition results
training set. For recognition of a new face image, a pattern vector for the face is calculated in parallel using
precomputed M eigenfaces. Now, we can determine the
new face image as \one of the face in training set", \unknown", or \not a face" according to the minimal Euclidean distances of the pattern vector for the new face
image from those for M face classes.
The outline of the parallel face recognition algorthm is given below.
Initialization and eigenface construction
1). Store each characteristic face image ?i(1 i M )
in PE (i). The set of these initially registered face
images is called \training set".
2). Calculate, for each PE (i), the eigenface ui from the
training set in parallel. The M eigenfaces can be
obtained by solving symmetric eigenvalue problem
using parallel Jacobi transformation. The eigenfaces ui 's are unit vectors that dene the subspace
determined by the face images in training set, which
we call \face space".
3). Calculate, for each PE (i), the eigenface weight component !ki in M -dimensional weight space for each
face image ?k in the training set by projecting it
onto the \face space". Each of M weight components can be computed by simple dot product
in parallel. M eigenface weight components for
?k form a pattern vector Tk = [!k1 ; !k2 ; : : : ; !kM ]
that describes the contribution of eigenfaces in representing the face image, treating the eigenfaces as
a basis set for face images.
4). Store a pattern vector i for each face image ?i in
PE (i). i represents a face class i. Consquently,
PE (i) contains ui and i
Recognition
5). Transform a new face image ? into its eigenface com-
ponents in parallel and make the pattern vector
T = [!1; !2 ; : : : ; !M ] by projecting the input face
image onto each of M eigenfaces at each PE.
The main part of the eigenface construction step is to
solve a symmetric eigenvalue/eigenvector problem. Since
this is inherently one of the most time-consuming procedure and eigenfaces have to be recalculated when new
face classes enter the training set, we propose a parallel
method using Jacobi transformation to speed it up.
An N N matrix A is said to have an eigenvector x and corresponding eigenvalue , if A x = x.
The Jacobi method consists of a sequence of orthogonal
similarity transformations of the form as below.
D = PT3 PT2 PT1 A P1 P2 P3 If we get all the way to diagonal form, then the eigenvectors are the columns of the accumulated transformation.
X = P 1 P2 P3 Each transformation is just a plane rotation designed
to annihilated one of the o-diagonal matrix elements
and aects only two rows and columns. The idea of the
Jacobi method is to try to zero the o-diagonal elements
by a series of plane rotations.
Jacobi transformations can be applied in parallel to
disjoint pairs of rows and/or columns of the matrix, so a
matrix with N rows and columns can have N=2 Jacobi
transformations applied simultaneously. The question
remains of the order in which to apply the simultaneous
rotations. We use exclusive-OR operation to make N=2
disjoint pairs of rows and/or columns. Each rotation
parameter i;j is determined by the ith and j th row(or
column). The description of the parallel algorithm on
MCC with N N PE's is given below. Let the elements of the target matrix A are distributed in order
that A(i; j ) is stored in PE (i; j ).
Procedure PAR JACOBI
1. if i = j
2.
V (i; j ) = 1
3. else
4.
V (i; j ) = 0
5. Repeat
6. for k := 1 to N ? 1 do
7.
Determine i;i
k
8.
R(i; j ) A(i k; j )
9.
Determine j;j
k
10. C (i; j ) A(i; j k)
11. V 0 (i; j ) V (i; j k)
# of eigenfaces
Eigenface construction
time(sec)
Recognition accuracy
2
2.651
31.2%
4
4.230
58.7%
8
6.937
85.6%
16
11.788
97.8%
Table 1: Eect of the number of eigenfaces on execution
time and recognition accuracy (# of PE's = 1, # of face
images in the training set = 16)
# of PE's
# of faces(M )
8
16
!
#
(e.f. const.)
(recog.)
(e.f. const.)
(recog.)
1
6.98
20.07
11.78
3.24
2
4.35
11.75
7.07
1.95
4
2.83
6.58
4.59
1.22
8
1.95
4.15
2.93
0.78
Table 2: Execution time for eigenface construction and
recognition with respect to the number of PE's and M
(# of eigenfaces = M , unit : sec)
12. if i < i k
13.
A(i; j ) := cos i;i
k A(i; j ) ? sin i;i
k R(i; j )
14. else
15.
A(i; j ) := sin i;i
k R(i; j ) + cos i;i
k A(i; j )
16. if j < j k
17.
A(i; j ) := cos j;j
k A(i; j ) ? sin j;j
k C (i; j )
18.
V (i; j ) := cos j;j
k V (i; j ) ? sin j;j
k V 0 (i; j )
19. else
20.
A(i; j ) := sin j;j
k C (i; j ) + cos j;j
k A(i; j )
21.
V (i; j ) := sin j;j
k V 0 (i; j ) + cos j;j
k V (i; j )
22. if j = i k
23.
A(i; j ) := 0
24. Until convergence
End PAR JACOBI
The procedure PAR JACOBI computes N eigenvectors in V in parallel. Since it takes O(N ) to determine the rotation parameter and save the counterpart
elements by transfering each other from line 7 to line 11
and the other steps in the loop can be done in O(1), each
iteration of the loop can be done in O(N ) time on MCC.
Therefore, PAR JACOBI can be executed in O(N 2 ) on
MCC with N N PE's at each sweep.
4. Experimental Results
In this section, we shall describe the experimental results
of our work. We have implemented our parallel face
recognition algorithm on the transputer based parallel
computer KOPS(KOrea Parallel System) with the face
images obtained from MIT. We rst describe the eect of
the number of eigenfaces used on the performance, and
then the performance of the parallel algorithm is shown
as the number of PE's varies.
Table 1 shows the execution time taken for eigenface construction and recognition rate for the various
number of eigenfaces. The time taken for computing
eigenfaces is increased rapidly as the number of eigenfaces is increased, which shows that the number of eigenfaces has a signicant impact on the performance. On
the contrary, recognition accuracy is best when the number of eigenfaces is same as the number of face image in
training set.
Table 2 shows the execution time of the parallel face
recognition algorithm versus the number of PE's as the
number of face images in training set changes. Execution
time for both eigenface construction and recognition is
sharply decreased as the number of PE's is increased.
The time for recognition is for recognizing all the persons
in the training set.
5. Conclusion
In this paper, we have addressed the automatic parallel face recognition using eigenfaces. In our parallel approach, eigenfaces are computed mainly by solving eigenvalue/eigenvector problem using parallel Jacobi
transformation. Since solving eigenvalue problem with
the traditional sequential methods at the eigenface construction step is very expensive and time-consuming,
we speed up this procedure with the fast parallel algorithm. We use M eigenfaces from the training set of M
face images when M PE's are available, while the sequential approach adopts much less eigenfaces because
time for the eigenface construction step increases rapidly
with respect to the number of eigenfaces to be created.
Though smaller M 0 (M 0 < M ) eigenfaces may be sucient sometimes, more eigenfaces provide higher recognition accuracy. Our parallel face recognition approach
has been implemented on the transputer based parallel
computer KOPS(KOrea Parallel System) with grey scale
face images with moderately cluttered backgrounds. Experimental results show that execution time taken for
both eigenface construction and recognition is sharply
decreased as the number of PE's is increased.
References
[1] M. Turk and A. Pentland, \Eigenfaces for recognition," Journal of Cognitive Neuroscience, Vol. 3,
No. 1, 1991, pp. 71-86.
[2] S. A. Sirohey, \Human face segmentation and identication," Tech. Rep. CAR-TR-695, Center for
Autom. Res., Univ. Maryland, College Park, MD,
1993.
[3] M. Kirby and L. Sirovich, \Application of the
Karhunen-Loeve procedure for the charaterization
of human faces," IEEE Trans. Pattern Analysis and
Machine Intelligence, Vol. 12, No. 1, 1990.
[4] R. Brunelli and T. Poggio, \Face recognition: Features vs. Templates," IEEE Trans. Pattern Analysis
and Machine Intelligence, Vol. 15, No. 10, 1993.
[5] A. L. Yuille, D. S. Cohen, and P. W. Hallinan, \Feature extraction from faces using deformable templates," Proc. IEEE Conf. Computer Vision Pattern Recognition, 1989, pp. 104-109.
[6] B. S. Manjunath, R. Chellappa, and C. von der
Malsburg, \A feature based approach to face recognition," Proc. IEEE Conf. Computer Vision Pattern Recognition, 1992, pp. 373-378.
[7] R. Chellappa, C. L. Wilson, and S. Sirohey, \Human
and Machine Recognition of faces: A survey," Proc.
of the IEEE, Vol. 83, No. 5, 1995, pp. 705-740.