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 inWissen 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
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 (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-Algorithmusund Eigenfaces-Algorithmus:
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-AlgorithmusprozessFühren Sie eine Gesichtserkennung durch, beobachten Sie Gesichtszüge und stellen Sie fest, ob es sich um eine Person handelt.
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 Grundideeder 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
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 ans3), 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):
'''
生成均匀对应字典
:return: 均匀LBP特征对应字典
'''
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):
'''
计算LBP特征
:param img:图像矩阵
:return: LBP特征图
'''
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 ansErweitertes 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.
BeleuchtungDas 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 .
OkklusionBei 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änderungenMit 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ätGesichtsbilder 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 ProbenDer 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 DatenmengeTraditionelle 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 GesichtserkennungMit 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!
So stellen Sie den IE-Browser wieder her, um automatisch zu EDGE zu springen
Art der Verwendung in JavaScript
So öffnen Sie eine IMG-Datei
Lösung zur Verlangsamung der Zugriffsgeschwindigkeit bei der Anmietung eines US-Servers
AccessDenied-Fehlerlösung
Was bedeutet Marge in CSS?
Wie lautet das Passwort für den Mobilfunkdienst?
So eröffnen Sie ein digitales Währungskonto
