人脸识别算法是指什么

人脸识别算法是指在检测到人脸并定位面部关键特征点之后，主要的人脸区域就可以被裁剪出来，经过预处理之后，馈入后端的识别算法。识别算法要完成人脸特征的提取，并与库存的已知人脸进行比对，完成最终的分类。人脸识别算法的原理：系统输入一张或者一系列含有未确定身份的人脸图像，以及人脸数据库中的若干已知身份的人脸图象或者相应的编码，而其输出则是一系列相似度得分，表明待识别的人脸的身份。

本教程操作环境：windows7系统、Dell G3电脑。

人脸识别（Facial Recognition），就是通过视频采集设备获取用户的面部图像，再利用核心的算法对其脸部的五官位置、脸型和角度进行计算分析，进而和自身数据库里已有的范本进行比对，后判断出用户的真实身份。

人脸识别算法是指在检测到人脸并定位面部关键特征点之后，主要的人脸区域就可以被裁剪出来，经过预处理之后，馈入后端的识别算法。识别算法要完成人脸特征的提取，并与库存的已知人脸进行比对，完成最终的分类。

人脸识别的算法有 4 种：基于人脸特征点的识别算法、基于整幅 人脸图像的识别算法、基于模板的识别算法、利用神经网络进行识别的算法。

人脸识别算法的原理：

系统输入一般是一张或者一系列含有未确定身份的人脸图像，以及人脸数据库中的若干已知身份的人脸图象或者相应的编码，而其输出则是一系列相似度得分，表明待识别的人脸的身份。

人脸识别的三个经典算法

1、Eigenfaces（特征脸）算法        

        Eigenfaces是在人脸识别的计算机视觉问题中使用的一组特征向量的名称，Eigenfaces是基于PCA（主成分分析）的，所以学习Eigenfaces需要我们了解PCA的原理。

基本思想

        主成分分析（PCA）是一种矩阵的压缩算法，在减少矩阵维数的同时尽可能的保留原矩阵的信息，简单来说就是将 n×m的矩阵转换成n×k的矩阵，仅保留矩阵中所存在的主要特性，从而可以大大节省空间和数据量。PCA的实现需要进行降维，也就是将矩阵进行变换，从更高的维度降到低的维度，然而PCA的降维离不开协方差矩阵。方差是描述一维数据样本本身相对于均值的偏离程度，是一种用来度量两个随机变量关系的统计量，从角度来说，其夹角越小，值越大，方向越相近，也就是越正相关。协方差矩阵度量除了是两个随机变量的关系外，还是维度与维度之间的关系，而非样本与样本之间的关系。

        学习一种新的东西，尤其是知识，我们需要了解知识中的思想。我在了解和学习Eigenface算法时它的思想是图像识别首先要选择一个合适的子空间，将所有的图像集中到这个子空间中，然后在这个子空间中衡量相似性或者进行分类学习，再讲子空间变换到另一个空间中，这样的作用一是同一个类别的图像离得更近，二是不同的类别的图像会离得比较远；这样经过线性分类分开的图像在新空间就能容易分开。同时特征脸技术会寻找人脸图像分布的基本元素，即人脸图像样本集协方差矩阵的特征向量，以此来表征人脸图像。人脸图像的基本元素有很多，比如眼、面颊、唇等基本元素，这些特征向量在特征脸的图像空间中对应生成的子空间被称为子脸空间。
        生成了子空间之后就要进行空间构造，那么如何进行空间构造呢？首先要寻找人脸的共性，其次是要寻找个体与共性的差异，还有就是要明白共性其实是空间，个体就是向量。利用协方差矩阵把目标集中所有人脸图像的特征值进行分解，得到对应的特征向量，这些特征向量就是“特征脸”。寻找特征向量的特性，将其进行线性组合。在以每一个特征子脸为基的空间，每个人脸就是一个点，这个点的坐标就是每一个人脸在每个特征基下的的投影坐标。

Eigenfaces算法过程

•  获得人脸图像数据，将每一个人脸图像矩阵按行串成一维，每个人脸就是一个向量；

