Face Recognition - Rochester CS

         

 

Face Recognition                                          

   

Programming Project

Haofu Liao, BSEE June 23, 2013

                                   

 

Department of Electrical and Computer Engineering Northeastern University

1.  How  to  build  the  PCA  Mex  Funtion   1.1  Basic  Information   The  table  below  is  the  basic  information  about  how  to  build  the  mex  function.   Operating  System  

OX  S  

IDE  

Xcode  

Programming  Language  

C++  

PCA  package  

ALGLIB  

Source  files  

Mex_PCA.cpp,  Mex_PCA.h  

Object  file  

Mex_PCA.mexmaci64  

  The  mex  function  is  built  on  Mac  OX  S  with  Xcode.  The  C++  linear  algebra   package  that  implements  the  PCA  is  ALGLIB.  User  can  download  this  package  at   http://www.alglib.net/download.php.  Mex_PCA.cpp  and  Mex_PCA.h  are  the   source  files  that  used  to  build  the  object  file.  With  these  two  files,  one  can  use   Xcode  build  the  Mex_PCA.mexmaci64  object  file  automatically.  User  can  use  the   Mex_PCA.mexmaci64  just  like  a  .m  function  in  MATLAB.  For  more  details  about   how  to  use  Mex_PCA.mexmaci64  file  on  MATLAB,  see  ~local/PCA/Source   Code/read  me  before  use.txt.  

1.2  ALGLIB  package  and  PCA  subpackage     ALGLIB  is  a  cross-­‐platform  numerical  analysis  and  data  processing  library.   User  can  look  up  its  C++  user  manual  for  details  about  how  to  use  this  package.   The  webpage  of  the  manual  is   http://www.alglib.net/translator/man/manual.cpp.html   User  can  use  the  PCA  subpackage  by  including  the  DataAnalysis  subpackage   in  his  code.  The  function  that  actually  do  the    PCA  algorithm  is   void pcabuildbasis(const real_2d_array &x, const ae_int_t npoints, const ae_int_t nvars, ae_int_t &info, real_1d_array &s2, real_2d_array &v)

Here  const real_2d_array &x and  real_2d_array &v are  two   important  parameters.  X  is  the  input  matrix,  Rows  of  X  correspond  to   observations  and  columns  correspond  to  variables.  V  is  the  principal  component   coefficients  for  X.  For  more  information  about  other  parameters,  please  see  the   user  manual.   Notice  that  X  has  a  real_2d_array  type.  Which  means  user  need  to  build  an   interface  to  make  sure  all  the  data  read  from  MATLAB  can  be  used  in  the  PCA   package.  We  will  talk  more  about  the  interface  later.  

1.3  Workflow  of  the  mex  function   The  figure  below  shows  the  work  flow  of  the  mex  function                    

Read data from MATLAB

Convert  MATLAB  data   type  to  PCA  package   data  type  

    MATLAB   Interface  

                   

Do the principal component analysis by ALGLIB PCA package

PCA  package   Interface   Interface  

Convert  PCA  package   data  type  back  to   MATLAB  data  type  

 

 

Output PCA results to MATLAB

From  the  figure  above  we  can  know  that  our  mex  function  works  as  an   interface  that  transfers  data  from  MATLAB  to  PCA  package  and  then  back  to   MATLAB.  

1.4  MATLAB  interface  and  PCA  package  interface   The  MATLAB  interface  has  the  syntax  below   #include "mex.h" void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])

Here,  mexFunction  is  the  name  of  the  gateway  function  in  C  /C++  which  every   MEX-­‐file  requires.  When  you  invoke  the  PCA  mex  function,  MATLAB   automatically  seeds  nlhs,  plhs,  nrhs,  and  prhs  with  the  caller's  information.  NLHS   is  the  number  of  expected  output  mxArrays.  PLHS  is  the  array  of  pointers  to  the   expected  output  mxArrays.  NRHA  is  the  number  of  input  mxArrays.  PRHS  is  the   array  of  pointers  to  the  input  mxArrays.    

As  we  have  mentioned  in  1.2,  the  PCA  package  requires  a  real_2d_array  type   matrix,  which  we  can  know  from  the  user  manual  can  only  be  initialized  by  a   char*  type  data.  Hence,  we  need  to  write  an  interface  to  convert  the  different   data  type.  The  function  that  implement  the  conversion  is                                                char* mat2char(const mwSize *x1, double *x2) For  more  details  about  this  function,  ~local/PCA/Source  Code/Mex_PCA/                Mex_PCA.  

2.  Comparison  between  PCA  functions   2.1  PCA  functions   Name  

Description  

Performance  

pca(svd)  

The  built-­‐in  MATLAB  PCA  function   using  singular  value  decomposition.  

0.07  sec  

pca(evd)  

The  built-­‐in  MATLAB  PCA  function   using  eigen  value  decomposition.  

388.7  sec  

Mex_PCA  

The  mex  function  PCA  using  ALGLIB   PCA  package.  This  function  is  also  use   evd  to  perform  PCA  

17.9  sec  

