人脸识别 订阅
人脸识别,是基于人的脸部特征信息进行身份识别的一种生物识别技术。用摄像机或摄像头采集含有人脸的图像或视频流,并自动在图像中检测和跟踪人脸,进而对检测到的人脸进行脸部识别的一系列相关技术,通常也叫做人像识别、面部识别。 展开全文
人脸识别,是基于人的脸部特征信息进行身份识别的一种生物识别技术。用摄像机或摄像头采集含有人脸的图像或视频流,并自动在图像中检测和跟踪人脸,进而对检测到的人脸进行脸部识别的一系列相关技术,通常也叫做人像识别、面部识别。
信息
处理方法
人脸识别算法
传统技术
可见光图像的人脸识别
别    名
人像识别、面部识别
用    途
身份识别
中文名
人脸识别
工    具
摄像机或摄像头
人脸识别发展历史
人脸识别系统的研究始于20世纪60年代,80年代后随着计算机技术和光学成像技术的发展得到提高,而真正进入初级的应用阶段则在90年后期,并且以美国、德国和日本的技术实现为主;人脸识别系统成功的关键在于是否拥有尖端的核心算法,并使识别结果具有实用化的识别率和识别速度;“人脸识别系统”集成了人工智能、机器识别、机器学习、模型理论、专家系统、视频图像处理等多种专业技术,同时需结合中间值处理的理论与实现,是生物特征识别的最新应用,其核心技术的实现,展现了弱人工智能向强人工智能的转化。 [1] 
收起全文
精华内容
下载资源
问答
  • 深入浅出人脸识别

    万次阅读 多人点赞 2018-08-02 14:56:34
    人脸识别系统的研究始于20世纪60年代,80年代后随着计算机技术和光学成像技术的发展得到提高,而真正进入初级的应用阶段则在90年后期,并且以美国、德国和日本的技术实现为主。 人脸识别系统集成了人工智能、机器...

    人脸识别系统的研究始于20世纪60年代,80年代后随着计算机技术和光学成像技术的发展得到提高,而真正进入初级的应用阶段则在90年后期,并且以美国、德国和日本的技术实现为主。

    人脸识别系统集成了人工智能、机器识别、机器学习、模型理论、专家系统、视频图像处理等多种专业技术,同时需结合中间值处理的理论与实现,是生物特征识别的最新应用,其核心技术的实现,展现了弱人工智能向强人工智能的转化。

    人脸识别方法大致可以分为两类: 基于2D人脸图像的人脸识别和基于3D人脸图像的人脸识别。

    其中2D人脸识别是通过2D摄像头平面成像,无法接收物理世界中的第三位信息(尺寸和距离等几何数据),即使算法及软件再先进,在有限的信息接收状态下,安全级别终究不够高,通过照片//视频/化妆/人皮面具等方式可以很容易进行破解,无法满足智能门禁安全级别的需求。

    3D人脸识别则是通过3D摄像头立体成像,能够识别视野内空间每个点位的三维坐标信息,从而使得计算机得到空间的3D数据并能够复原完整的三维世界,并实现各种智能的三维定位。简单的说就是机器获取的信息多了,分析判断的准确性有了极大的提升,人脸识别功能可以分辨出平面图像/视频/化妆/皮面具/双胞胎等状态,适合金融领域和智能门禁等安全级别要求高的应用场景。

    目前,人脸识别技术已在中国得到广泛应用,涉及移动支付,交通枢纽安全,企业门禁考勤等诸多场合。显然,随着技术水平的不断提高,人脸识别技术在中国的应用将进一步扩大。随着技术的发展,市场需求将增加一倍。

    具体的详情,请参考鲜枣课堂的相关文章。

    展开全文
  • 人脸识别

    2019-09-02 19:48:22
    人脸识别1 人脸识别1.1 人脸检测、人脸验证、人脸识别1.2 单样本学习1.3 孪生网络 (Siamese Network)1.4 三元组损失函数1.5 基于孪生网络的二分类系统实现人脸识别1.6 一个节约时间的方法2 神经风格迁移2.1 什么是...


    1 人脸检测、人脸验证、人脸识别

    人脸检测:是否有人脸,有多少人脸? 例子:某些智能手机的相机在拍照时会检测人脸
    人脸验证:给出一张人脸和一个身份 ID,系统判断这种人脸是否对应这个身份ID。 例子:人脸解锁
    人脸识别:给出一张人脸,系统会取其特征,然后与库中的所有人的人脸特征做对比,判断属于哪一个人。

    人脸识别比人脸验证复杂得多,前者是一对多,而后者是一对一。如果人脸验证正确的概率为 99%,那么这已经算非常高了。如果在包含100个人的人脸识别系统中,每个人识别正确的概率为 99%,那么要100个全部识别正确的概率为 0.991000.3660.99^{^{100}}\approx0.366,即 36.6%,这是一个相当低的正确率。

    2 单样本学习

    在这里插入图片描述

    3 孪生网络 (Siamese Network)

    在这里插入图片描述
    在这里插入图片描述

    4 三元组损失函数

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5 基于孪生网络的二分类系统实现人脸识别

    在这里插入图片描述
    在这里插入图片描述

    6 一个节约时间的方法

    当人脸检测系统训练完成,在进行人脸识别预测的时候,我们会输入一张新的人脸图片,然后系统会把这张新图片依次和人脸库中每张人脸图片输入孪生网络。无论是通过单元组损失函数,还是通过二分类的方法来实现人脸识别,在每一次识别预测的时候都需要通过孪生网络计算两次特征向量。

    我们可以先就算出人脸库中每张人脸的特征向量,然后储存起来。当进行人脸识别预测的时候,这时我们仅仅需要计算新人脸图片的特征向量,然后取出之前计算好的人脸库中每个人的人脸特征,再依次做对比。这样可以节省很多时间。

    展开全文
  • 利用python、tensorflow、opencv实现人脸识别(包会)!

    万次阅读 多人点赞 2018-07-25 17:07:54
    本人是机械专业在读硕士,在完成暑假实践的时候接触到了人脸识别,对这一实现很感兴趣,所以花了大概十天时间做出了自己的人脸识别。这篇文章应该是很详细的了所以帮你实现人脸识别应该没什么问题。 先说本博文的...

     

    一,前言

    本人是机械专业在读硕士,在完成暑假实践的时候接触到了人脸识别,对这一实现很感兴趣,所以花了大概十天时间做出了自己的人脸识别。这篇文章应该是很详细的了所以帮你实现人脸识别应该没什么问题。

    先说本博文的最终要达到的效果:通过一系列操作,在摄像头的视频流中识别特定人的人脸,并且予以标记。

    本人通过网上资料的查询发现这类人脸识别,大多参考了一位日本程序员小哥的文章。

    链接:https://github.com/Hironsan/BossSensor

    关于这个思路的人脸识别网上资料很多,但是有很多细节没有提到,我在实践的过程中菜过了无数的坑,希望我这篇文章能够对你提供更加清晰的思路和操作。先看结果(人丑勿怪)!这个是识别我的脸,别人的脸不会识别到

    其实,这已经涉及到了一些机器学习的内容,对于像入门机器学习的同学来说是一个不错的练手的项目。

    二、前期准备工作

    首先说,我在刚开始接触的时候,主要是在各种数据包的安装上以及环境的配置上花费了巨大的时间,有些数据包升级版本之后与一些功能不兼容,出了很多问题,所以。我在这里说一下我的数据包的版本和python版本。现在可以用anaconda来下载python和各种数据包,但是最新的版本是用python3.6.X,在后面的实践中可能会出现不同的问题,所以为了安全起见python最好选择3.5.X的,不要安装2.X的,与3.X的版本不兼容,会出现很多问题。另外再安装一个tensorflow,pip,keras,sklearn,PIL,numpy,opencv等。其中keras要安装2.0版本的,opencv安装3.3.1版本的。tensorflow有CPU版本的和GPU版本的,你可以看一下你适合哪一种,这里贴出来一些供你参考:

           您必须从以下 TensorFlow 类型中选择其一来进行安装:

           仅支持 CPU 的 TensorFlow。如果您的系统没有 NVIDIA® GPU,则必须安装此版本。请注意,此版本的                                    TensorFlow 通常更容易安装(用时通常在 5 或 10 分钟内),所以即使您拥有 NVIDIA GPU,我们也建议先安                              装此版本。预编译的二进制文件将使用 AVX 指令。

            支持 GPU 的 TensorFlow。TensorFlow 程序在 GPU 上的运行速度通常要比在 CPU 上快得多。因此,如果您                           的系统配有满足以下所示先决条件的 NVIDIA® GPU,并且您需要运行性能至关重要的应用,则最终应安装此                              版本。

    另外我在安装的过程中发现了几篇比较不错的博文供你参考:

    1.https://blog.csdn.net/Eppley/article/details/79297503

    2.https://blog.csdn.net/WJ_MeiMei/article/details/79684627

    3.https://zhuanlan.zhihu.com/p/24055668

    在几篇博文里你也会看到验证安装正确的方法,如果可以的话,说明你安装成功了,这里我就不多说了。后面的话你可能还会遇到别的什么问题,如果还需要安装什么模块的话,在安装也可以。

    在硬件方面,你还需要一个USB摄像头。

     

    总结:

    1. USB摄像头一个;

    2. python  --  3.5.X

    3. tensorflow

    4. opencv  --  3.3.1

    5. keras   --  2.0.X

    6. sklearn  -- 0.19.0

     

    三、正式开始

     

    1,识别人脸

           实现人脸识别简单程序没几行,但是我们要实现的是识别这个是谁的脸。首先我们让系统识别人脸,这是opencv的工作,我们只需要调用其中的API函数就可以了。下面是调用opencv实现对于人脸的识别。咱们在程序下面对程序进行一些解释:

    
    
    import cv2
    import sys
    from PIL import Image
    
    def CatchUsbVideo(window_name, camera_idx):
        cv2.namedWindow(window_name)
        
        #视频来源,可以来自一段已存好的视频,也可以直接来自USB摄像头
        cap = cv2.VideoCapture(camera_idx)                
        
        #告诉OpenCV使用人脸识别分类器
        classfier = cv2.CascadeClassifier("H:\\OpenCV\\opencv\\build\\etc\\haarcascades\\haarcascade_frontalface_alt2.xml")
        
        #识别出人脸后要画的边框的颜色,RGB格式
        color = (0, 255, 0)
            
        while cap.isOpened():
            ok, frame = cap.read() #读取一帧数据
            if not ok:            
                break  
    
            #将当前帧转换成灰度图像
            grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)                 
            
            #人脸检测,1.2和2分别为图片缩放比例和需要检测的有效点数
            faceRects = classfier.detectMultiScale(grey, scaleFactor = 1.2, minNeighbors = 3, minSize = (32, 32))
            if len(faceRects) > 0:            #大于0则检测到人脸                                   
                for faceRect in faceRects:  #单独框出每一张人脸
                    x, y, w, h = faceRect        
                    cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, 2)
                            
            #显示图像
            cv2.imshow(window_name, frame)        
            c = cv2.waitKey(10)
            if c & 0xFF == ord('q'):
                break        
        
        #释放摄像头并销毁所有窗口
        cap.release()
        cv2.destroyAllWindows() 
        
    if __name__ == '__main__':
        if len(sys.argv) != 1:
            print("Usage:%s camera_id\r\n" % (sys.argv[0]))
        else:
            CatchUsbVideo("识别人脸区域", 0)
    

        首先,第一行import cv2,实际上,”cv2”中的”2”并不表示OpenCV的版本号。我们知道,OpenCV是基于C/C++的,”cv”和”cv2”表示的是底层CAPI和C++API的区别,”cv2”表示使用的是C++API。这主要是一个历史遗留问题,是为了保持向后兼容性。PIL是一个模块,如果运行的过程中提示你缺少模块的时候你就要安装一个模块了,其余同理,就不再说了。另外在函数Catchusbvideo中,第二个参数指的是你电脑的摄像头的编号,例如是0,1,2等,如果0不行的话,试一下1。在下边的人脸识别分类器中是我自己下载的opencv,下载网站是:https://opencv.org/releases.html,如果你是windows选择对应版本就好,还有就是“H:\\OpenCV\\opencv\\build\\etc\\haarcascades\\haarcascade_frontalface_alt2.xml”这是我安装的一个路径,你也要找到这个路径并且复制到程序中,这个东西的作用主要是实现对人脸识别的功能,在安装中还有其他的功能,我也一并列在下面:

                   人脸检测器(默认):haarcascade_frontalface_default.xml 
                   人脸检测器(快速Harr):haarcascade_frontalface_alt2.xml 
                   人脸检测器(侧视):haarcascade_profileface.xml 
                   眼部检测器(左眼):haarcascade_lefteye_2splits.xml 
                   眼部检测器(右眼):haarcascade_righteye_2splits.xml 
                   嘴部检测器:haarcascade_mcs_mouth.xml 
                   鼻子检测器:haarcascade_mcs_nose.xml 
                   身体检测器:haarcascade_fullbody.xml 
                   人脸检测器(快速LBP):lbpcascade_frontalface.xml

    另外,如果我们想构建自己的分类器,比如识别火焰、汽车,数,花等,我们依然可以使用OpenCV训练构建。   

        这个函数完成对人脸的识别以及用一个框框给框起来,其中grey是要识别的图像数据,转化为灰度可以减少计算量。scaleFactor:图像缩放比例,可以理解为同一个物体与相机距离不同,其大小亦不同,必须将其缩放到一定大小才方便识别,该参数指定每次缩放的比例。minNeighbors:对特征检测点周边多少有效点同时检测,这样可避免因选取的特征检测点太小而导致遗漏。minSize:特征检测点的最小值。

            对同一个画面有可能出现多张人脸,因此,我们需要用一个for循环将所有检测到的人脸都读取出来,然后逐个用矩形框框出来,这就是接下来的for语句的作用。Opencv会给出每张人脸在图像中的起始坐标(左上角,x、y)以及长、宽(h、w),我们据此就可以截取出人脸。其中,cv2.rectangle()完成画框的工作,在这里外扩了10个像素以框出比人脸稍大一点的区域。cv2.rectangle()函数的最后两个参数一个用于指定矩形边框的颜色,一个用于指定矩形边框线条的粗细程度。

                运行结果:

                                               

    好,看来可以顺利的识别出视频中的脸,搞定!但是我们想做的是识别这个人脸是谁的,这仅仅能识别这是谁的脸,完全不能满足我们的渴望,接下来我们进行下一步!

    2.模型训练

    模型训练的目的是让电脑知道,这个脸的特征是什么,从而可以在视频流中识别。在训练之前必须先准备足够的脸部照片作为机器学习的资料。

         2.1准备机器学习的资料

    所谓机器学习就是给程序投喂足够多的资料,资料越多,准确度和效率也会越高。要想识别出这张人脸属于谁,我们肯定需要大量的自己的脸和别人的脸,这样才能区别开。然后将这些数据输入到Tensorflow中建立我们自己脸的模型。

    1.keras简介

    上面提到的日本小哥利用深度学习库keras来训练自己的人脸识别模型。 我这里找到一篇keras的中文文档可能对你有些帮助。另外关于Keras, Keras是由纯python编写的基于theano/tensorflow的深度学习框架。Keras是一个高层神经网络API,支持快速实验,能够把你的idea迅速转换为结果,如果有如下需求,可以优先选择Keras:

                    a)简易和快速的原型设计(keras具有高度模块化,极简,和可扩充特性)

                    b)支持CNN和RNN,或二者的结合

                    c)无缝CPU和GPU切换

     

    Keras的模块结构:

                   

            

    使用Keras搭建一个神经网络:

     

          

    数据格式(data_format):

            目前主要有两种方式来表示张量:
            a) th模式或channels_first模式,Theano和caffe使用此模式。
            b)tf模式或channels_last模式,TensorFlow使用此模式。

    因为我装的是tensorflow因此我直接使用了keras的Tensorflow版,同时,为了验证其它深度学习库的效率和准确率,我还使用了Theano,利用CNN——卷积神经网络来训练我的人脸识别模型。本节专注把训练数据准备好。

    完整代码如下:

    
    
    import cv2
    import sys
    
    from PIL import Image
    
    def CatchPICFromVideo(window_name, camera_idx, catch_pic_num, path_name):
        cv2.namedWindow(window_name)
        
        #视频来源,可以来自一段已存好的视频,也可以直接来自USB摄像头
        cap = cv2.VideoCapture(camera_idx)                
        
        #告诉OpenCV使用人脸识别分类器
        classfier = cv2.CascadeClassifier("H:\\OpenCV\\opencv\\build\\etc\\haarcascades\\haarcascade_frontalface_alt2.xml")
        
        #识别出人脸后要画的边框的颜色,RGB格式
        color = (0, 255, 0)
        
        num = 0    
        while cap.isOpened():
            ok, frame = cap.read() #读取一帧数据
            if not ok:            
                break                
        
            grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  #将当前桢图像转换成灰度图像            
            
            #人脸检测,1.2和2分别为图片缩放比例和需要检测的有效点数
            faceRects = classfier.detectMultiScale(grey, scaleFactor = 1.2, minNeighbors = 3, minSize = (32, 32))
            if len(faceRects) > 0:          #大于0则检测到人脸                                   
                for faceRect in faceRects:  #单独框出每一张人脸
                    x, y, w, h = faceRect                        
                    
                    #将当前帧保存为图片
                    img_name = '%s/%d.jpg'%(path_name, num)                
                    image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
                    cv2.imwrite(img_name, image)                                
                                    
                    num += 1                
                    if num > (catch_pic_num):   #如果超过指定最大保存数量退出循环
                        break
                    
                    #画出矩形框
                    cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, 2)
                    
                    #显示当前捕捉到了多少人脸图片了,这样站在那里被拍摄时心里有个数,不用两眼一抹黑傻等着
                    font = cv2.FONT_HERSHEY_SIMPLEX
                    cv2.putText(frame,'num:%d' % (num),(x + 30, y + 30), font, 1, (255,0,255),4)                
            
            #超过指定最大保存数量结束程序
            if num > (catch_pic_num): break                
                           
            #显示图像
            cv2.imshow(window_name, frame)        
            c = cv2.waitKey(10)
            if c & 0xFF == ord('q'):
                break        
        
        #释放摄像头并销毁所有窗口
        cap.release()
        cv2.destroyAllWindows() 
        
    if __name__ == '__main__':
        if len(sys.argv) != 1:
            print("Usage:%s camera_id face_num_max path_name\r\n" % (sys.argv[0]))
        else:
            CatchPICFromVideo("截取人脸", 0, 1000, 'C:\\Users\\Administrator\\Desktop\\Python\\data\\liziqiang')
    

     这段代码我们只是在前面代码的基础上增加脸部图像存储功能,比较简单。

    def CatchPICFromVideo(window_name, camera_idx, catch_pic_num, path_name):

    在函数定义中,几个参数,反别是窗口名字,摄像头系列号,捕捉照片数量,以及存储路径。根据自己需要进行修改,咱们这里为了精度高一点,选择捕捉1000张脸部照片。在你捕捉的时候由于精度的问题,会捕捉许多非脸部的照片,这时候需要你将不是脸部的照片清洗掉,使数据更加准确。另外,我们还需要捕捉另一个人的图片来提高模型的准确度。然后存储到另一个文件夹下,注意,一个人的照片存储到一个文件夹下,不可弄混。截图完成,就像下图这样。

    好了,经过前面的数据搜集,咱们已经差不多准备了2000张照片,准备工作已经做好,下面我们将进行数据模型的训练!

     

    2.模型训练

    训练程序建立了一个包含4个卷积层的神经网络(CNN),程序利用这个网络训练我的人脸识别模型,并将最终训练结果保存到硬盘上。在我们实际动手操练之前我们必须先弄明白一个问题——什么是卷积神经网络(CNN)?

    想知道你可以谷歌,另外有关神经网络我会另外写一篇博客。这里就不多做介绍了。

    首先建立一个python文件,命名load_dataset。代码如下:

    
    import os
    import sys
    import numpy as np
    import cv2
    
    IMAGE_SIZE = 64
    
    #按照指定图像大小调整尺寸
    def resize_image(image, height = IMAGE_SIZE, width = IMAGE_SIZE):
        top, bottom, left, right = (0, 0, 0, 0)
        
        #获取图像尺寸
        h, w, _ = image.shape
        
        #对于长宽不相等的图片,找到最长的一边
        longest_edge = max(h, w)    
        
        #计算短边需要增加多上像素宽度使其与长边等长
        if h < longest_edge:
            dh = longest_edge - h
            top = dh // 2
            bottom = dh - top
        elif w < longest_edge:
            dw = longest_edge - w
            left = dw // 2
            right = dw - left
        else:
            pass 
        
        #RGB颜色
        BLACK = [0, 0, 0]
        
        #给图像增加边界,是图片长、宽等长,cv2.BORDER_CONSTANT指定边界颜色由value指定
        constant = cv2.copyMakeBorder(image, top , bottom, left, right, cv2.BORDER_CONSTANT, value = BLACK)
        
        #调整图像大小并返回
        return cv2.resize(constant, (height, width))
    
    #读取训练数据
    images = []
    labels = []
    def read_path(path_name):    
        for dir_item in os.listdir(path_name):
            #从初始路径开始叠加,合并成可识别的操作路径
            full_path = os.path.abspath(os.path.join(path_name, dir_item))
            
            if os.path.isdir(full_path):    #如果是文件夹,继续递归调用
                read_path(full_path)
            else:   #文件
                if dir_item.endswith('.jpg'):
                    image = cv2.imread(full_path)                
                    image = resize_image(image, IMAGE_SIZE, IMAGE_SIZE)
                    
                    #放开这个代码,可以看到resize_image()函数的实际调用效果
                    #cv2.imwrite('1.jpg', image)
                    
                    images.append(image)                
                    labels.append(path_name)                                
                        
        return images,labels
        
    
    #从指定路径读取训练数据
    def load_dataset(path_name):
        images,labels = read_path(path_name)    
        
        #将输入的所有图片转成四维数组,尺寸为(图片数量*IMAGE_SIZE*IMAGE_SIZE*3)
        #我和闺女两个人共1200张图片,IMAGE_SIZE为64,故对我来说尺寸为1200 * 64 * 64 * 3
        #图片为64 * 64像素,一个像素3个颜色值(RGB)
        images = np.array(images)
        print(images.shape)    
        
        #标注数据,'liziqiang'文件夹下都是我的脸部图像,全部指定为0,另外一个文件夹下是同学的,全部指定为1
        labels = np.array([0 if label.endswith('liziqiang') else 1 for label in labels])    
        
        return images, labels
    
    if __name__ == '__main__':
        if len(sys.argv) != 1:
            print("Usage:%s path_name\r\n" % (sys.argv[0]))    
        else:
            images, labels = load_dataset("C:\\Users\\Administrator\\Desktop\\Python\\data")
    

           

            稍微解释一下resize_image()函数。这个函数的功能是判断图片是不是正方形,如果不是则增加短边的长度使之变成正方形。这样再调用cv2.resize()函数就可以实现等比例缩放了。因为我们指定缩放的比例就是64 x 64,只有缩放之前图像为正方形才能确保图像不失真。例如:

    这样明显不是正方形。经过程序运行之后要达到这样的目的。

    大概是这么个意思。

    将你捕捉到的照片放在俩个不同的文件夹里,我在这里一块放在了data文件夹里。

     

    然后再新建一个python文件,命名为:face_train。添加如下代码。

    
    import random
    
    import numpy as np
    from sklearn.cross_validation import train_test_split
    from keras.preprocessing.image import ImageDataGenerator
    from keras.models import Sequential
    from keras.layers import Dense, Dropout, Activation, Flatten
    from keras.layers import Convolution2D, MaxPooling2D
    from keras.optimizers import SGD
    from keras.utils import np_utils
    from keras.models import load_model
    from keras import backend as K
    
    from load_data import load_dataset, resize_image, IMAGE_SIZE
    
    
    
    class Dataset:
        def __init__(self, path_name):
            #训练集
            self.train_images = None
            self.train_labels = None
            
            #验证集
            self.valid_images = None
            self.valid_labels = None
            
            #测试集
            self.test_images  = None            
            self.test_labels  = None
            
            #数据集加载路径
            self.path_name    = path_name
            
            #当前库采用的维度顺序
            self.input_shape = None
            
        #加载数据集并按照交叉验证的原则划分数据集并进行相关预处理工作
        def load(self, img_rows = IMAGE_SIZE, img_cols = IMAGE_SIZE, 
                 img_channels = 3, nb_classes = 2):
            #加载数据集到内存
            images, labels = load_dataset(self.path_name)        
            
            train_images, valid_images, train_labels, valid_labels = train_test_split(images, labels, test_size = 0.3, random_state = random.randint(0, 100))        
            _, test_images, _, test_labels = train_test_split(images, labels, test_size = 0.5, random_state = random.randint(0, 100))                
            
            #当前的维度顺序如果为'th',则输入图片数据时的顺序为:channels,rows,cols,否则:rows,cols,channels
            #这部分代码就是根据keras库要求的维度顺序重组训练数据集
            if K.image_dim_ordering() == 'th':
                train_images = train_images.reshape(train_images.shape[0], img_channels, img_rows, img_cols)
                valid_images = valid_images.reshape(valid_images.shape[0], img_channels, img_rows, img_cols)
                test_images = test_images.reshape(test_images.shape[0], img_channels, img_rows, img_cols)
                self.input_shape = (img_channels, img_rows, img_cols)            
            else:
                train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, img_channels)
                valid_images = valid_images.reshape(valid_images.shape[0], img_rows, img_cols, img_channels)
                test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, img_channels)
                self.input_shape = (img_rows, img_cols, img_channels)            
                
                #输出训练集、验证集、测试集的数量
                print(train_images.shape[0], 'train samples')
                print(valid_images.shape[0], 'valid samples')
                print(test_images.shape[0], 'test samples')
            
                #我们的模型使用categorical_crossentropy作为损失函数,因此需要根据类别数量nb_classes将
                #类别标签进行one-hot编码使其向量化,在这里我们的类别只有两种,经过转化后标签数据变为二维
                train_labels = np_utils.to_categorical(train_labels, nb_classes)                        
                valid_labels = np_utils.to_categorical(valid_labels, nb_classes)            
                test_labels = np_utils.to_categorical(test_labels, nb_classes)                        
            
                #像素数据浮点化以便归一化
                train_images = train_images.astype('float32')            
                valid_images = valid_images.astype('float32')
                test_images = test_images.astype('float32')
                
                #将其归一化,图像的各像素值归一化到0~1区间
                train_images /= 255
                valid_images /= 255
                test_images /= 255            
            
                self.train_images = train_images
                self.valid_images = valid_images
                self.test_images  = test_images
                self.train_labels = train_labels
                self.valid_labels = valid_labels
                self.test_labels  = test_labels
                
    #CNN网络模型类            
    class Model:
        def __init__(self):
            self.model = None 
            
        #建立模型
        def build_model(self, dataset, nb_classes = 2):
            #构建一个空的网络模型,它是一个线性堆叠模型,各神经网络层会被顺序添加,专业名称为序贯模型或线性堆叠模型
            self.model = Sequential() 
            
            #以下代码将顺序添加CNN网络需要的各层,一个add就是一个网络层
            self.model.add(Convolution2D(32, 3, 3, border_mode='same', 
                                         input_shape = dataset.input_shape))    #1 2维卷积层
            self.model.add(Activation('relu'))                                  #2 激活函数层
            
            self.model.add(Convolution2D(32, 3, 3))                             #3 2维卷积层                             
            self.model.add(Activation('relu'))                                  #4 激活函数层
            
            self.model.add(MaxPooling2D(pool_size=(2, 2)))                      #5 池化层
            self.model.add(Dropout(0.25))                                       #6 Dropout层
    
            self.model.add(Convolution2D(64, 3, 3, border_mode='same'))         #7  2维卷积层
            self.model.add(Activation('relu'))                                  #8  激活函数层
            
            self.model.add(Convolution2D(64, 3, 3))                             #9  2维卷积层
            self.model.add(Activation('relu'))                                  #10 激活函数层
            
            self.model.add(MaxPooling2D(pool_size=(2, 2)))                      #11 池化层
            self.model.add(Dropout(0.25))                                       #12 Dropout层
    
            self.model.add(Flatten())                                           #13 Flatten层
            self.model.add(Dense(512))                                          #14 Dense层,又被称作全连接层
            self.model.add(Activation('relu'))                                  #15 激活函数层   
            self.model.add(Dropout(0.5))                                        #16 Dropout层
            self.model.add(Dense(nb_classes))                                   #17 Dense层
            self.model.add(Activation('softmax'))                               #18 分类层,输出最终结果
            
            #输出模型概况
            self.model.summary()
            
        #训练模型
        def train(self, dataset, batch_size = 20, nb_epoch = 10, data_augmentation = True):        
            sgd = SGD(lr = 0.01, decay = 1e-6, 
                      momentum = 0.9, nesterov = True) #采用SGD+momentum的优化器进行训练,首先生成一个优化器对象  
            self.model.compile(loss='categorical_crossentropy',
                               optimizer=sgd,
                               metrics=['accuracy'])   #完成实际的模型配置工作
            
            #不使用数据提升,所谓的提升就是从我们提供的训练数据中利用旋转、翻转、加噪声等方法创造新的
            #训练数据,有意识的提升训练数据规模,增加模型训练量
            if not data_augmentation:            
                self.model.fit(dataset.train_images,
                               dataset.train_labels,
                               batch_size = batch_size,
                               nb_epoch = nb_epoch,
                               validation_data = (dataset.valid_images, dataset.valid_labels),
                               shuffle = True)
            #使用实时数据提升
            else:            
                #定义数据生成器用于数据提升,其返回一个生成器对象datagen,datagen每被调用一
                #次其生成一组数据(顺序生成),节省内存,其实就是python的数据生成器
                datagen = ImageDataGenerator(
                    featurewise_center = False,             #是否使输入数据去中心化(均值为0),
                    samplewise_center  = False,             #是否使输入数据的每个样本均值为0
                    featurewise_std_normalization = False,  #是否数据标准化(输入数据除以数据集的标准差)
                    samplewise_std_normalization  = False,  #是否将每个样本数据除以自身的标准差
                    zca_whitening = False,                  #是否对输入数据施以ZCA白化
                    rotation_range = 20,                    #数据提升时图片随机转动的角度(范围为0~180)
                    width_shift_range  = 0.2,               #数据提升时图片水平偏移的幅度(单位为图片宽度的占比,0~1之间的浮点数)
                    height_shift_range = 0.2,               #同上,只不过这里是垂直
                    horizontal_flip = True,                 #是否进行随机水平翻转
                    vertical_flip = False)                  #是否进行随机垂直翻转
    
                #计算整个训练样本集的数量以用于特征值归一化、ZCA白化等处理
                datagen.fit(dataset.train_images)                        
    
                #利用生成器开始训练模型
                self.model.fit_generator(datagen.flow(dataset.train_images, dataset.train_labels,
                                                       batch_size = batch_size),
                                         samples_per_epoch = dataset.train_images.shape[0],
                                         nb_epoch = nb_epoch,
                                         validation_data = (dataset.valid_images, dataset.valid_labels))    
        
        MODEL_PATH = './liziqiang.face.model.h5'
        def save_model(self, file_path = MODEL_PATH):
             self.model.save(file_path)
     
        def load_model(self, file_path = MODEL_PATH):
             self.model = load_model(file_path)
    
        def evaluate(self, dataset):
             score = self.model.evaluate(dataset.test_images, dataset.test_labels, verbose = 1)
             print("%s: %.2f%%" % (self.model.metrics_names[1], score[1] * 100))
    
        #识别人脸
        def face_predict(self, image):    
            #依然是根据后端系统确定维度顺序
            if K.image_dim_ordering() == 'th' and image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
                image = resize_image(image)                             #尺寸必须与训练集一致都应该是IMAGE_SIZE x IMAGE_SIZE
                image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))   #与模型训练不同,这次只是针对1张图片进行预测    
            elif K.image_dim_ordering() == 'tf' and image.shape != (1, IMAGE_SIZE, IMAGE_SIZE, 3):
                image = resize_image(image)
                image = image.reshape((1, IMAGE_SIZE, IMAGE_SIZE, 3))                    
            
            #浮点并归一化
            image = image.astype('float32')
            image /= 255
            
            #给出输入属于各个类别的概率,我们是二值类别,则该函数会给出输入图像属于0和1的概率各为多少
            result = self.model.predict_proba(image)
            print('result:', result)
            
            #给出类别预测:0或者1
            result = self.model.predict_classes(image)        
    
            #返回类别预测结果
            return result[0]
    
    
    
    
    
    
    
        
    if __name__ == '__main__':
        dataset = Dataset('./data/')    
        dataset.load()
        
        model = Model()
        model.build_model(dataset)
        
        #先前添加的测试build_model()函数的代码
        model.build_model(dataset)
    
        #测试训练函数的代码
        model.train(dataset)
        
        
    if __name__ == '__main__':
        dataset = Dataset('./data/')    
        dataset.load()
        
        model = Model()
        model.build_model(dataset)
        model.train(dataset)
        model.save_model(file_path = './model/liziqiang.face.model.h5')
        
        
    if __name__ == '__main__':    
        dataset = Dataset('./data/')    
        dataset.load()
    
        
        #评估模型
        model = Model()
        model.load_model(file_path = './model/liziqiang.face.model.h5')
        model.evaluate(dataset)    
        
        
        
        
        

    运行程序结果:

    可以看到,最后我们对数据进行了验证,准确率达到了99.83%。结果较为理想,并且在model下面也得到了我i们的训练数据。

    由此,我们最重要的训练数据也完成了,加下来就是验证我们训练数据的效果的时候了。

     

     

    3、识别人脸

     

    新建python文件,命名:Face_recognition。代码如下:

    #-*- coding: utf-8 -*-
    
    import cv2
    import sys
    import gc
    from face_train import Model
    
    if __name__ == '__main__':
        if len(sys.argv) != 1:
            print("Usage:%s camera_id\r\n" % (sys.argv[0]))
            sys.exit(0)
            
        #加载模型
        model = Model()
        model.load_model(file_path = './model/liziqiang.face.model.h5')    
                  
        #框住人脸的矩形边框颜色       
        color = (0, 255, 0)
        
        #捕获指定摄像头的实时视频流
        cap = cv2.VideoCapture(0)
        
        #人脸识别分类器本地存储路径
        cascade_path = "H:\\opencv\\opencv\\build\\etc\\haarcascades\\haarcascade_frontalface_alt2.xml"    
        
        #循环检测识别人脸
        while True:
            ret, frame = cap.read()   #读取一帧视频
            
            if ret is True:
                
                #图像灰化,降低计算复杂度
                frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            else:
                continue
            #使用人脸识别分类器,读入分类器
            cascade = cv2.CascadeClassifier(cascade_path)                
    
            #利用分类器识别出哪个区域为人脸
            faceRects = cascade.detectMultiScale(frame_gray, scaleFactor = 1.2, minNeighbors = 3, minSize = (32, 32))        
            if len(faceRects) > 0:                 
                for faceRect in faceRects: 
                    x, y, w, h = faceRect
                    
                    #截取脸部图像提交给模型识别这是谁
                    image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
                    faceID = model.face_predict(image)   
                    
                    #如果是“我”
                    if faceID == 0:                                                        
                        cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness = 2)
                        
                        #文字提示是谁
                        cv2.putText(frame,'liziqiang', 
                                    (x + 30, y + 30),                      #坐标
                                    cv2.FONT_HERSHEY_SIMPLEX,              #字体
                                    1,                                     #字号
                                    (255,0,255),                           #颜色
                                    2)                                     #字的线宽
                    else:
                        pass
                                
            cv2.imshow("识别朕", frame)
            
            #等待10毫秒看是否有按键输入
            k = cv2.waitKey(10)
            #如果输入q则退出循环
            if k & 0xFF == ord('q'):
                break
    
        #释放摄像头并销毁所有窗口
        cap.release()
        cv2.destroyAllWindows()

     

    好,最终实现的结果就是文章开头的时候的效果。希望能帮到你!

    有什么问题我会尽量回答!

    展开全文
  • DeepID人脸识别算法之三代

    万次阅读 多人点赞 2014-12-23 00:09:48
    DeepID人脸识别算法之三代 DeepID,目前最强人脸识别算法,已经三代。 如今,深度学习方兴未艾,大数据风起云涌,各个领域都在处于使用深度学习进行强突破的阶段,人脸识别也不例外,香港中文大学的团队使用卷积神经...

    DeepID人脸识别算法之三代

    转载请注明:http://blog.csdn.net/stdcoutzyx/article/details/42091205

    DeepID,目前最强人脸识别算法,已经三代。

    如今,深度学习方兴未艾,大数据风起云涌,各个领域都在处于使用深度学习进行强突破的阶段,人脸识别也不例外,香港中文大学的团队使用卷积神经网络学习特征,将之用于人脸识别的子领域人脸验证方面,取得了不错的效果。虽然是今年7月份才出的成果,但连发三箭,皆中靶心,使用的卷积神经网络已经改进了三次,破竹之势节节高。故而在这里将DeepID神经网络的三代进化史总结一下,以期相互讨论,互有增益。

    在说明具体的结论之前,我先进行总结式的几段文字,然后再做详细的技术说明,以防有些过来寻求科普的人看到一坨坨的公式便拂袖远去,没看到什么干货。

    1. 问题引入及算法流程

    DeepID所应用的领域是人脸识别的子领域——人脸验证,就是判断两张图片是不是同一个人。人脸验证问题很容易就可以转成人脸识别问题,人脸识别就是多次人脸验证。DeepID达到的效果都是在LFW数据集上,该数据集是wild人脸数据集,即没有经过对其的人脸,背景变化比较大。该数据集太小,很多identities都只有一张人脸,5000个人只有13000张图片。所以DeepID引入了外部数据集CelebFaces和CelebFaces+,每次模型更新都会使用更大的数据集,这在后面介绍DeepID时再细说。

    卷积神经网络在DeepID中的作用是是学习特征,即将图片输入进去,学习到一个160维的向量。然后再这个160维向量上,套用各种现成的分类器,即可得到结果。DeepID之所以有效,首先在于卷积神经网络学习到的特征的区分能力比较强,为了得到比较强的结果,DeepID采取了目前最常用的手法——增大数据集,只有大的数据集才能使得卷积神经网络训练的更加的充分。增大数据集有两种手法,第一种手法,就是采集好的数据,即CelebFaces数据集的引入。第二种手法,就是将图片多尺度多通道多区域的切分,分别进行训练,再把得到的向量连接起来,得到最后的向量。DeepID的算法流程如下:

     

    在上述的流程中,DeepID可以换为Hog,LBP等传统特征提取算法。Classifier可以是SVM,Joint Bayes,LR,NN等任意的machine learning分类算法。

    在引入外部数据集的情况下,训练流程是这样的。首先,外部数据集4:1进行切分,4那份用来训练DeepID,1那份作为训练DeepID的验证集;然后,1那份用来训练Classifier。这样划分的原因在于两层模型不能使用同一种数据进行训练,容易产生过拟合。

    如此,想必大家对DeepID的应用场景已经熟悉了,下面开始讲三代DeepID的进化。

    2. DeepID

    在这里,我假定大家对卷积神经网络已经有了基本的认识,如果没有的话,出门左转看我这篇blog:卷积神经网络http://blog.csdn.net/stdcoutzyx/article/details/41596663。

    2.1 DeepID网络结构

    DeepID是第一代,其结构与普通的卷积神经网络差不多。结构图如下:

     

    该结构与普通的卷积神经网络的结构相似,但是在隐含层,也就是倒数第二层,与Convolutional layer 4和Max-pooling layer3相连,鉴于卷积神经网络层数越高视野域越大的特性,这样的连接方式可以既考虑局部的特征,又考虑全局的特征。

    2.2 DeepID实验设置

    实验中,人脸图片的预处理方式,也就是切分方式的样例如下:

     

    在DeepID的实验过程中,使用的外部数据集为CelebFaces+,有10177人,202599张图片;8700人训练DeepID,1477人训练Joint Bayesian分类器。切分的patch(也就是上图这样的数据)数目为100,使用了五种不同的scale。每张图片最后形成的向量长度为32000,使用PCA降维到150。如此,达到97.20的效果。使用某种Transfer Learning的算法后,达到97.45%的最终效果。

    2.3 实验结论

    • 使用multi-scale patches的convnet比只使用一个只有整张人脸的patch的效果要好。
    • DeepID自身的分类错误率在40%到60%之间震荡,虽然较高,但DeepID是用来学特征的,并不需要要关注自身分类错误率。
    • 使用DeepID神经网络的最后一层softmax层作为特征表示,效果很差。
    • 随着DeepID的训练集人数的增长,DeepID本身的分类正确率和LFW的验证正确率都在增加。

    这就是DeepID第一代。

    3 DeepID2

    DeepID2相对于DeepID有了较大的提高。其主要原因在于在DeepID的基础上添加了验证信号。具体来说,原本的卷积神经网络最后一层softmax使用的是Logistic Regression作为最终的目标函数,也就是识别信号;但在DeepID2中,目标函数上添加了验证信号,两个信号使用加权的方式进行了组合。

    3.1 两种信号及训练过程

    识别信号公式如下:

     

    验证信号公式如下:

     

    由于验证信号的计算需要两个样本,所以整个卷积神经网络的训练过程也就发生了变化,之前是将全部数据切分为小的batch来进行训练。现在则是每次迭代时随机抽取两个样本,然后进行训练。训练过程如下:

     

    在训练过程中,lambda是验证信号的加权参数。M参数时动态调整的,调整策略是使最近的训练样本上的验证错误率最低。

    3.2 实验设置

    首先使用SDM算法对每张人脸检测出21个landmarks,然后根据这些landmarks,再加上位置、尺度、通道、水平翻转等因素,每张人脸形成了400张patch,使用200个CNN对其进行训练,水平翻转形成的patch跟原始图片放在一起进行训练。这样,就形成了400×160维的向量。

    这样形成的特征维数太高,所以要进行特征选择,不同于之前的DeepID直接采用PCA的方式,DeepID2先对patch进行选取,使用前向-后向贪心算法选取了25个最有效的patch,这样就只有25×160维向量,然后使用PCA进行降维,降维后为180维,然后再输入到联合贝叶斯模型中进行分类。

    DeepID2使用的外部数据集仍然是CelebFaces+,但先把CelebFaces+进行了切分,切分成了CelebFaces+A(8192个人)和CelebFaces+B(1985个人)。首先,训练DeepID2,CelebFaces+A做训练集,此时CelebFaces+B做验证集;其次,CelebFaces+B切分为1485人和500人两个部分,进行特征选择,选择25个patch。最后在CelebFaces+B整个数据集上训练联合贝叶斯模型,然后在LFW上进行测试。在上一段描述的基础上,进行了组合模型的加强,即在选取特征时进行了七次。第一次选效果最好的25个patch,第二次从剩余的patch中再选25个,以此类推。然后将七个联合贝叶斯模型使用SVM进行融合。最终达到了99.15%的结果。

    其中,选取的25个patch如下:

     

    3.3 实验结论

    • 对lambda进行调整,也即对识别信号和验证信号进行平衡,发现lambda在0.05的时候最好。使用LDA中计算类间方差和类内方差的方法进行计算。得到的结果如下:

     

    可以发现,在lambda=0.05的时候,类间方差几乎不变,类内方差下降了很多。这样就保证了类间区分性,而减少了类内区分性。如果lambda为无穷大,即只有验证信号时,类间方差和类内方差都变得很小,不利于最后的分类。

    • DeepID的训练集人数越多,最后的验证率越高。
    • 对不同的验证信号,包括L1,L2,cosin等分别进行了实验,发现L2 Norm最好。

    4 DeepID2+

    DeepID2+有如下贡献,第一点是继续更改了网络结构;第二点是对卷积神经网络进行了大量的分析,发现了几大特征,包括:+ 神经单元的适度稀疏性,该性质甚至可以保证即便经过二值化后,仍然可以达到较好的识别效果;+ 高层的神经单元对人比较敏感,即对同一个人的头像来说,总有一些单元处于一直激活或者一直抑制的状态;+ DeepID2+的输出对遮挡非常鲁棒。

    4.1 网络结构变化

    相比于DeepID2,DeepID2+做了如下三点修改:

    • DeepID层从160维提高到512维。
    • 训练集将CelebFaces+和WDRef数据集进行了融合,共有12000人,290000张图片。
    • 将DeepID层不仅和第四层和第三层的max-pooling层连接,还连接了第一层和第二层的max-pooling层。

    最后的DeepID2+的网络结构如下:

     

    上图中,ve表示监督信号(即验证信号和识别信号的加权和)。FC-n表示第几层的max-pooling。

    4.2 实验设置

    训练数据共有12000人,290000张图像。其中2000人用于在训练DeepID2+时做验证集,以及训练联合贝叶斯模型。

    4.3 实验结论

    分别使用FC-n进行实验,比较的算法包括DeepID2+、只有从FC-4反向传播下来进行训练的模型、使用少量数据的、使用小的特征向量的模型。结果如下:

     

    DeepID2选取了25个patch,DeepID2+选取了同样的25个patch,然后抽取的特征分别训练联合贝叶斯模型,得到的结果是DeepID2+平均比DeepID2提高2%。

    4.4 适度稀疏与二值化

    DeepID2+有一个性质,即对每个人,最后的DeepID层都大概有半数的单元是激活的,半数的单元是抑制的。而不同的人,激活或抑制的单元是不同的。基于此性质。使用阈值对最后输出的512维向量进行了二值化处理,发现效果降低有限。

     

    二值化后会有好处,即通过计算汉明距离就可以进行检索了。然后精度保证的情况下,可以使人脸检索变得速度更快,更接近实用场景。

    4.5 特征区分性

    存在某个神经单元,只使用普通的阈值法,就能针对某个人得到97%的正确率。不同的神经单元针对不同的人或不同的种族或不同的年龄都有很强的区分性。在这里,对每个单元的激活程度进行由高到低排序,可以得到下图所示:

     

    上图只是其中一张图示,还有针对种族、年龄等的激活分析。此处不赘述。

    但值得说的是,这种分析方法对我们很有启发。卷积神经网络的输出的含义是什么,很难解释,通过这种方法,或许可以得到一些结论。

    4.6 遮挡鲁棒性

    在训练数据中没有遮挡数据的情况下,DeepID2+自动就对遮挡有了很好的鲁棒性。有两种方式对人脸进行多种尺度的遮挡,第一种是从下往上进行遮挡,从10%-70%。第二种是不同大小的黑块随机放,黑块的大小从10×10到70×70。

     

    结论是遮挡在20%以内,块大小在30×#30以下,DeepID2+的输出的向量的验证正确率几乎不变。

     

     

     

    5 总结

    至此,DeepID的三代进化史就讲完了。简单的说一下我的感受。

    首先是卷积神经网络的作用,虽说之前听说过卷积神经网络既可以分类,也可以学习特征,但ImageNet上的卷积神经网络都是分类的,这次终于见到不关注分类错误率而关注特征的卷积神经网络。

    其次,卷积神经网络的改进方式,无非如下几种:增大网络深度和宽度,增加数据,将网络隐含层连接到前面几层来,添加其他的信号。

    再次,也是最重要的,就是DeepID在发展过程中对输出向量的分析,尤其是DeepID2+,神经网络的各个单元一直是无法解释的,但这次作者不仅试图去发现规律,还基于规律做出了一些改动,比如二值化。

    最后,卷积神经网络的鲁棒性真的很厉害。

    6 参考文献

    • [1] Sun Y, Wang X, Tang X. Deep learning face representation from predicting 10,000 classes[C]//Computer Vision and Pattern Recognition (CVPR), 2014 IEEE Conference on. IEEE, 2014: 1891-1898.
    • [2] Sun Y, Chen Y, Wang X, et al. Deep learning face representation by joint identification-verification[C]//Advances in Neural Information Processing Systems. 2014: 1988-1996.
    • [3] Sun Y, Wang X, Tang X. Deeply learned face representations are sparse, selective, and robust[J]. arXiv preprint arXiv:1412.1265, 2014.

    更多内容欢迎关注微信公众号【雨石记】。

     

    展开全文
  • opencv人脸识别
  • 人脸识别(一)——人脸识别简介

    万次阅读 多人点赞 2019-03-11 20:49:02
    当今世界智能产业不断发展,人脸识别技术发展至今也是相对很成熟的。下面就由小编来带领大家进入人脸识别的世界,在下也是学生,有很多地方也不太懂,还请各位大神多多指教。 目录 1.人脸识别简介 2.人脸识别基本...
  • Matlab实现人脸识别

    万次阅读 多人点赞 2018-06-13 21:35:23
    最近在学习matlab图像处理部分,发现人脸识别这一块非常好玩,在这里做个总结。人脸识别之一:查找图片中的人脸并用方框圈出 这种类似于智能手机拍照时,屏幕里那个框任务头部的红框。大致步骤为:获取RGB图片---&...
  • 视觉识别入门之人脸识别———— 基于FACENET的高精度人脸识别 一:项目展示: - 这是实时视频读取的展示,是可以读单张图片,或者本地视频流,抑或是实时人脸检测与分类的,至于我为什么不展示我的自拍,主要原因...
  • 人脸识别二次开发包,免费,可商用,有演示、范例、说明书
  • 利用MTCNN和facenet实现人脸检测和人脸识别

    万次阅读 多人点赞 2018-12-09 14:29:07
    利用MTCNN和facenet实现人脸检测和人脸识别 人脸检测和人脸识别技术算是目前人工智能方面应用最成熟的技术了。本博客将利用mtcnn和faceNet搭建一个实现人脸检测和人脸识别的系统。基本思路也很简单,先利用mtcnn的...
  • 人脸识别各算法详解

    万次阅读 多人点赞 2019-04-11 16:49:05
    人脸识别各算法详解 最近,由于工作需要,为了找到一款高效的认识识别算法,对各种人脸识别算法都研究了一番,以下记录的是各算法的理论基础。 一.MTCNN 本文章主要介绍MTCNN算法的流程,MTCNN主要由三个框架组成...
  • FaceNet--Google的人脸识别

    万次阅读 多人点赞 2015-06-29 21:39:22
    引入随着深度学习的出现,...并没有用传统的softmax的方式去进行分类学习,然后抽取其中某一层作为特征,而是直接进行端对端学习一个从图像到欧式空间的编码方法,然后基于这个编码再做人脸识别、人脸验证和人脸聚类。
  • 基于OpenCV3实现人脸识别(实践篇)

    万次阅读 多人点赞 2018-08-03 14:45:31
    首先了解做人脸识别的步骤 各个算法后面的原理 原理背后的相关知识的了解 人脸识别项目总遇到的问题 由于篇幅原因,后面一篇写各个算法背后的原理,原理背后的相关知识的了解,人脸识别项目总遇到的问题 首先...
  • 基于Opencv快速实现人脸识别(完整版)

    万次阅读 多人点赞 2019-06-26 12:03:06
    上篇博客:...这次进一步地研究这一块的知识,来一波真正意义上的人脸识别,查询的资料可能有点过时,但基本思想是没有毛病的,对一些函数也进行了更新,保证了功能的正常实...
  • 看完之后如有不懂,请看:关于人脸和指纹识别共同交流方案,也可以关注微信公众号:雄雄的小课堂,回复:人脸识别群获取群号,群内有直接可以运行的源码可供下载,人脸识别所需的软件群内也有!!! 人脸识别,...
  • 人脸识别人脸识别技术综述

    万次阅读 2016-09-14 13:11:12
     近年来,随着计算机技术的迅速发展,人脸自动识别技术得到广泛研究与开发,人脸识别成为近30年里模式识别和图像处理中最热门的研究主题之一。人脸识别的目的是从人脸图像中抽取人的个性化特征,并以此来识别人的身...
  • 静态人脸识别和动态人脸识别的区别   人脸识别,是基于人的脸部特征信息进行身份识别的一种生物识别技术。作为一种新型而且发展较快的技术,很多人对这门技术并没有清晰的理解和认识。比如说,人脸识别有哪些种类...
  • 然后会跟大家聊一下工业界对人脸识别技术的需求,并分享一些工业界进行大规模人脸识别的经验,常用的人脸识别算法。后会宣布一个比赛,这个比赛不仅提供了标注更准确的大规模人脸训练数据集, 而且也提供了一个非常有...
  • 人脸检测 人脸对齐 人脸识别工程,五点人脸特征识别 实时性好
  • 使用卷积神经网络(CNN)做人脸识别

    万次阅读 多人点赞 2018-08-13 17:36:26
    上回书说到了对人脸的检测,这回就开始正式进入人脸识别的阶段。 关于人脸识别,目前有很多经典的算法,当我大学时代,我的老师给我推荐的第一个算法是特征脸法,原理是先将图像灰度化,然后将图像每行首尾相接拉...
  • 在上一篇文章树莓派调用百度人脸识别API实现人脸识别,我们完成了树莓派人脸识别的基础环境配置,人脸识别功能也测试成功了,现在我们做一个小小的案例来实际应用一下,我们想树莓派人脸识别成功后,发送蓝牙串口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,674
精华内容 16,269
关键字:

人脸识别