•  将M个人脸在对应维度上加起来，然后求平均得到“平均脸”；

•  将每个图像都减去平均脸向量；

•  计算协方差矩阵；

•  运用Eigenfaces记性人脸识别；

算法实践过程;

•  训练图像

•  求出平均脸

•  获得特征子脸

•  进行图像重构

•  寻找相似度高的人脸图像。

2、FisherFace算法

        FisherFace是Fisher线性判别在人脸识别的应用。线性判别分析（LDA）算法思想最早由英国统计与遗传学家，现代统计科学的奠基人之一罗纳德*费舍尔(Ronald)提出。LDA算法使用统计学方法，尝试找到物体间特征的一个线性组合，在降维的同时考虑类别信息。通过该算法得到的线性组合可以用来作为一个线性分类器或者实现降维。

基本思想

        线性判别分析的基本思想是：将高维的模式样本投影到低维最佳矢量空间，以达到抽取重要分类信息和压缩特征空间维度的效果，投影后保证模式样本在新的子空间有最大的类间距离、最小的类内距离，即模式在该空间中有最佳的可分离性。理论和特征脸里用到的Eigenfaces有相似之处，都是对原有数据进行整体降维映射到低维空间的方法，fisherfaces和Eigenfaces都是从数据整体入手而不同于LBP提取局部纹理特征。

        对降维后的样本使用Fisher线性判别方法，确定一个最优的投影方向，构造一个一维的体征空间，将多维的人脸图像投影到 fisherfaces特征空间，利用类内样本数据形成一组特征向量，这组特征向量就代表了人脸的特征。

        我们知道，该算法是在样本数据映射到另外一个特征空间后，将类内距离最小化，类间距离最大化。LDA算法可以用作降维，该算法的原理和PCA算法很相似，因此LDA算法也同样可以用在人脸识别领域。通过使用PCA算法来进行人脸识别的算法称为特征脸法，而使用LDA算法进行人脸识别的算法称为费舍尔脸法。

LDA和PCA相比：

• 相同：1、在降维的时候，两者都使用了矩阵的特征分解思想；2、两者都假设数据符合高斯分布。
• 不同：1、LDA是有监督的降维方法，而PCA是无监督的。2、如果说数据是k维的，那么LDA只能降到(k-1)维度，而PCA不受此限制。3、从数学角度来看，LDA选择分类性能最好的投影方向，而PCA选择样本投影点具有最大方差的方向。

Fisherfaces算法和Eigenfaces算法相比：

• 相同：两者均可以对数据进行降维；两者在降维时均使用了矩阵特征分解的思想。

• 不同：Fisherfaces是有监督的降维方法，而是Eigenfaces无监督的降维方法；Fisherfaces除了可以用于降维，还可以用于分类。

值得一提的是，FisherFace算法识别的错误率低于哈佛和耶鲁人脸数据库测试的Eigenfaces识别结果。

Fisherface算法流程 

•  获得人脸图像数据，然后求出人脸的均值。

• 观察各个人脸的特征值。

• 进行人脸鉴定，观察人脸特征，判断是否是个人。

• 最后进行人脸识别。

3、LBPH（Local Binary Patter Histogram）算法

        Local Binary Patterns Histograms即LBP特征的统计直方图，LBPH将LBP（局部二值编码）特征与图像的空间信息结合在一起。如果直接使用LBP编码图像用于人脸识别。其实和不提取LBP特征区别不大，因此在实际的LBP应用中，一般采用LBP编码图像的统计直方图作为特征向量进行分类识别。

        原始的LBP算子定义为在33的窗口内，以窗口中心像素为阈值，将相邻的8个像素的灰度值与其进行比较，若周围像素值大于或等于中心像素值，则该像素点的位置被标记为1，否则为0。这样，33邻域内的8个点经比较可产生8位二进制数（通常转换为十进制数即LBP码，共256种），即得到该窗口中心像素点的LBP值，并用这个值来反映该区域的纹理特征。

        LBPH的维度： 采样点为8个，如果用的是原始的LBP或Extended LBP特征，其LBP特征值的模式为256种，则一幅图像的LBP特征向量维度为：64256=16384维，而如果使用的UniformPatternLBP特征，其LBP值的模式为59种，其特征向量维度为：6459=3776维，可以看出，使用等价模式特征，其特征向量的维度大大减少，这意味着使用机器学习方法进行学习的时间将大大减少，而性能上没有受到很大影响。

