Que signifie l’algorithme de reconnaissance faciale ?

L'algorithme de reconnaissance faciale signifie qu'après avoir détecté le visage et localisé les points clés des caractéristiques du visage, la zone principale du visage peut être recadrée et, après prétraitement, elle est introduite dans l'algorithme de reconnaissance principal. L’algorithme de reconnaissance doit compléter l’extraction des traits du visage et les comparer avec les visages connus dans l’inventaire pour compléter le classement final. Le principe de l'algorithme de reconnaissance faciale : le système saisit une ou une série d'images de visages avec des identités indéterminées, ainsi que plusieurs images de visages avec des identités connues ou des codes correspondants dans la base de données de visages, et sa sortie est une série de Le score de similarité indique l'identité du visage à reconnaître.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ordinateur Dell G3.

La reconnaissance faciale consiste à obtenir l'image du visage de l'utilisateur via un appareil de collecte vidéo, puis à utiliser l'algorithme de base pour calculer et analyser la position, la forme et l'angle des traits du visage, puis à la comparer avec les modèles existants dans sa propre base de données. Comparez et déterminez la véritable identité de l'utilisateur.

L'algorithme de reconnaissance faciale signifie qu'après avoir détecté le visage et localisé les points clés des caractéristiques du visage, la zone principale du visage peut être recadrée et, après prétraitement, elle est introduite dans l'algorithme de reconnaissance principal. L’algorithme de reconnaissance doit compléter l’extraction des traits du visage et les comparer avec les visages connus dans l’inventaire pour compléter le classement final.

Il existe 4 types d'algorithmes de reconnaissance faciale : les algorithmes de reconnaissance basés sur les points caractéristiques du visage, les algorithmes de reconnaissance basés sur l'image entière du visage, les algorithmes de reconnaissance basés sur des modèles et les algorithmes de reconnaissance utilisant des réseaux de neurones.

Principe de l'algorithme de reconnaissance faciale :

L'entrée du système est généralement une ou une série d'images de visages avec des identités non identifiées, ainsi que plusieurs images de visages avec des identités connues dans la base de données de visages ou un encodage correspondant, et sa sortie est une série de scores de similarité indiquant l'identité du visage à reconnaître.的 Trois algorithmes classiques de reconnaissance faciale

1, l'algorithme EigenFaces

eigenFaces
est un ensemble de vecteurs de fonctionnalités utilisés dans les problèmes visuels informatiques de reconnaissance faciale. Le nom, Eigenfaces est basé sur PCA (Principal Component Analysis), donc l’apprentissage des Eigenfaces nous oblige à comprendre le principe de l’ACP.

Idée de base

                                                         . . La mise en œuvre de l'ACP nécessite une réduction de dimensionnalité, c'est-à-dire la transformation de la matrice d'une dimension supérieure à une dimension inférieure. Cependant, la réduction de dimensionnalité de l'ACP est indissociable de la matrice de covariance. La variance décrit l'écart d'un échantillon de données unidimensionnel par rapport à la moyenne. Il s'agit d'une statistique utilisée pour mesurer la relation entre deux variables aléatoires. D'un point de vue, plus l'angle est petit, plus la valeur est grande et plus la direction est similaire. Autrement dit, plus la corrélation est positive. En plus de la relation entre deux variables aléatoires, la mesure de la matrice de covariance est également la relation entre les dimensions, et non la relation entre les échantillons.

Pour apprendre une nouvelle chose, en particulier des connaissances, nous devons comprendre les idées contenues dans la

connaissance. Lorsque je comprends et apprends l'algorithme Eigenface, son idée est que la reconnaissance d'images doit d'abord sélectionner un sous-espace approprié, concentrer toutes les images dans ce sous-espace, puis mesurer la similarité ou effectuer un apprentissage de classification dans ce sous-espace. Le sous-espace est transformé en un autre espace. Cela a pour effet que les images de la même catégorie sont plus proches et les images de différentes catégories sont plus éloignées les unes des autres. De cette manière, les images séparées par une classification linéaire peuvent être facilement transformées dans le nouvel espace séparé. Dans le même temps, la technologie des visages propres recherchera les éléments de base de la distribution des images du visage, c'est-à-dire les vecteurs propres de la matrice de covariance de l'ensemble d'échantillons d'images du visage, pour caractériser l'image du visage. Il existe de nombreux éléments de base des images de visage humain, tels que les yeux, les joues, les lèvres et d'autres éléments de base. Le sous-espace généré en conséquence par ces vecteurs de caractéristiques dans l'espace d'image du visage propre est appelé espace sous-face

