Was bedeutet Gesichtserkennungsalgorithmus?

Der Gesichtserkennungsalgorithmus bedeutet, dass nach der Erkennung des Gesichts und der Lokalisierung der wichtigsten Gesichtsmerkmalspunkte der Hauptgesichtsbereich ausgeschnitten werden kann und nach der Vorverarbeitung in den Back-End-Erkennungsalgorithmus eingespeist wird. Der Erkennungsalgorithmus muss die Gesichtsmerkmale extrahieren und sie mit bekannten Gesichtern im Inventar vergleichen, um die endgültige Klassifizierung abzuschließen. Das Prinzip des Gesichtserkennungsalgorithmus: Das System gibt ein oder eine Reihe von Gesichtsbildern mit unbestimmter Identität sowie mehrere Gesichtsbilder mit bekannter Identität oder entsprechenden Codes in die Gesichtsdatenbank ein und gibt als Ausgabe eine Reihe von Gesichtsbildern mit einer Ähnlichkeitsbewertung aus die Identität des zu erkennenden Gesichts.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, Dell G3-Computer.

Gesichtserkennung besteht darin, das Gesichtsbild des Benutzers über ein Videoerfassungsgerät zu erhalten und dann den Kernalgorithmus zu verwenden, um die Position, Form und den Winkel der Gesichtsmerkmale zu berechnen und zu analysieren und es dann mit den vorhandenen Vorlagen in seiner eigenen Datenbank zu vergleichen Vergleichen und ermitteln Sie die wahre Identität des Benutzers.

Der Gesichtserkennungsalgorithmus bedeutet, dass nach der Erkennung des Gesichts und der Lokalisierung der wichtigsten Gesichtsmerkmalspunkte der Hauptgesichtsbereich ausgeschnitten werden kann und nach der Vorverarbeitung in den Back-End-Erkennungsalgorithmus eingespeist wird. Der Erkennungsalgorithmus muss die Gesichtsmerkmale extrahieren und sie mit bekannten Gesichtern im Inventar vergleichen, um die endgültige Klassifizierung abzuschließen.

Es gibt 4 Arten von Gesichtserkennungsalgorithmen: Erkennungsalgorithmen, die auf Gesichtsmerkmalspunkten basieren, Erkennungsalgorithmen, die auf dem gesamten Gesichtsbild basieren, vorlagenbasierte Erkennungsalgorithmen und Erkennungsalgorithmen, die neuronale Netze verwenden.

Prinzip des Gesichtserkennungsalgorithmus:

Die Systemeingabe besteht im Allgemeinen aus einem oder mehreren Gesichtsbildern mit nicht identifizierter Identität sowie mehreren Gesichtsbildern mit bekannten Identitäten in der Gesichtsdatenbank oder entsprechender Codierung, und die Ausgabe erfolgt eine Reihe von Ähnlichkeitswerten, die die Identität des zu erkennenden Gesichts angeben.的 Drei klassische Algorithmen zur Gesichtserkennung

1. Eigenfaces-Algorithmus

eigenFaces
ist eine Reihe von Merkmalsvektoren, die bei computervisuellen Problemen der Gesichtserkennung verwendet werden. Der Name Eigenfaces basiert auf PCA (Principal Component Analyse), daher erfordert das Erlernen von Eigenfaces, dass wir das Prinzip von PCA verstehen.

Grundidee

                                                         . Die Implementierung von PCA erfordert eine Dimensionsreduktion, das heißt die Transformation der Matrix von einer höheren Dimension in eine niedrigere Dimension. Die Dimensionsreduktion von PCA ist jedoch untrennbar mit der Kovarianzmatrix verbunden. Varianz beschreibt die Abweichung einer eindimensionalen Datenstichprobe vom Mittelwert. Es handelt sich um eine Statistik, die zur Messung der Beziehung zwischen zwei Zufallsvariablen verwendet wird. Aus einer Perspektive gilt: Je kleiner der Winkel, desto größer der Wert und desto ähnlicher die Richtung. Das heißt, je positiver die Korrelation ist. Neben der Beziehung zwischen zwei Zufallsvariablen ist das Maß der Kovarianzmatrix auch die Beziehung zwischen Dimensionen und nicht die Beziehung zwischen Stichproben.