基本思想

        建立在LBPH基础上的人脸识别法基本思想如下：首先以每个像素为中心，判断与周围像素灰度值大小关系，对其进行二进制编码，从而获得整幅图像的LBP编码图像；再将LBP图像分为个区域，获取每个区域的LBP编码直方图，继而得到整幅图像的LBP编码直方图，通过比较不同人脸图像LBP编码直方图达到人脸识别的目的，其优点是不会受到光照、缩放、旋转和平移的影响。

LBPH算法“人”如其名，采用的识别方法是局部特征提取的方法，这是与前两种方法的最大区别。

LBPH 算法流程

• LBP特征提取：根据上述的均匀LBP算子处理原始图像；

• LBP特征匹配（计算直方图）：将图像分为若干个的子区域，并在子区域内根据LBP值统计其直方图，以直方图作为其判别特征。

4、算法的复现代码

1）、EigenFaces算法

#encoding=utf-8
import numpy as np
import cv2
import os
 
class EigenFace(object):
    def __init__(self,threshold,dimNum,dsize):
        self.threshold = threshold # 阈值暂未使用
        self.dimNum = dimNum
        self.dsize = dsize
 
    def loadImg(self,fileName,dsize):
        '''
        载入图像，灰度化处理，统一尺寸，直方图均衡化
        :param fileName: 图像文件名
        :param dsize: 统一尺寸大小。元组形式
        :return: 图像矩阵
        '''
        img = cv2.imread(fileName)
        retImg = cv2.resize(img,dsize)
        retImg = cv2.cvtColor(retImg,cv2.COLOR_RGB2GRAY)
        retImg = cv2.equalizeHist(retImg)
        # cv2.imshow('img',retImg)
        # cv2.waitKey()
        return retImg
 
 
    def createImgMat(self,dirName):
        '''
        生成图像样本矩阵，组织形式为行为属性，列为样本
        :param dirName: 包含训练数据集的图像文件夹路径
        :return: 样本矩阵，标签矩阵
        '''
        dataMat = np.zeros((10,1))
        label = []
        for parent,dirnames,filenames in os.walk(dirName):
            # print parent
            # print dirnames
            # print filenames
            index = 0
            for dirname in dirnames:
                for subParent,subDirName,subFilenames in os.walk(parent+'/'+dirname):
                    for filename in subFilenames:
                        img = self.loadImg(subParent+'/'+filename,self.dsize)
                        tempImg = np.reshape(img,(-1,1))
                        if index == 0 :
                            dataMat = tempImg
                        else:
                            dataMat = np.column_stack((dataMat,tempImg))
                        label.append(subParent+'/'+filename)
                        index += 1
        return dataMat,label
 
 
    def PCA(self,dataMat,dimNum):
        '''
        PCA函数，用于数据降维
        :param dataMat: 样本矩阵
        :param dimNum: 降维后的目标维度
        :return: 降维后的样本矩阵和变换矩阵
        '''
        # 均值化矩阵
        meanMat = np.mat(np.mean(dataMat,1)).T
        print '平均值矩阵维度',meanMat.shape
        diffMat = dataMat-meanMat
        # 求协方差矩阵，由于样本维度远远大于样本数目，所以不直接求协方差矩阵，采用下面的方法
        covMat = (diffMat.T*diffMat)/float(diffMat.shape[1]) # 归一化
        #covMat2 = np.cov(dataMat,bias=True)
        #print '基本方法计算协方差矩阵为',covMat2
        print '协方差矩阵维度',covMat.shape
        eigVals, eigVects = np.linalg.eig(np.mat(covMat))
        print '特征向量维度',eigVects.shape
        print '特征值',eigVals
        eigVects = diffMat*eigVects
        eigValInd = np.argsort(eigVals)
        eigValInd = eigValInd[::-1]
        eigValInd = eigValInd[:dimNum] # 取出指定个数的前n大的特征值
        print '选取的特征值',eigValInd
        eigVects = eigVects/np.linalg.norm(eigVects,axis=0) #归一化特征向量
        redEigVects = eigVects[:,eigValInd]
        print '选取的特征向量',redEigVects.shape
        print '均值矩阵维度',diffMat.shape
        lowMat = redEigVects.T*diffMat
        print '低维矩阵维度',lowMat.shape
        return lowMat,redEigVects
 
    def compare(self,dataMat,testImg,label):
        '''
        比较函数，这里只是用了最简单的欧氏距离比较，还可以使用KNN等方法，如需修改修改此处即可
        :param dataMat: 样本矩阵
        :param testImg: 测试图像矩阵，最原始形式
        :param label: 标签矩阵
        :return: 与测试图片最相近的图像文件名
        '''
        testImg = cv2.resize(testImg,self.dsize)
        testImg = cv2.cvtColor(testImg,cv2.COLOR_RGB2GRAY)
        testImg = np.reshape(testImg,(-1,1))
        lowMat,redVects = self.PCA(dataMat,self.dimNum)
        testImg = redVects.T*testImg
        print '检测样本变换后的维度',testImg.shape
        disList = []
        testVec = np.reshape(testImg,(1,-1))
        for sample in lowMat.T:
            disList.append(np.linalg.norm(testVec-sample))
        print disList
        sortIndex = np.argsort(disList)
        return label[sortIndex[0]]
 
 
    def predict(self,dirName,testFileName):
        '''
        预测函数
        :param dirName: 包含训练数据集的文件夹路径
        :param testFileName: 测试图像文件名
        :return: 预测结果
        '''
        testImg = cv2.imread(testFileName)
        dataMat,label = self.createImgMat(dirName)
        print '加载图片标签',label
        ans = self.compare(dataMat,testImg,label)
        return ans
 
 
