Apakah maksud algoritma pengecaman muka?-masalah biasa-php.cn

Algoritma pengecaman muka bermaksud bahawa selepas mengesan wajah dan mengesan titik ciri muka utama, kawasan muka utama boleh dipangkas keluar, dan selepas prapemprosesan, ia dimasukkan ke dalam algoritma pengecaman hujung belakang. Algoritma pengecaman mesti melengkapkan pengekstrakan ciri muka dan membandingkannya dengan wajah yang diketahui dalam inventori untuk melengkapkan pengelasan akhir. Prinsip algoritma pengecaman muka: sistem memasukkan satu atau satu siri imej muka dengan identiti yang tidak ditentukan, serta beberapa imej muka dengan identiti yang diketahui atau kod yang sepadan dalam pangkalan data muka, dan outputnya ialah satu siri Skor kesamaan menunjukkan identiti wajah untuk dikenali.

Apakah maksud algoritma pengecaman muka?

Persekitaran pengendalian tutorial ini: sistem Windows 7, komputer Dell G3.

Pengecaman Muka ialah untuk mendapatkan imej muka pengguna melalui peranti pengumpulan video, dan kemudian menggunakan algoritma teras untuk mengira dan menganalisis kedudukan, bentuk dan sudut ciri muka, dan kemudian membandingkannya dengan pangkalan datanya sendiri Bandingkan templat sedia ada untuk menentukan identiti sebenar pengguna.

Algoritma pengecaman muka bermaksud bahawa selepas mengesan wajah dan mengesan titik ciri muka utama, kawasan muka utama boleh dipangkas keluar, dan selepas prapemprosesan, ia dimasukkan ke dalam algoritma pengecaman hujung belakang. Algoritma pengecaman mesti melengkapkan pengekstrakan ciri muka dan membandingkannya dengan wajah yang diketahui dalam inventori untuk melengkapkan pengelasan akhir.

Terdapat empat jenis algoritma pengecaman muka: algoritma pengecaman berdasarkan titik ciri muka, algoritma pengecaman berdasarkan keseluruhan imej muka, algoritma pengecaman berasaskan templat dan algoritma pengecaman menggunakan rangkaian saraf.

Prinsip algoritma pengecaman muka:

Input sistem secara amnya adalah satu atau satu siri imej muka yang mengandungi wajah yang tidak dikenali dan pangkalan data wajah Terdapat beberapa imej wajah dengan identiti yang diketahui atau kod yang sepadan, dan outputnya ialah satu siri skor persamaan, yang menunjukkan identiti wajah yang akan dikenali.

Tiga algoritma klasik untuk pengecaman muka

1 algoritma Eigenfaces (eigenface)

Eigenfaces ialah nama set vektor ciri yang digunakan dalam masalah penglihatan komputer bagi pengecaman muka Eigenfaces adalah berdasarkan PCA (Analisis Komponen Utama), jadi pembelajaran Eigenfaces memerlukan kita untuk. memahami prinsip-prinsip PCA.

Idea asas

Analisis komponen utama (PCA) ialah algoritma pemampatan matriks yang mengurangkan dimensi matriks sebanyak mungkin Mengekalkan maklumat matriks asal hanya bermaksud menukar matriks n×m kepada matriks n×k, mengekalkan hanya ciri utama yang terdapat dalam matriks, yang boleh menjimatkan ruang dan volum data. Pelaksanaan PCA memerlukan pengurangan dimensi, iaitu mengubah matriks daripada dimensi yang lebih tinggi kepada dimensi yang lebih rendah Walau bagaimanapun, pengurangan dimensi PCA tidak dapat dipisahkan daripada matriks kovarians. Varians menerangkan sisihan sampel data satu dimensi daripada min Ia adalah statistik yang digunakan untuk mengukur hubungan antara dua pembolehubah rawak Dari perspektif, semakin kecil sudutnya, semakin besar nilainya, dan semakin serupa arahnya. Iaitu, semakin positif korelasi itu. Sebagai tambahan kepada hubungan antara dua pembolehubah rawak, ukuran matriks kovarians juga merupakan hubungan antara dimensi, bukan hubungan antara sampel.

