Eigenface与PCA人脸识别算法实验

简单的特征脸识别实验

---

实现特征脸的过程其实就是主成分分析（Principal Component Analysis，PCA）的一个过程。关于PCA的原理问题，它是一种数学降维的方法。是为了简化问题。在二维的坐标空间内，找到一个单位向量U，使得所有数据在U上的投影之和最大。这样就能把数据分的尽可能的开。然后把训练样本投影到这个向量U上，把测试图片也投影上去，计算这个投影与各个样本人脸投影的欧式距离，得出最小的欧式距离的的那个样本编号，就是最大概率的人脸。

Eigenface算法

---

特征脸方法(Eigenface)是一个经典算法的人脸识别算法。特征脸方法是从PCA导出的一种人脸识别和描述技术。就是将包含人脸的图像区域看作是一种随机向量，因此可以采用K-L变换获得其正交K-L基底。对应其中较大特征值的基底具有与人脸相似的形状，因此又称为特征脸。利用这些基底的线性组合可以描述、表达和逼近人脸图像，因此可以进行人脸识别与合成。识别过程就是将人脸图像映射到由特征脸构成的子空间上，比较其与己知人脸在特征空间中的位置，具体步骤如下：

(1) 初始化，获得人脸图像的训练集并计算特征脸，定义为人脸空间，存储在模板库中，以便系统进行识别；这里使用Yalefaces数据库。这里面有15个人，每个人的文件夹中取一张正常状态的图像，size为（98，116），并用flatten()把该图像转换成一维向量。15张这样的图组成一个（8100，15）的矩阵；

(2) 对每一行求均值，得到一个（11368，1）的向量avgImg，这个图像就是平均脸；

(3) 将图像矩阵与平均脸相减，得到偏差值diffTrain，用偏差值计算协方差，协方差矩阵C= XX^T；

(4) 这里需要做一个变换，因为C算出来为都会非常大，可以改为计算C’，设C’ = X^TX，设这里算出的特征向量为E’，XE’= E，这里E就是原本该C得到的特征向量。然后把E归一化。

人脸识别

---

这里得到了15个特征脸之后，考虑选择出主成分。这里取特征向量超过特征向量均值的80%的几个特征向量，假设是K个，这K个特征向量组成的矩阵设为w。将偏差矩阵转置乘以w，得到协方差矩阵的特征向量。

(1) 输入新的人脸图像，转换成一维向量，将其映射到特征脸空间，得到一组关于该人脸的特征数据；

(2) 通过检查图像与人脸空间的距离判断它是否是人脸；

(3) 若为人脸，根据权值模式判断它是否为数据库中的某个人，并做出具体的操作。

代码如下：

import numpy as np

from numpy import *

from numpy import linalg as la

from PIL import Image

import glob

from matplotlib import pyplot as plt

def loadImageSet(add):

 filenames = glob.glob('face/pgm/*.pgm')

 filenames.sort()

 img = [Image.open(fn).convert('L').resize((98, 116)) for fn in filenames]

 FaceMat = np.asarray([np.array(im).flatten() for im in img])

 return FaceMat

def ReconginitionVector(selecthr = 0.8):

 # step1: load the face image data ,get the matrix consists of all image

 FaceMat = loadImageSet('face/yalefaces/')

 print('-----------FaceMat.shape--------')

 print(FaceMat.shape)

 # step2: average the FaceMat

 avgImg = mean(FaceMat,0)

 # step3: calculate the difference of avgimg and all image data(FaceMat)

 diffTrain = FaceMat-avgImg

 covMat =np.asmatrix(diffTrain) * np.asmatrix(diffTrain.T)

 eigvals,eigVects = linalg.eig(covMat) #la.linalg.eig(np.mat(covMat))

 #step4: calculate eigenvector of covariance matrix (because covariance matrix will cause memory error)

 eigSortIndex = argsort(-eigvals)

 for i in range(shape(FaceMat)[1]):

 if (eigvals[eigSortIndex[:i]]/eigvals.sum()).sum() >= selecthr:

 eigSortIndex = eigSortIndex[:i]

 break

 covVects = diffTrain.T * eigVects[:,eigSortIndex] # covVects is the eigenvector of covariance matrix

 # avgImg 是均值图像，covVects是协方差矩阵的特征向量，diffTrain是偏差矩阵

 return avgImg,covVects,diffTrain

def judgeFace(judgeImg,FaceVector,avgImg,diffTrain):

 diff = judgeImg - avgImg

 weiVec = FaceVector.T* diff.T

 res = 0

 resVal = inf

#==============================================================================

# plt.imshow(avgImg.reshape(98,116))

# plt.show()

#==============================================================================

 for i in range(15):

 TrainVec = (diffTrain[i]*FaceVector).T

 if (array(weiVec-TrainVec)**2).sum() < resVal:

 res = i

 resVal = (array(weiVec-TrainVec)**2).sum()

 return res+1

if __name__ == '__main__':

 avgImg,FaceVector,diffTrain = ReconginitionVector(selecthr = 0.8)

 nameList = ['01','02','03','04','05','06','07','08','09','10','11','12','13','14','15']

 characteristic = ['centerlight','glasses','happy','leftlight','noglasses','rightlight','sad','sleepy','surprised','wink']

 for c in characteristic:

 count = 0

 for i in range(len(nameList)):

 # 这里的loadname就是我们要识别的未知人脸图，我们通过15张未知人脸找出的对应训练人脸进行对比来求出正确率

 loadname = 'face/yalefaces/subject'+nameList[i]+'.'+c+'.pgm'

 judgeImg = Image.open(loadname).convert('L').resize((98, 116))

 #print(loadname)

 if judgeFace(mat(judgeImg).flatten(),FaceVector,avgImg,diffTrain) == int(nameList[i]):

 count += 1

print('accuracy of %s is %f'%(c, float(count)/len(nameList))) # 求出正确率

运行结果：

accuracy of centerlight is 0.400000

accuracy of glasses is 0.533333

accuracy of happy is 0.866667

accuracy of leftlight is 0.133333

accuracy of noglasses is 0.800000

accuracy of rightlight is 0.133333

accuracy of sad is 0.800000

accuracy of sleepy is 0.800000

accuracy of surprised is 0.666667

accuracy of wink is 0.600000