if __name__ == '__main__':
    eigenface = EigenFace(20,50,(50,50))
    print eigenface.predict('d:/face','D:/face_test/1.bmp')

2）、FisherFaces算法

#encoding=utf-8
import numpy as np
import cv2
import os
 
class FisherFace(object):
    def __init__(self,threshold,k,dsize):
        self.threshold = threshold # 阈值，暂未使用
        self.k = k         # 指定投影w的个数
        self.dsize = dsize # 统一尺寸大小
 
    def loadImg(self,fileName,dsize):
        '''
        载入图像，灰度化处理，统一尺寸，直方图均衡化
        :param fileName: 图像文件名
        :param dsize: 统一尺寸大小。元组形式
        :return: 图像矩阵
        '''
        img = cv2.imread(fileName)
        retImg = cv2.resize(img,dsize)
        retImg = cv2.cvtColor(retImg,cv2.COLOR_RGB2GRAY)
        retImg = cv2.equalizeHist(retImg)
        # cv2.imshow('img',retImg)
        # cv2.waitKey()
        return retImg
 
    def createImgMat(self,dirName):
        '''
        生成图像样本矩阵，组织形式为行为属性，列为样本
        :param dirName: 包含训练数据集的图像文件夹路径
        :return: 包含样本矩阵的列表，标签列表
        '''
        dataMat = np.zeros((10,1))
        label = []
        dataList = []
        for parent,dirnames,filenames in os.walk(dirName):
            # print parent
            # print dirnames
            # print filenames
            #index = 0
            for dirname in dirnames:
                for subParent,subDirName,subFilenames in os.walk(parent+'/'+dirname):
                    for index,filename in enumerate(subFilenames):
                        img = self.loadImg(subParent+'/'+filename,self.dsize)
                        tempImg = np.reshape(img,(-1,1))
                        if index == 0 :
                            dataMat = tempImg
                        else:
                            dataMat = np.column_stack((dataMat,tempImg))
                dataList.append(dataMat)
                label.append(subParent)
        return dataList,label
 
    def LDA(self,dataList,k):
        '''
        多分类问题的线性判别分析算法
        :param dataList: 样本矩阵列表
        :param k: 投影向量k的个数
        :return: 变换后的矩阵列表和变换矩阵
        '''
        n = dataList[0].shape[0]
        W = np.zeros((n,self.k))
        Sw = np.zeros((n,n))
        Sb = np.zeros((n,n))
        u = np.zeros((n,1))
        N = 0
        meanList = []
        sampleNum = []
 
        for dataMat in dataList:
            meanMat = np.mat(np.mean(dataMat,1)).T
            meanList.append(meanMat)
            sampleNum.append(dataMat.shape[1])
 
            dataMat = dataMat-meanMat
            sw = dataMat*dataMat.T
            Sw += sw
        print 'Sw的维度',Sw.shape
 
        for index,meanMat in enumerate(meanList):
            m = sampleNum[index]
            u += m*meanMat
            N += m
        u = u/N
        print 'u的维度',u.shape
 
        for index,meanMat in enumerate(meanList):
            m = sampleNum[index]
            sb = m*(meanMat-u)*(meanMat-u).T
            Sb += sb
        print 'Sb的维度',Sb.shape
 
        eigVals, eigVects = np.linalg.eig(np.mat(np.linalg.inv(Sw)*Sb))
        eigValInd = np.argsort(eigVals)
        eigValInd = eigValInd[::-1]
        eigValInd = eigValInd[:k] # 取出指定个数的前k大的特征值
        print '选取的特征值',eigValInd.shape
        eigVects = eigVects/np.linalg.norm(eigVects,axis=0) #归一化特征向量
        redEigVects = eigVects[:,eigValInd]
        print '变换矩阵维度',redEigVects.shape
 
        transMatList = []
        for dataMat in dataList:
            transMatList.append(redEigVects.T*dataMat)
        return transMatList,redEigVects
 
    def compare(self,dataList,testImg,label):
        '''
        比较函数，这里只是用了最简单的欧氏距离比较，还可以使用KNN等方法，如需修改修改此处即可
        :param dataList: 样本矩阵列表
        :param testImg: 测试图像矩阵，最原始形式
        :param label: 标签矩阵
        :return: 与测试图片最相近的图像文件夹，也就是类别
        '''
        testImg = cv2.resize(testImg,self.dsize)
        testImg = cv2.cvtColor(testImg,cv2.COLOR_RGB2GRAY)
        testImg = np.reshape(testImg,(-1,1))
        transMatList,redVects = fisherface.LDA(dataList,self.k)
        testImg = redVects.T*testImg
        print '检测样本变换后的维度',testImg.shape
        disList = []
        testVec = np.reshape(testImg,(1,-1))
        sumVec = np.mat(np.zeros((self.dsize[0]*self.dsize[1],1)))
        for transMat in transMatList:
            for sample in transMat.T:
                disList.append( np.linalg.norm(testVec-sample))
        print disList
        sortIndex = np.argsort(disList)
        return label[sortIndex[0]/9]
 
    def predict(self,dirName,testFileName):
        '''
        预测函数
        :param dirName: 包含训练数据集的文件夹路径
        :param testFileName: 测试图像文件名
        :return: 预测结果
        '''
        testImg = cv2.imread(testFileName)
        dataMat,label = self.createImgMat(dirName)
        print '加载图片标签',label
        ans = self.compare(dataMat,testImg,label)
        return ans
 