Um etwas Neues zu lernen, insbesondere Wissen, müssen wir die Ideen in

Wissen verstehen. Wenn ich den Eigenface-Algorithmus verstehe und lerne, besteht seine Idee darin, dass die Bilderkennung zuerst einen geeigneten Unterraum auswählen, alle Bilder in diesem Unterraum konzentrieren und dann die Ähnlichkeit messen oder ein Klassifizierungslernen in diesem Unterraum durchführen muss. Dies hat zur Folge, dass Bilder derselben Kategorie näher beieinander liegen und Bilder verschiedener Kategorien weiter voneinander entfernt sind. Auf diese Weise können durch lineare Klassifizierung getrennte Bilder leicht in den neuen Raum umgewandelt werden. Gleichzeitig sucht die Eigengesichtstechnologie nach den Grundelementen der Gesichtsbildverteilung, dh den Eigenvektoren der Kovarianzmatrix des Gesichtsbild-Stichprobensatzes, um das Gesichtsbild zu charakterisieren. Es gibt viele Grundelemente menschlicher Gesichtsbilder, wie Augen, Wangen, Lippen und andere Grundelemente. Der durch diese Merkmalsvektoren im Bildraum des Eigengesichts erzeugte Unterraum wird als „Untergesichtsraum“ bezeichnet.                                                                                                                                                                                                       Nachdem wir den Unterraum erzeugt haben, müssen wir die Raumkonstruktion durchführen. Wie führt man also die Raumkonstruktion durch? Erstens müssen wir nach den Gemeinsamkeiten in menschlichen Gesichtern suchen, zweitens müssen wir nach den Unterschieden zwischen Individuen und Gemeinsamkeiten suchen und drittens müssen wir verstehen, dass Gemeinsamkeiten tatsächlich Räume und Individuen Vektoren sind. Verwenden Sie die Kovarianzmatrix, um die Eigenwerte aller Gesichtsbilder im Zielsatz zu zerlegen und die entsprechenden Eigenvektoren zu erhalten. Diese Eigenvektoren sind „

Eigengesichter

“. Finden Sie die Eigenschaften der Eigenvektoren und kombinieren Sie sie linear. In dem Raum, der auf jeder charakteristischen Unterfläche basiert, ist jede Fläche ein Punkt, und die Koordinaten dieses Punktes sind die Projektionskoordinaten jeder Fläche unter jeder charakteristischen Basis. Eigenfaces-Algorithmusprozess

Erhalten Sie Gesichtsbilddaten, ordnen Sie jede Gesichtsbildmatrix zeilenweise in einer Dimension an und jedes Gesicht ist ein Vektor

Addieren Sie M Gesichter in den entsprechenden Dimensionen und ermitteln Sie dann den Durchschnitt, um das „durchschnittliche Gesicht“ zu erhalten.

Berechnen Sie die Kovarianzmatrix.

Verwenden Sie Eigengesichter Gedächtnis-Gesichtserkennung;

Algorithmus-Übungsprozess;

Trainingsbilder

• Finden Sie das durchschnittliche Gesicht

• Für die Bildrekonstruktion

• Finden Sie Gesichtsbilder mit hohe Ähnlichkeit. Er2, Fisherface-Algorithmus

• Fisherface ist eine Anwendung für die lineare Fisher-Beurteilung bei der Erkennung menschlicher Gesichter.

  Die Idee des Algorithmus der linearen Diskriminanzanalyse (
LDA) wurde erstmals von Ronald Fisher (Ronald) vorgeschlagen, einem britischen Statistiker und Genetiker und einem der Begründer der modernen Statistikwissenschaft. Der LDA-Algorithmus verwendet statistische Methoden, um eine lineare Kombination von Merkmalen zwischen Objekten zu finden und Kategorieinformationen zu berücksichtigen und gleichzeitig die Dimensionalität zu reduzieren. Die durch diesen Algorithmus erhaltene Linearkombination kann als linearer Klassifikator oder zur Dimensionsreduktion verwendet werden.