. ?                                                                                           étant que le sous-espace a été généré pour être transformé en un espace, alors comment construire l'espace ? Premièrement, nous devons rechercher les points communs dans les visages humains, deuxièmement, nous devons rechercher les différences entre les individus et les points communs, et troisièmement, nous devons comprendre que les points communs sont en réalité des espaces et que les individus sont des vecteurs. Utilisez la matrice de covariance pour décomposer les valeurs propres de toutes les images de visage dans l'ensemble cible afin d'obtenir les vecteurs propres correspondants. Ces vecteurs propres sont des "

faces propres". Trouvez les caractéristiques des vecteurs propres et combinez-les linéairement. Dans l'espace basé sur chaque sous-face caractéristique, chaque face est un point, et les coordonnées de ce point sont les coordonnées de projection de chaque face sous chaque base caractéristique. Processus d'algorithme Eigenfaces

Obtenez des données d'image de visage, enchaînez chaque matrice d'image de visage en une dimension par lignes, et chaque visage est un vecteur  ;

Ajoutez M faces dans les dimensions correspondantes, puis faites la moyenne pour obtenir le "visage moyen" ;

Soustrayez le vecteur de visage moyen de chaque image ;

Calculez la matrice de covariance ; reconnaissance faciale en mémoire ;

processus de pratique d'algorithme ;

images d'entraînement

• Trouver le visage moyen

• Obtenir une sous-face caractéristique

• pour la reconstruction d'image

• Trouvez des images de visage avec grande similarité. Er2, algorithme Fisherface

• Fisherface est une application pour le jugement linéaire de Fisher dans la reconnaissance des visages humains. L'idée de l'algorithme d'analyse discriminante linéaire (

  LDA) a été proposée pour la première fois par Ronald Fisher (Ronald), statisticien et généticien britannique et l'un des fondateurs de la science statistique moderne. L'algorithme LDA utilise des méthodes statistiques pour tenter de trouver une combinaison linéaire de caractéristiques entre les objets et prendre en compte les informations de catégorie tout en réduisant la dimensionnalité. La combinaison linéaire obtenue par cet algorithme peut être utilisée comme classificateur linéaire ou pour réaliser une réduction de dimensionnalité.

Idée de base L'

idée de base

de l'analyse discriminante linéaire est la suivante : projeter des échantillons de motifs de haute dimension dans un espace vectoriel optimal de basse dimension pour obtenir l'effet d'extraire des informations de classification importantes et de compresser la dimension de l'espace des caractéristiques. . Projection Enfin, il est garanti que l'échantillon de motif a la distance inter-classe maximale et la distance intra-classe minimale dans le nouveau sous-espace, c'est-à-dire que le motif a la meilleure séparabilité dans cet espace. La théorie est similaire aux faces propres utilisées dans les faces propres. Ce sont deux méthodes de réduction de dimensionnalité globale et de mappage des données originales sur un espace de faible dimension. Les faces de pêche et les faces propres partent des données globales et sont différentes de LBP dans l'extraction de la texture locale. caractéristiques.

                                                                                                                                                                                                                                                  Utilisez la méthode discriminante linéaire de Fisher pour déterminer une direction de projection optimale, construisez un espace de signe unidimensionnel, projetez l'image du visage multidimensionnelle dans l'espace de caractéristiques des visages de pêcheur et utilisez des échantillons de données intra-classe pour former un vecteur de caractéristiques. un ensemble de vecteurs de caractéristiques représente les caractéristiques du visage.

Nous savons que cet algorithme minimise la distance intra-classe et maximise la distance inter-classe une fois que les exemples de données sont mappés vers un autre espace de fonctionnalités. L'algorithme LDA peut être utilisé pour la réduction de dimensionnalité. Le principe de cet algorithme est très similaire à l'algorithme PCA, l'algorithme LDA peut donc également être utilisé dans le domaine de la reconnaissance faciale. L'algorithme de reconnaissance faciale utilisant l'algorithme PCA est appelé méthode Eigenface, tandis que l'algorithme de reconnaissance faciale utilisant l'algorithme LDA est appelé méthode Fisher Face.