if __name__=="__main__":
   
    fisherface = FisherFace(10,20,(20,20))
    ans = fisherface.predict('d:/face','d:/face_test/8.bmp')
    print ans

3）、LBPH算法

#encoding=utf-8
import numpy as np
import os
import cv2
 
class LBP(object):
    def __init__(self,threshold,dsize,blockNum):
        self.dsize = dsize # 统一尺寸大小
        self.blockNum = blockNum # 分割块数目
        self.threshold = threshold # 阈值，暂未使用
 
    def loadImg(self,fileName,dsize):
        '''
        载入图像，灰度化处理，统一尺寸，直方图均衡化
        :param fileName: 图像文件名
        :param dsize: 统一尺寸大小。元组形式
        :return: 图像矩阵
        '''
        img = cv2.imread(fileName)
        retImg = cv2.resize(img,dsize)
        retImg = cv2.cvtColor(retImg,cv2.COLOR_RGB2GRAY)
        retImg = cv2.equalizeHist(retImg)
        # cv2.imshow('img',retImg)
        # cv2.waitKey()
        return retImg
 
    def loadImagesList(self,dirName):
        '''
        加载图像矩阵列表
        :param dirName:文件夹路径
        :return: 包含最原始的图像矩阵的列表和标签矩阵
        '''
        imgList = []
        label = []
        for parent,dirnames,filenames in os.walk(dirName):
            # print parent
            # print dirnames
            # print filenames
            for dirname in dirnames:
                for subParent,subDirName,subFilenames in os.walk(parent+'/'+dirname):
                    for filename in subFilenames:
                        img = self.loadImg(subParent+'/'+filename,self.dsize)
                        imgList.append(img) # 原始图像矩阵不做任何处理，直接加入列表
                        label.append(subParent+'/'+filename)
        return imgList,label
 
 
    def getHopCounter(self,num):
        '''
        计算二进制序列是否只变化两次
        :param num: 数字
        :return: 01变化次数
        '''
        binNum = bin(num)
        binStr = str(binNum)[2:]
        n = len(binStr)
        if n < 8:
            binStr = "0"*(8-n)+binStr
        n = len(binStr)
        counter = 0
        for i in range(n):
            if i != n-1:
                if binStr[i+1] != binStr[i]:
                    counter += 1
            else:
                if binStr[0] != binStr[i]:
                    counter += 1
        return counter
 
    def createTable(self):
        &#39;&#39;&#39;
        生成均匀对应字典
        :return: 均匀LBP特征对应字典
        &#39;&#39;&#39;
        self.table = {}
        temp = 1
        print type(temp)
        for i in range(256):
            if self.getHopCounter(i) <= 2:
                self.table[i] = temp
                temp += 1
            else:
                self.table[i] = 0
        return self.table
 
    def getLBPfeature(self,img):
        &#39;&#39;&#39;
        计算LBP特征
        :param img:图像矩阵
        :return: LBP特征图
        &#39;&#39;&#39;
        m = img.shape[0];n = img.shape[1]
        neighbor = [0]*8
        featureMap = np.mat(np.zeros((m,n)))
        for y in xrange(1,m-1):
            for x in xrange(1,n-1):
                neighbor[0] = img[y-1,x-1]
                neighbor[1] = img[y-1,x]
                neighbor[2] = img[y-1,x+1]
                neighbor[3] = img[y,x+1]
                neighbor[4] = img[y+1,x+1]
                neighbor[5] = img[y+1,x]
                neighbor[6] = img[y+1,x-1]
                neighbor[7] = img[y,x-1]
                center = img[y,x]
                temp = 0
                for k in range(8):
                    temp += (neighbor[k] >= center)*(1<<k)
                featureMap[y,x] = self.table[temp]
        featureMap = featureMap.astype('uint8') # 数据类型转换为无符号8位型，如不转换则默认为float64位，影响最终效果
        return featureMap
 
    def calcHist(self,roi):
        '''
        计算直方图
        :param roi:图像区域
        :return: 直方图矩阵
        '''
        hist = cv2.calcHist([roi],[0],None,[59],[0,256]) # 第四个参数是直方图的横坐标数目，经过均匀化降维后这里一共有59种像素
        return hist
 
    def compare(self,sampleImg,testImg):
        '''
        比较函数，这里使用的是欧氏距离排序，也可以使用KNN，在此处更改
        :param sampleImg: 样本图像矩阵
        :param testImg: 测试图像矩阵
        :return: k2值
        '''
        testImg = cv2.resize(testImg,self.dsize)
        testImg = cv2.cvtColor(testImg,cv2.COLOR_RGB2GRAY)
        testFeatureMap = self.getLBPfeature(testImg)
        sampleFeatureMap = self.getLBPfeature(sampleImg)
        # 计算步长，分割整个图像为小块
        ystep = self.dsize[0]/self.blockNum
        xstep = self.dsize[1]/self.blockNum
        k2 = 0
        for y in xrange(0,self.dsize[0],ystep):
            for x in xrange(0,self.dsize[1],xstep):
                testroi = testFeatureMap[y:y+ystep,x:x+xstep]
                sampleroi =sampleFeatureMap[y:y+ystep,x:x+xstep]
                testHist = self.calcHist(testroi)
                sampleHist = self.calcHist(sampleroi)
                k2 += np.sum((sampleHist-testHist)**2)/np.sum((sampleHist+testHist))
        print 'k2的值为',k2
        return k2
 
    def predict(self,dirName,testImgName):
        '''
        预测函数
        :param dirName:样本图像文件夹路径
        :param testImgName: 测试图像文件名
        :return: 最相近图像名称
        '''
        table = self.createTable()
        testImg = cv2.imread(testImgName)
        imgList,label = self.loadImagesList(dirName)
        k2List = []
        for img in imgList:
            k2 = self.compare(img,testImg)
            k2List.append(k2)
        order = np.argsort(k2List)
        return label[order[0]]
 