• Grundidee

Die Grundidee der linearen Diskriminanzanalyse ist: Projizieren Sie hochdimensionale Musterproben in einen niedrigdimensionalen optimalen Vektorraum, um den Effekt zu erzielen, wichtige Klassifizierungsinformationen zu extrahieren und die Dimension des Merkmalsraums zu komprimieren Projektion: Schließlich wird garantiert, dass die Musterprobe im neuen Unterraum den maximalen Abstand zwischen den Klassen und den minimalen Abstand innerhalb der Klassen aufweist, d. h. das Muster weist in diesem Raum die beste Trennbarkeit auf. Die Theorie ähnelt den Eigenfaces, die in Eigenfaces verwendet werden. Beide sind Methoden zur Gesamtdimensionalitätsreduzierung und zur Abbildung der Originaldaten auf einen niedrigdimensionalen Raum. Sowohl Fisherfaces als auch Eigenfaces gehen von den Gesamtdaten aus und unterscheiden sich von LBP bei der Extraktion lokaler Texturen Merkmale.

                                                                                                                                                                                                                                        Verwenden Sie die lineare Diskriminanzmethode von Fisher, um eine optimale Projektionsrichtung zu bestimmen, einen eindimensionalen Zeichenraum zu konstruieren, das mehrdimensionale Gesichtsbild in den Merkmalsraum von Fisherfaces zu projizieren und anhand klasseninterner Beispieldaten einen Merkmalsvektor zu bilden Der Satz von Merkmalsvektoren stellt die Eigenschaften des Gesichts dar. Wir wissen, dass dieser Algorithmus den Abstand innerhalb der Klasse minimiert und den Abstand zwischen den Klassen maximiert, nachdem die Beispieldaten einem anderen Merkmalsraum zugeordnet wurden. Der LDA-Algorithmus kann zur Dimensionsreduktion verwendet werden. Das Prinzip dieses Algorithmus ist dem PCA-Algorithmus sehr ähnlich, sodass der LDA-Algorithmus auch im Bereich der Gesichtserkennung eingesetzt werden kann. Der Algorithmus zur Gesichtserkennung mithilfe des PCA-Algorithmus wird als Eigenface-Methode bezeichnet, während der Algorithmus zur Gesichtserkennung mithilfe des LDA-Algorithmus als Fisher-Gesichtsmethode bezeichnet wird. Im Vergleich zu

LDA und

PCA

: sind gleich: 1. Bei der Reduzierung der Dimensionen verwenden beide die Idee der Matrix-Eigenzerlegung. 2. Beide gehen davon aus, dass die Daten der Gaußschen Verteilung entsprechen.

Unterschiede: 1. LDA ist eine überwachte Dimensionsreduktionsmethode, während PCA unbeaufsichtigt ist. 2. Wenn die Daten k-dimensional sind, kann LDA nur auf (k-1) Dimensionen reduziert werden, PCA unterliegt dieser Einschränkung jedoch nicht. 3. Aus mathematischer Sicht wählt LDA die Projektionsrichtung mit der besten Klassifizierungsleistung aus, während PCA die Richtung mit der maximalen Varianz der Stichprobenprojektionspunkte auswählt. Im Vergleich zum

Fisherfaces-Algorithmus

und Eigenfaces-Algorithmus:

sind gleich: Beide können die Dimensionalität von Daten reduzieren; beide verwenden beim Reduzieren von Dimensionen die Idee der Matrix-Eigenzerlegung.
• Unterschied: Fisherfaces ist eine überwachte Dimensionsreduktionsmethode, aber Eigenfaces ist eine unbeaufsichtigte Dimensionsreduktionsmethode; Fisherfaces können nicht nur zur Dimensionsreduktion, sondern auch zur Klassifizierung verwendet werden.

Es ist erwähnenswert, dass die Fehlerrate der Erkennung durch den FisherFace-Algorithmus niedriger ist als die Ergebnisse der Eigenfaces-Erkennung, die in den Gesichtsdatenbanken von Harvard und Yale getestet wurden.

Fisherface-Algorithmusprozess