LDA et PCA sont comparées :

sont identiques : 1. Lors de la réduction des dimensions, les deux utilisent l'idée de​​décomposition caractéristique des matrices 2. Les deux supposent que les données sont conformes à la distribution gaussienne ; .

Différences : 1. LDA est une méthode de réduction de dimensionnalité supervisée, tandis que PCA est non supervisée. 2. Si les données sont à k dimensions, alors LDA ne peut être réduit qu'à (k-1) dimensions, mais PCA n'est pas soumis à cette restriction. 3. D'un point de vue mathématique, LDA sélectionne la direction de projection avec les meilleures performances de classification, tandis que PCA sélectionne la direction avec la variance maximale des points de projection de l'échantillon. Par rapport à l'

Algorithme Fisherfaces et à l'Algorithme Eigenfaces

:

• sont les mêmes : les deux peuvent réduire la dimensionnalité des données ;

Différence : Fisherfaces est une méthode de réduction de dimensionnalité supervisée, mais Eigenfaces est une méthode de réduction de dimensionnalité non supervisée ; Fisherfaces peut non seulement être utilisée pour la réduction de dimensionnalité, mais également pour la classification.

Il convient de mentionner que le taux d'erreur de reconnaissance de l'algorithme FisherFace est inférieur aux résultats de reconnaissance Eigenfaces testés sur les bases de données faciales de Harvard et Yale.

• Processus de l'algorithme Fisherface

• Obtenez des données d'image de visage, puis trouvez la valeur moyenne du visage.

Observez les valeurs caractéristiques de chaque visage.

Effectuez une identification du visage, observez les traits du visage et déterminez s'il s'agit d'un individu.

• Effectuez enfin la reconnaissance faciale.
• 3. Algorithme LBPH (Local Binary Patter Histogram)

• Les histogrammes de modèles binaires locaux sont les histogrammes statistiques des fonctionnalités LBP

  LBPH

  combine les fonctionnalités
LBP

(codage binaire local) avec l'espace du. Les informations sur l'image sont combinées. Si vous utilisez des images codées LBP directement pour la reconnaissance faciale. En fait, il n'y a pas beaucoup de différence avec le fait de ne pas extraire les caractéristiques LBP. Par conséquent, dans les applications LBP réelles, l'histogramme statistique de l'image codée LBP est généralement utilisé comme vecteur de caractéristiques pour la classification et la reconnaissance.