fastPCA  

A  PCA  function  using  algorithm   mentioned  in  [1]  

0.03  sec  

  From  the  table  above  we  know  that  there  are  four  functions  that  implement   PCA  algorithm.  The  first  two  functions  are  built-­‐in  MATLAB  functions.  They   implement  PCA  using  svd  and  evd.  The  last  two  functions  are  created  by  myself.   Mex_PCA  is  the  function  build  from  C++  code  which  implements  PCA  by  ALGLIB   PCA  package.  fastPCA  function  implements  a  new  algorithm  other  than  evd  and   svd,  it  should  have  a  better  perform  in  theory.  

2.2  Performance         Next,  We  test  the  performance  of  the  four  functions.  We  use  a  10  by  10304   matrix  that  contains  10  faces  as  the  input  of  our  functions.  Then,  we  run  these   functions  one  by  one  and  record  the  time  consumption  of  each  function.     From  the  table  of  2.1  we  can  find  that  fastPCA  runs  faster  than  other   functions,  which  suggests  that  it  is  a  good  choice  of  using  the  fastPCA  algorithm   in  our  face  recognition  project.  We  also  find  that  Mex_PCA  beats  over  the   pca(evd)  function.  Since  they  both  use  the  eigen  value  decomposition  way  to  do  

PCA.  It  means  the  C++  PCA  ALGLIB  package  have  better  performance  than  the   built-­‐in  MATLAB  function.  

3.  Face  Recognition     3.1  Eigenfaces   Our  training  images  are  from  ~local/PCA/Source  Code/att_faces/s1.  They   are  10  images  from  one  person.  Each  of  them  is  a  92×112 pixel training image. First, we transform each image to a 10304-dimensional vector and concatenate these vectors from 10 images into a 10×10304 dimensional matrix. Then, we do a principle component analysis on the matrix to find the vectors that best account for the distribution of face images within the entire image space. (Here, we use fastPCA function by default, because it has a better performance. Actually, all the four functions are ok to do PCA. The results are exactly the same). These vectors define the subspace of face images, which we call “face space.” Each vector is of length 10304, describes a 92×112 image, and is a linear combination of the original face images. Because these vectors are the eigenvectors of the covariance matrix corresponding to the original face images, and because they are face-like in appearance, we refer to them as “eigenfaces. Below is the eigenfaces we got from folder s1.

 

3.2  Projection   Once get the eigenfaces, we can project a new face image on the image space that the eigenfaces defines. The equation that we use to get the projection is 𝛺 = 𝑈! 𝛤 − Ψ 𝛷 = 𝑈𝛺! Here, 𝑈 is a 10304×9 matrix whose column is an eigenfaces from the figure in 3.1. 𝛤 is the new face image. Ψ is the average 10304×1 face of the training images. 𝛺 is a 9×1 weights vector that describes the contribution of each eigenface in representing the input face image, treating the eigenfaces as a basis set for face images. 𝛷 is the 10304×1 projection. Below shows two input images and their projections

Input  Image  

Projection  

Input  Image  

Projection  

The upper figure is an original image from the training set and its corresponding projection. We can find that the projection and the input image is nearly the same (the difference is caused by the subtraction of the average image). It is reasonable because the training images are the linear combination of the eigenfaces. The bottom figure is a new face image and its projection. We can find these two doesn’t look like the same. But we can find the eigenfaces try their best to match the input image.

3.3  Face  Recognition   We can use the input image and its projection to do the face recognition. The equation we use to evaluate an input image is 𝜖 ! = 𝛷 − 𝛷! Here, 𝛷 is the mean adjusted input image 𝛷 = 𝛤 − Ψ, 𝛷! is the projection of the input image and 𝜖 is the distance between the image and the face space. Hence, we can use 𝜖 to decide whether an input image is a face image. If 𝜖 is larger some value 𝜃, we say it is not a face image, otherwise we say yes.

 

A:  

                               

B:  

C:   Input  Image  

Projection  

To  get  a  more  precise  results  we  include  more  face  images  to  our  training  set.   Hence,  our  training  set  now  has  100  images  from  10  folders.  And  to  reduce  the   computational  complexity,  we  don’t  choose  all  the  99  eigenfaces  but  just  choose   first  50  of  them.  The  above  figure  shows  three  images  and  their  projections  onto   the  new  face  space  defined  by  50  eigenfaces.  The  relative  measures  of  distance   from  face  space  are  (a)  28.1,  (b)  52.7,  (c)  81.3.  Images  (a)  is  in  the  original   training  set.  Images  (b)  is  from  the  att_faces  but  not  in  the  original  training  set.   We  can  see  that  the  image  that  contains  face  has  a  closer  distance  from  the  face   space.  This  property  will  help  us  to  determine  the  which  image  contains  a   human  face.      

References   [1]    M. Turk and A. Pentland, “Eigenfaces for Recognition”, Journal of Cognitive Neuroscience, March 1991 [2] M. Turk and A. Pentland, “Face recognition using eigenfaces”, Conference of Computer Science and Pattern Recognition, June 1991