Untuk mempelajari sesuatu yang baru, terutamanya ilmu, kita perlu memahami idea dalam ilmu. Apabila saya memahami dan mempelajari algoritma Eigenface, ideanya ialah pengecaman imej mesti terlebih dahulu memilih subruang yang sesuai, menumpukan semua imej ke dalam subruang ini, dan kemudian mengukur persamaan atau melakukan pembelajaran klasifikasi dalam subruang ini. Kesan daripada ini ialah imej dari kategori yang sama adalah lebih dekat, dan imej kategori yang berbeza adalah lebih jauh dipisahkan Dengan cara ini, imej yang dipisahkan oleh klasifikasi linear boleh diubah dengan mudah menjadi ruang baharu. Pada masa yang sama, teknologi eigenface akan mencari elemen asas pengedaran imej muka, iaitu, vektor eigen bagi matriks kovarians set sampel imej muka, untuk mencirikan imej muka. Terdapat banyak elemen asas imej muka manusia, seperti mata, pipi, bibir dan elemen asas lain Subruang yang dijana oleh vektor ciri ini dalam ruang imej muka eigen dipanggil ruang sub-muka .
Selepas menjana subruang, adalah perlu untuk membina ruang Jadi bagaimana untuk membina ruang? Pertama, kita perlu mencari persamaan dalam wajah manusia, kedua, kita perlu mencari perbezaan antara individu dan persamaan, dan ketiga, kita perlu memahami bahawa persamaan sebenarnya adalah ruang, dan individu adalah vektor. Gunakan matriks kovarians untuk menguraikan nilai eigen semua imej muka dalam set sasaran untuk mendapatkan vektor eigen yang sepadan ialah "Eigenface". Cari ciri-ciri vektor eigen dan gabungkan secara linear. Dalam ruang berdasarkan setiap sub-muka ciri, setiap muka ialah satu titik, dan koordinat titik ini ialah koordinat unjuran setiap muka di bawah setiap tapak ciri.

Proses algoritma eigenfaces

Dapatkan data imej muka, rentetan setiap matriks imej muka ke dalam satu dimensi mengikut baris dan setiap muka ialah vektor A;
Tambah muka M dalam dimensi yang sepadan, dan kemudian purata untuk mendapatkan "muka purata"; >
Kira matriks kovarians; >