if __name__ == "__main__":
 
    lbp = LBP(20,(50,50),5)
    ans = lbp.predict('d:/face','d:/face_test/9.bmp')
    print ans

扩展知识：人脸识别算法研究的难点

人脸识别算法研究已久，在背景简单的情形下，大部分算法都能很好的处理。但是，人脸识别的应用范围颇广，仅是简单图像测试，是远远不能满足现实需求的。所以人脸识别算法还是存在很多的难点。

光照

光照问题是机器视觉中的老问题，在人脸识别中的表现尤为明显，算法未能达到使用的程度。

姿态

与光照问题类似，姿态问题也是人脸识别研究中需要解决的一个技术难点。针对姿态的研究相对比较少，多数的人脸识别算法主要是针对正面，或接近正面的人脸图像，当发生俯仰或者左右侧而比较厉害的情况下，人脸识别算法的识别率也将会急剧下降。

遮挡

对于非配合情况下的人脸图像采集，遮挡问题是一个非常严重的问题，特别是在监控环境下，往往被监控对象都会带着眼镜﹑帽子等饰物，使得被采集出来的人脸图像有可能不完整，从而影响了后面的特征提取与识别，甚至会导致人脸识别算法的失效。

年龄变化

随着年龄的变化，面部外观也在变化，特别是对于青少年，这种变化更加的明显。对于不同的年龄段，人脸识别算法的识别率也不同。

图像质量

人脸图像的来源可能多种多样，由于采集设备的不同，得到的人脸图像质量也不同，特别是对于那些低分辨率﹑噪声大﹑质量差的人脸图像如何进行有效的人脸识别是个需要关注的问题。同样的，对于高分辨图像，对人脸识别算法的影响也需要进一步研究。

样本缺乏

基于统计学习的人脸识别算法是人脸识别领域中的主流算法，但是统计学习方法需要大量的培训。由于人脸图像在高维空间中的分布是一个不规则的流行分布，能得到的样本只是对人脸图像空间中的一个极小部分的采样，如何解决小样本下的统计学习问题有待进一步的研究。

大量数据

传统人脸识别算法如PCA、LDA等在小规模数据中可以很容易进行训练学习。但是对于大量数据，这些方法其训练过程难以进行，甚至有可能崩溃。

大规模人脸识别

随着人脸数据库规模的增长，人脸算法的性能将呈现下降。

更多相关知识，请访问常见问题栏目！

以上是人脸识别算法是指什么的详细内容。更多信息请关注PHP中文网其他相关文章！