Erhalten Sie Gesichtsbilddaten und ermitteln Sie dann den Mittelwert des Gesichts.
Beobachten Sie die charakteristischen Werte jedes Gesichts.

Führen Sie eine Gesichtserkennung durch, beobachten Sie Gesichtszüge und stellen Sie fest, ob es sich um eine Person handelt.

Führen Sie abschließend die Gesichtserkennung durch.

• 3. LBPH-Algorithmus (Local Binary Patter Histogram)

• Local Binary Patterns Histograms sind die statistischen Histogramme von LBP-Merkmalen Bildinformationen werden kombiniert. Wenn Sie LBP-codierte Bilder direkt zur Gesichtserkennung verwenden. Tatsächlich besteht kein großer Unterschied darin, LBP-Merkmale nicht zu extrahieren. Daher wird in tatsächlichen LBP-Anwendungen im Allgemeinen das statistische Histogramm des LBP-codierten Bildes als Merkmalsvektor für die Klassifizierung und Erkennung verwendet.

  算 Der ursprüngliche LBP-Operator ist als Fenster von 33 definiert. Unter Verwendung des mittleren Pixels als Schwelle wird der Aschewert der angrenzenden 8 Pixel damit verglichen. Die Position des Punkts wird als 1 markiert, andernfalls ist sie 0 . Auf diese Weise können 8 Punkte in der 33er-Nachbarschaft verglichen werden, um eine 8-Bit-Binärzahl zu erzeugen (normalerweise in eine Dezimalzahl umgewandelt, d. h. LBP-Code, insgesamt 256 Typen), d. h. den LBP-Wert des Pixels in der Mitte des Fensters wird erhalten, und dieser Wert wird verwendet, um die Textureigenschaften des Bereichs widerzuspiegeln.
     Abmessungen von LBPH: Es gibt 8 Abtastpunkte, wenn das Original-LBP-Feature oder das erweiterte LBP-Feature verwendet wird, der LBP-Feature-Wertmodus 256 ist, dann ist die LBP-Feature-Vektordimension eines Bildes: 64256=16384 Dimensionen, wenn das UniformPatternLBP Bei Verwendung des Merkmals beträgt das LBP-Wertmuster 59 und die Merkmalsvektordimension beträgt: 6459 = 3776 Dimensionen. Es ist ersichtlich, dass bei Verwendung des äquivalenten Mustermerkmals die Merkmalsvektordimension stark reduziert wird, was bedeutet, dass die Maschine das Lernen verwendet Die Zeit der Lernmethode wird erheblich verkürzt, ohne dass die Leistung stark beeinträchtigt wird.

  Grundidee

         Die Grundidee

  der auf LBPH basierenden Gesichtserkennungsmethode lautet wie folgt: Nehmen Sie zunächst jedes Pixel als Mittelpunkt, bestimmen Sie die Beziehung zum Grauwert der umgebenden Pixel und führen Sie eine binäre Kodierung durch Es wird ein LBP-codiertes Bild des gesamten Bildes erhalten. Anschließend wird das LBP-Bild in Regionen unterteilt, das LBP-codierte Histogramm jeder Region erhalten und anschließend das LBP-codierte Histogramm des gesamten Bildes ermittelt , Das menschliche Gesicht kann zum Zweck der Gesichtserkennung erhalten werden. Der Vorteil besteht darin, dass es nicht durch Beleuchtung, Skalierung, Drehung und Übersetzung beeinflusst wird. Der LBPH-Algorithmus „Menschen“ ist, wie der Name schon sagt, die Methode zur lokalen Merkmalsextraktion. Dies ist der größte Unterschied zu den ersten beiden Methoden.

  LBPH-Algorithmusablauf
  LBP-Merkmalsextraktion: Verarbeiten Sie das Originalbild gemäß dem oben genannten einheitlichen LBP-Operator;
  LBP-Merkmalsabgleich (Histogramm berechnen): Teilen Sie das Bild in mehrere Unterbereiche auf Das Histogramm wird basierend auf dem LBP-Wert in der Unterregion berechnet und das Histogramm wird als Diskriminanzmerkmal verwendet.

  4. Algorithmus-Replikationscode 1), EigenFaces-Algorithmus

  #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-Algorithmus

  #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-Algorithmus

  #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

  Erweitertes Wissen: Gesichtserkennung Algorithmus Schwierigkeiten in der Forschung Gesichtserkennungsalgorithmen werden seit langem untersucht. Die meisten Algorithmen kommen gut damit zurecht, wenn der Hintergrund einfach ist. Allerdings gibt es für die Gesichtserkennung ein breites Anwendungsspektrum, und einfache Bildtests genügen bei weitem nicht den praktischen Anforderungen. Daher weist der Gesichtserkennungsalgorithmus immer noch viele Schwierigkeiten auf.

  Beleuchtung

  Das Beleuchtungsproblem ist ein altes Problem in der maschinellen Bildverarbeitung und zeigt sich besonders deutlich bei der Gesichtserkennung. Der Algorithmus hat noch nicht den Grad der Nutzung erreicht.

  Haltung

  Ähnlich wie das Beleuchtungsproblem ist auch das Haltungsproblem eine technische Schwierigkeit, die in der Gesichtserkennungsforschung gelöst werden muss. Es gibt relativ wenige Studien zur Körperhaltung. Die meisten Gesichtserkennungsalgorithmen zielen hauptsächlich auf frontale oder frontale Gesichtsbilder ab .

  Okklusion

  Bei der Sammlung von Gesichtsbildern ohne Kooperation ist das Okklusionsproblem ein sehr ernstes Problem, insbesondere in einer Überwachungsumgebung, in der die überwachten Personen häufig Brillen, Hüte und andere Accessoires tragen, was die Aufnahme von Bildern erschwert Das resultierende Gesichtsbild ist möglicherweise unvollständig, was sich auf die nachfolgende Merkmalsextraktion und -erkennung auswirkt und sogar dazu führen kann, dass der Gesichtserkennungsalgorithmus fehlschlägt.

  Altersveränderungen

  Mit zunehmendem Alter verändert sich auch das Gesichtsaussehen, insbesondere bei Teenagern ist diese Veränderung deutlicher. Für verschiedene Altersgruppen sind auch die Erkennungsraten von Gesichtserkennungsalgorithmen unterschiedlich.

  Bildqualität

  Gesichtsbilder können aus verschiedenen Quellen stammen. Aufgrund unterschiedlicher Erfassungsgeräte ist auch die Qualität der erhaltenen Gesichtsbilder unterschiedlich, insbesondere bei Gesichtsbildern mit niedriger Auflösung, hohem Rauschen und schlechter Qualität Die Durchführung einer effektiven Gesichtserkennung ist ein Problem, das Aufmerksamkeit erfordert. Auch bei hochauflösenden Bildern müssen die Auswirkungen auf Gesichtserkennungsalgorithmen weiter untersucht werden.

  Mangel an Proben

  Der auf statistischem Lernen basierende Gesichtserkennungsalgorithmus ist der gängige Algorithmus im Bereich der Gesichtserkennung, aber statistische Lernmethoden erfordern viel Training. Da es sich bei der Verteilung von Gesichtsbildern im hochdimensionalen Raum um eine unregelmäßige, beliebte Verteilung handelt, tasten die erhaltenen Stichproben nur einen sehr kleinen Teil des Gesichtsbildraums ab. Wie das Problem des statistischen Lernens bei kleinen Stichproben gelöst werden kann, bedarf weiterer Untersuchungen. Forschung.

  Eine große Datenmenge

  Traditionelle Gesichtserkennungsalgorithmen wie PCA, LDA usw. können in kleinen Datenmengen leicht trainiert und erlernt werden. Bei großen Datenmengen ist der Trainingsprozess dieser Methoden jedoch schwierig und kann sogar zusammenbrechen.

  Großflächige Gesichtserkennung

  Mit zunehmender Größe der Gesichtsdatenbank nimmt die Leistung des Gesichtsalgorithmus ab.

  Weitere Informationen zu diesem Thema finden Sie in der Rubrik „FAQ“!

Das obige ist der detaillierte Inhalt vonWas bedeutet Gesichtserkennungsalgorithmus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!