2. Algoritma FisherFace
FisherFace ialah aplikasi diskriminasi linear Fisher dalam pengecaman muka.
Idea algoritma analisis diskriminasi linear (
Idea asas

idea asas analisis diskriminasi linear ialah: projek sampel corak dimensi tinggi kepada rendah- dimensi Ruang vektor terbaik boleh mencapai kesan mengekstrak maklumat pengelasan penting dan memampatkan dimensi ruang ciri Selepas unjuran, ia dijamin bahawa sampel corak mempunyai jarak antara kelas terbesar dan jarak antara kelas terkecil dalam subruang baharu. , iaitu corak mempunyai jarak terkecil dalam ruang ini. Teori ini serupa dengan Eigenfaces yang digunakan dalam eigenfaces Kedua-dua kaedah pengurangan dimensi keseluruhan dan pemetaan data asal ke ruang berdimensi rendah Kedua-dua fisherfaces dan Eigenfaces bermula dari data keseluruhan dan berbeza daripada LBP dalam mengekstrak tekstur tempatan ciri.

Gunakan kaedah diskriminasi linear Fisher pada sampel yang dikurangkan secara dimensi untuk menentukan arah unjuran yang optimum, bina ruang tanda satu dimensi, tonjolkan imej muka berbilang dimensi ke dalam ruang ciri fisherfaces dan gunakan intra-kelas sampel Data membentuk set vektor ciri, dan set vektor ciri ini mewakili ciri wajah manusia. Kami tahu bahawa algoritma ini meminimumkan jarak antara kelas dan memaksimumkan jarak antara kelas selepas data sampel dipetakan ke ruang ciri lain. Algoritma LDA boleh digunakan untuk pengurangan dimensi Prinsip algoritma ini hampir sama dengan algoritma PCA, jadi algoritma LDA juga boleh digunakan dalam bidang pengecaman muka. Algoritma untuk pengecaman muka menggunakan algoritma PCA dipanggil kaedah Eigenface, manakala algoritma untuk pengecaman muka menggunakan algoritma LDA dipanggil kaedah muka Fisher.

LDA dan

PCA

dibandingkan: adalah sama: 1. Apabila mengurangkan dimensi, kedua-duanya menggunakan matriks idea penguraian ciri; 2. Kedua-duanya menganggap bahawa data mematuhi taburan Gaussian.

Perbezaan: 1. LDA ialah kaedah pengurangan dimensi yang diselia, manakala PCA tidak diselia. 2. Jika data adalah k-dimensi, maka LDA hanya boleh dikurangkan kepada (k-1) dimensi, tetapi PCA tidak tertakluk kepada sekatan ini. 3. Dari perspektif matematik, LDA memilih arah unjuran dengan prestasi pengelasan terbaik, manakala PCA memilih arah dengan varians maksimum titik unjuran sampel.

Algoritma Fisherfaces

dan Algoritma Eigenfaces dibandingkan:

Perbezaan: Fisherfaces ialah kaedah pengurangan dimensi yang diselia, tetapi Eigenfaces ialah kaedah pengurangan dimensi tanpa pengawasan bukan sahaja boleh digunakan untuk pengurangan dimensi, tetapi juga untuk pengelasan.

Perlu dinyatakan bahawa kadar ralat pengecaman algoritma FisherFace adalah lebih rendah daripada hasil pengecaman Eigenfaces yang diuji pada pangkalan data muka Harvard dan Yale.

Proses algoritma Fisherface

Lakukan pengecaman muka, amati ciri muka dan tentukan sama ada ia adalah individu.

3. Algoritma LBPH (Local Binary Patter Histogram)
Histogram Corak Binari Tempatan ialah histogram statistik LBP ciri Rajah,
LBPH

LBP

(pengekodan binari tempatan) dengan maklumat spatial imej. Jika anda menggunakan imej berkod LBP secara langsung untuk pengecaman muka. Sebenarnya, tidak banyak perbezaan daripada tidak mengekstrak ciri LBP Oleh itu, dalam aplikasi LBP sebenar, histogram statistik imej yang dikodkan LBP biasanya digunakan sebagai vektor ciri untuk pengelasan dan pengecaman.

Pengendali LBP asal ditakrifkan sebagai dalam tetingkap 33, mengambil piksel tengah tetingkap sebagai ambang, dan membandingkan nilai skala kelabu 8 piksel bersebelahan dengannya jika nilai piksel di sekelilingnya lebih besar daripada atau sama dengan nilai piksel pusat, maka Kedudukan piksel ini ditandakan sebagai 1, jika tidak ia adalah 0. Dengan cara ini, 8 mata dalam 33 kejiranan boleh dibandingkan untuk menghasilkan nombor perduaan 8-bit (biasanya ditukar kepada nombor perpuluhan, iaitu kod LBP, 256 jenis secara keseluruhan), iaitu nilai LBP piksel di tengah tetingkap diperoleh, dan nilai ini digunakan untuk mencerminkan ciri tekstur kawasan.

Dimensi LBPH: Terdapat 8 titik persampelan Jika ciri LBP atau Extended LBP asal digunakan, mod nilai ciri LBP ialah 256, maka dimensi vektor ciri LBP bagi sesuatu imej ialah: 64256 =16384 dimensi. , dan jika ciri UniformPatternLBP digunakan, corak nilai LBP ialah 59, dan dimensi vektor ciri ialah: 6459=3776 dimensi Ia boleh dilihat bahawa menggunakan ciri corak setara, dimensi vektor ciri dikurangkan dengan ketara bahawa masa untuk belajar menggunakan kaedah pembelajaran mesin akan dikurangkan dengan banyak tanpa menjejaskan prestasi.

Idea asas

Kaedah pengecaman muka berdasarkan LBPHIdea asasadalah seperti berikut: Pertama, ambil setiap piksel sebagai pusat, hakim dan Hubungan antara nilai kelabu piksel sekeliling dikodkan binari untuk mendapatkan imej yang dikodkan LBP bagi keseluruhan imej, kemudian imej LBP dibahagikan kepada kawasan, histogram yang dikodkan LBP bagi setiap rantau diperoleh, dan kemudian LBP keseluruhan; imej diperolehi. Pengekodan histogram mencapai tujuan pengecaman muka dengan membandingkan histogram pengekodan LBP bagi imej muka yang berbeza Kelebihannya ialah ia tidak akan terjejas oleh pencahayaan, penskalaan, putaran dan terjemahan.

Algoritma LBPH adalah seperti namanya Kaedah pengenalan yang digunakan ialah pengekstrakan ciri tempatan Ini adalah perbezaan terbesar daripada dua kaedah pertama.

Algoritma LBPH

Pengestrakan ciri LBP: proses imej asal mengikut operator LBP seragam di atas
Padanan ciri LBP (mengira histogram): Bahagikan imej kepada beberapa subrantau, dan kira histogram mengikut nilai LBP dalam subrantau, menggunakan histogram sebagai ciri diskriminasinya.

4. Kod replikasi algoritma

1), algoritma 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')