算 L'opérateur LBP d'origine est défini comme une fenêtre de 33. En prenant le pixel central comme seuil, comparez la valeur de cendre des 8 pixels adjacents avec celui-ci. La position du point est marquée comme 1, sinon elle est 0. De cette façon, 8 points dans le voisinage 33 peuvent être comparés pour produire un nombre binaire de 8 bits (généralement converti en nombre décimal, c'est-à-dire un code LBP, 256 types au total), c'est-à-dire la valeur LBP du pixel. au centre de la fenêtre est obtenue et cette valeur est utilisée pour refléter les caractéristiques de la texture de la zone.

   Dimensions de LBPH : il y a 8 points d'échantillonnage. Si la fonctionnalité LBP d'origine ou LBP étendue est utilisée, le mode de valeur de la caractéristique LBP est 256, alors la dimension vectorielle de la caractéristique LBP d'une image est : 64256 = 16384 dimensions, si le modèle uniforme LBP est utilisé. La caractéristique est utilisée, le modèle de valeur LBP est de 59 et la dimension du vecteur de caractéristique est : 6459 = 3776 dimensions. On peut voir qu'en utilisant la caractéristique de modèle équivalente, la dimension du vecteur de caractéristique est considérablement réduite, ce qui signifie que la machine Le temps d'apprentissage. de la méthode d’apprentissage sera considérablement réduite sans affecter grandement les performances.

Idée de base

       L'idée de base

de la méthode de reconnaissance faciale basée sur LBPH est la suivante : tout d'abord, prenez chaque pixel comme centre, déterminez la relation avec la valeur de gris des pixels environnants et effectuez un codage binaire sur pour obtenir une image codée LBP de l'image entière ; puis divisez l'image LBP en régions, obtenez l'histogramme codé LBP de chaque région, puis obtenez l'histogramme codé LBP de l'image entière en comparant les histogrammes codés LBP de différentes images de visage. , le visage humain peut être obtenu Aux fins de la reconnaissance faciale, son avantage est qu'il ne sera pas affecté par l'éclairage, la mise à l'échelle, la rotation et la translation. L'algorithme LBPH « people » est comme son nom l'indique la méthode d'identification utilisée est la méthode d'extraction de caractéristiques locales. C'est la plus grande différence par rapport aux deux premières méthodes.

Flux d'algorithme LBP

Extraction des caractéristiques LBP : traitez l'image originale selon l'opérateur LBP uniforme ci-dessus 
Correspondance des caractéristiques LBP (calculer l'histogramme) : divisez l'image en plusieurs sous-régions, et Le L'histogramme est calculé sur la base de la valeur LBP dans la sous-région et l'histogramme est utilisé comme caractéristique discriminante.

4. Code de réplication de l'algorithme 1), algorithme 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), algorithme 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), algorithme 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

Connaissances approfondies : algorithme de reconnaissance faciale. Difficultés dans la recherche Les algorithmes de reconnaissance faciale sont étudiés depuis longtemps. La plupart des algorithmes peuvent bien le gérer lorsque l'arrière-plan est simple. Cependant, la reconnaissance faciale a un large éventail d’applications et les simples tests d’images sont loin de répondre aux besoins pratiques. Par conséquent, l’algorithme de reconnaissance faciale présente encore de nombreuses difficultés.

Éclairage

Le problème de l'éclairage est un vieux problème en vision industrielle, et il est particulièrement évident en reconnaissance faciale. L'algorithme n'a pas atteint le niveau d'utilisation.

Posture

Semblable au problème d'éclairage, le problème de posture est également une difficulté technique qui doit être résolue dans la recherche sur la reconnaissance faciale. Il existe relativement peu d'études sur la posture. La plupart des algorithmes de reconnaissance faciale visent principalement les images de visage frontal ou proche du front. Lorsque des changements de hauteur ou de gauche à droite se produisent, le taux de reconnaissance de l'algorithme de reconnaissance faciale diminue également fortement. .

Occlusion

Pour la collecte d'images de visage sans coopération, le problème d'occlusion est un problème très grave, en particulier dans un environnement de surveillance, où les sujets surveillés portent souvent des lunettes, des chapeaux et d'autres accessoires, ce qui rend difficile la collecte d'images. L'image du visage résultante peut être incomplète, ce qui affecte l'extraction et la reconnaissance ultérieures des caractéristiques, et peut même entraîner l'échec de l'algorithme de reconnaissance faciale.

Changements d'âge

À mesure que l'âge change, l'apparence du visage change également, en particulier pour les adolescents, ce changement est plus évident. Pour différents groupes d'âge, les taux de reconnaissance des algorithmes de reconnaissance faciale sont également différents.

Qualité de l'image

Les images de visage peuvent provenir de diverses sources. En raison des différents équipements de collecte, la qualité des images de visage obtenues est également différente, en particulier pour les images de visage à faible résolution, à bruit élevé et de mauvaise qualité. effectuer une reconnaissance faciale efficace est un problème qui nécessite une attention particulière. De même, pour les images haute résolution, l’impact sur les algorithmes de reconnaissance faciale nécessite également une étude plus approfondie.

Manque d'échantillons

L'algorithme de reconnaissance faciale basé sur l'apprentissage statistique est l'algorithme dominant dans le domaine de la reconnaissance faciale, mais les méthodes d'apprentissage statistique nécessitent beaucoup de formation. Étant donné que la distribution des images de visage dans un espace de grande dimension est une distribution populaire irrégulière, les échantillons qui peuvent être obtenus n'échantillonnent qu'une très petite partie de l'espace des images de visage. La manière de résoudre le problème d'apprentissage statistique sous de petits échantillons nécessite des recherches plus approfondies. .

Une grande quantité de données

Les algorithmes de reconnaissance faciale traditionnels tels que PCA, LDA, etc. peuvent être facilement formés et appris à partir de données à petite échelle. Cependant, pour de grandes quantités de données, le processus de formation de ces méthodes est difficile et peut même s'effondrer.

Reconnaissance faciale à grande échelle

À mesure que la taille de la base de données des visages augmente, les performances de l'algorithme du visage diminueront.

Pour plus de connaissances connexes, veuillez visiter la rubrique FAQ !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!