Salin selepas log masuk

2), algoritma 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

Salin selepas log masuk

3), algoritma 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

Salin selepas log masuk

Pengetahuan lanjutan: Kesukaran dalam penyelidikan algoritma pengecaman muka

Algoritma pengecaman muka telah dikaji sejak sekian lama dan kebanyakan algoritma boleh mengendalikannya dengan baik apabila latar belakangnya ringkas. Walau bagaimanapun, pengecaman muka mempunyai pelbagai aplikasi, dan ujian imej mudah jauh daripada memenuhi keperluan praktikal. Oleh itu, masih terdapat banyak kesukaran dalam algoritma pengecaman muka.

Pencahayaan

Masalah pencahayaan ialah masalah lama dalam penglihatan mesin, dan ia amat ketara dalam pengecaman muka Algoritma belum mencapai tahap penggunaan.

Postur

Sama seperti masalah pencahayaan, masalah postur juga merupakan kesukaran teknikal yang perlu diselesaikan dalam penyelidikan pengecaman muka. Terdapat sedikit kajian mengenai postur kebanyakan algoritma pengecaman muka terutamanya ditujukan kepada imej muka hadapan atau dekat-ke-depan Apabila perubahan pic atau kiri-kanan berlaku, kadar pengecaman algoritma pengecaman muka juga akan berkurangan .

Oklusi

Untuk pengumpulan imej muka dalam situasi bukan kerjasama, masalah oklusi adalah masalah yang sangat serius, terutamanya dalam persekitaran pengawasan, di mana objek yang dipantau selalunya Mereka semua memakai cermin mata, topi dan aksesori lain, yang mungkin menjadikan imej wajah yang dikumpul tidak lengkap, yang akan menjejaskan pengekstrakan dan pengecaman ciri seterusnya, malah menyebabkan kegagalan algoritma pengecaman muka.

Perubahan Usia

Seiring dengan perubahan usia, penampilan wajah juga turut berubah terutama bagi remaja, perubahan ini lebih ketara. Untuk kumpulan umur yang berbeza, kadar pengecaman algoritma pengecaman muka juga berbeza.

Kualiti imej

Sumber imej muka mungkin berbeza-beza disebabkan peranti koleksi yang berbeza, kualiti imej wajah yang diperoleh juga berbeza, terutamanya bagi mereka yang mempunyai rendah Cara melaksanakan pengecaman muka yang berkesan pada imej muka dengan peleraian tinggi, hingar tinggi dan kualiti yang rendah adalah masalah yang memerlukan perhatian. Begitu juga, untuk imej resolusi tinggi, kesan pada algoritma pengecaman muka juga memerlukan kajian lanjut.

Kekurangan sampel

Algoritma pengecaman muka berdasarkan pembelajaran statistik ialah algoritma arus perdana dalam bidang pengecaman muka, tetapi kaedah pembelajaran statistik memerlukan banyak latihan. Memandangkan taburan imej muka dalam ruang berdimensi tinggi adalah taburan popular yang tidak teratur, sampel yang boleh diperolehi hanya mengambil sampel sebahagian kecil daripada ruang imej muka Bagaimana untuk menyelesaikan masalah pembelajaran statistik di bawah sampel kecil memerlukan kajian lanjut. Penyelidikan.

Sejumlah besar data

Algoritma pengecaman muka tradisional seperti PCA dan LDA boleh dilatih dan dipelajari dengan mudah dalam data berskala kecil. Walau bagaimanapun, untuk jumlah data yang besar, proses latihan kaedah ini adalah sukar dan mungkin runtuh.

Pengecaman muka berskala besar

Apabila saiz pangkalan data wajah bertambah, prestasi algoritma muka akan menurun.

Untuk lebih banyak pengetahuan berkaitan, sila lawati ruangan Soalan Lazim!

Atas ialah kandungan terperinci Apakah maksud algoritma pengecaman muka?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!