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

    千人学习 2020-07-20 10:48:04
    当我们使用人脸识别技术来构建一个支付系统的时候,在准确性、安全性,以及实时性等方面,将会有更高的要求。 所以本课程着眼于刷脸支付系统实现上的特殊性,重点阐述了一些相关的技术,比如:开放域人脸识别、支付...
  • 利用python、tensorflow、opencv实现人脸识别(包会)!

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

     

    一,前言

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

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

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

    链接: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()

     

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

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

    展开全文
  • python基于openCV人脸识别

    千人学习 2019-10-30 14:34:06
    python 基于openCV人脸识别,简单入门级项目,初学者可以看懂。
  • 基于Opencv快速实现人脸识别(完整版)

    万次阅读 多人点赞 2019-12-31 16:22:22
    上篇博客:...这次进一步地研究这一块的知识,来一波真正意义上的人脸识别,查询的资料可能有点过时,但基本思想是没有毛病的,对一些函数也进行了更新,保证了功能的正常实...

    上篇博客:https://blog.csdn.net/beyond9305/article/details/92844258严格来说标题是有误的,只是单纯地对人脸进行了检测,而并非识别,opencv内置了检测分类器和识别器,这二者还是有很大不同的。

    这次进一步地研究这一块的知识,来一波真正意义上的人脸识别,查询的资料可能有点过时,但基本思想是没有毛病的,对一些函数也进行了更新,保证了功能的正常实现。那就开始吧:

    首先看一下本实验需要的数据集,为了简便我们只进行两个人的识别,选取了我的偶像beyond乐队的主唱黄家驹和贝斯手黄家强,这哥俩长得有几分神似,这也是对人脸识别的一个考验:

    两个文件夹,一个为训练数据集,一个为测试数据集,训练数据集中有两个文件夹0和1,之前看一些资料有说这里要遵循“slabel”命名规则,但后面处理起来比较麻烦,因为目前opencv接受的人脸识别标签为整数,那我们就直接用整数命名吧:

    为了简便,我们每个人用20张照片来训练,0代表黄家驹,1代表黄家强:

    接下来就正式开始吧:

    1. 检测人脸。这应该是最基本的,给我们一张图片,我们要先检测出人脸的区域,然后才能进行操作,opencv已经内置了很多分类检测器,我们这次用haar:

    def detect_face(img):
        #将测试图像转换为灰度图像,因为opencv人脸检测器需要灰度图像
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
        #加载OpenCV人脸检测分类器Haar
        face_cascade = cv2.CascadeClassifier('./haarcascade_frontalface_default.xml')
    
        #检测多尺度图像,返回值是一张脸部区域信息的列表(x,y,宽,高)
        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5)
    
        # 如果未检测到面部,则返回原始图像
        if (len(faces) == 0):
            return None, None
    
        #目前假设只有一张脸,xy为左上角坐标,wh为矩形的宽高
        (x, y, w, h) = faces[0]
    
        #返回图像的正面部分
        return gray[y:y + w, x:x + h], faces[0]

    2. 有了数据集和检测人脸的功能后,我们就可以进行图片预训练处理了,最后返回所有训练图片的人脸检测信息和标签:

    def prepare_training_data(data_folder_path):
        # 获取数据文件夹中的目录(每个主题的一个目录)
        dirs = os.listdir(data_folder_path)
    
        # 两个列表分别保存所有的脸部和标签
        faces = []
        labels = []
    
        # 浏览每个目录并访问其中的图像
        for dir_name in dirs:
            # dir_name(str类型)即标签
            label = int(dir_name)
            # 建立包含当前主题主题图像的目录路径
            subject_dir_path = data_folder_path + "/" + dir_name
            # 获取给定主题目录内的图像名称
            subject_images_names = os.listdir(subject_dir_path)
    
            # 浏览每张图片并检测脸部,然后将脸部信息添加到脸部列表faces[]
            for image_name in subject_images_names:
                # 建立图像路径
                image_path = subject_dir_path + "/" + image_name
                # 读取图像
                image = cv2.imread(image_path)
                # 显示图像0.1s
                cv2.imshow("Training on image...", image)
                cv2.waitKey(100)
    
                # 检测脸部
                face, rect = detect_face(image)
                # 我们忽略未检测到的脸部
                if face is not None:
                    #将脸添加到脸部列表并添加相应的标签
                    faces.append(face)
                    labels.append(label)
    
        cv2.waitKey(1)
        cv2.destroyAllWindows()
        #最终返回值为人脸和标签列表
        return faces, labels

    3. 有了脸部信息和对应标签后,我们就可以使用opencv自带的识别器来进行训练了:

    #调用prepare_training_data()函数
    faces, labels = prepare_training_data("training_data")
    
    #创建LBPH识别器并开始训练,当然也可以选择Eigen或者Fisher识别器
    face_recognizer = cv2.face.LBPHFaceRecognizer_create()
    face_recognizer.train(faces, np.array(labels))

    4.训练完毕后就可以进行预测了,在这之前我们可以设定一下预测的格式,包括用矩形框框出人脸并标出其名字,当然最后别忘了建立标签与真实姓名直接的映射表:

    #根据给定的(x,y)坐标和宽度高度在图像上绘制矩形
    def draw_rectangle(img, rect):
        (x, y, w, h) = rect
        cv2.rectangle(img, (x, y), (x + w, y + h), (128, 128, 0), 2)
    # 根据给定的(x,y)坐标标识出人名
    def draw_text(img, text, x, y):
        cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1, (128, 128, 0), 2)
    
    #建立标签与人名的映射列表(标签只能为整数)
    subjects = ["jiaju", "jiaqiang"]
    

    5.现在就可以定义我们的预测函数了:

    # 此函数识别传递的图像中的人物并在检测到的脸部周围绘制一个矩形及其名称
    def predict(test_img):
        #生成图像的副本,这样就能保留原始图像
        img = test_img.copy()
        #检测人脸
        face, rect = detect_face(img)
        #预测人脸
        label = face_recognizer.predict(face)
        # 获取由人脸识别器返回的相应标签的名称
        label_text = subjects[label[0]]
    
        # 在检测到的脸部周围画一个矩形
        draw_rectangle(img, rect)
        # 标出预测的名字
        draw_text(img, label_text, rect[0], rect[1] - 5)
        #返回预测的图像
        return img
    

    6.最后使用我们test_data中的图片进行预测并显示最终效果:

    #加载测试图像
    test_img1 = cv2.imread("test_data/test1.jpg")
    test_img2 = cv2.imread("test_data/test2.jpg")
    
    #执行预测
    predicted_img1 = predict(test_img1)
    predicted_img2 = predict(test_img2)
    
    #显示两个图像
    cv2.imshow(subjects[0], predicted_img1)
    cv2.imshow(subjects[1], predicted_img2)

    来看看识别结果如何:

    这就是人脸识别最基本的流程,后续还会进一步的研究,下一篇我们将讨论本次实验的一些细节和注意事项,算是对本篇的一次挖掘和总结吧。最后附上完整代码:

    # # -*- coding:utf-8 -*-
    import cv2
    import os
    import numpy as np
    
    # 检测人脸
    def detect_face(img):
        #将测试图像转换为灰度图像,因为opencv人脸检测器需要灰度图像
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
        #加载OpenCV人脸检测分类器Haar
        face_cascade = cv2.CascadeClassifier('./haarcascade_frontalface_default.xml')
    
        #检测多尺度图像,返回值是一张脸部区域信息的列表(x,y,宽,高)
        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5)
    
        # 如果未检测到面部,则返回原始图像
        if (len(faces) == 0):
            return None, None
    
        #目前假设只有一张脸,xy为左上角坐标,wh为矩形的宽高
        (x, y, w, h) = faces[0]
    
        #返回图像的正面部分
        return gray[y:y + w, x:x + h], faces[0]
    
    
    # 该函数将读取所有的训练图像,从每个图像检测人脸并将返回两个相同大小的列表,分别为脸部信息和标签
    def prepare_training_data(data_folder_path):
        # 获取数据文件夹中的目录(每个主题的一个目录)
        dirs = os.listdir(data_folder_path)
    
        # 两个列表分别保存所有的脸部和标签
        faces = []
        labels = []
    
        # 浏览每个目录并访问其中的图像
        for dir_name in dirs:
            # dir_name(str类型)即标签
            label = int(dir_name)
            # 建立包含当前主题主题图像的目录路径
            subject_dir_path = data_folder_path + "/" + dir_name
            # 获取给定主题目录内的图像名称
            subject_images_names = os.listdir(subject_dir_path)
    
            # 浏览每张图片并检测脸部,然后将脸部信息添加到脸部列表faces[]
            for image_name in subject_images_names:
                # 建立图像路径
                image_path = subject_dir_path + "/" + image_name
                # 读取图像
                image = cv2.imread(image_path)
                # 显示图像0.1s
                cv2.imshow("Training on image...", image)
                cv2.waitKey(100)
    
                # 检测脸部
                face, rect = detect_face(image)
                # 我们忽略未检测到的脸部
                if face is not None:
                    #将脸添加到脸部列表并添加相应的标签
                    faces.append(face)
                    labels.append(label)
    
        cv2.waitKey(1)
        cv2.destroyAllWindows()
        #最终返回值为人脸和标签列表
        return faces, labels
    
    #调用prepare_training_data()函数
    faces, labels = prepare_training_data("training_data")
    
    #创建LBPH识别器并开始训练,当然也可以选择Eigen或者Fisher识别器
    face_recognizer = cv2.face.LBPHFaceRecognizer_create()
    face_recognizer.train(faces, np.array(labels))
    
    #根据给定的(x,y)坐标和宽度高度在图像上绘制矩形
    def draw_rectangle(img, rect):
        (x, y, w, h) = rect
        cv2.rectangle(img, (x, y), (x + w, y + h), (128, 128, 0), 2)
    # 根据给定的(x,y)坐标标识出人名
    def draw_text(img, text, x, y):
        cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1, (128, 128, 0), 2)
    
    #建立标签与人名的映射列表(标签只能为整数)
    subjects = ["jiaju", "jiaqiang"]
    
    # 此函数识别传递的图像中的人物并在检测到的脸部周围绘制一个矩形及其名称
    def predict(test_img):
        #生成图像的副本,这样就能保留原始图像
        img = test_img.copy()
        #检测人脸
        face, rect = detect_face(img)
        #预测人脸
        label = face_recognizer.predict(face)
        # 获取由人脸识别器返回的相应标签的名称
        label_text = subjects[label[0]]
    
        # 在检测到的脸部周围画一个矩形
        draw_rectangle(img, rect)
        # 标出预测的名字
        draw_text(img, label_text, rect[0], rect[1] - 5)
        #返回预测的图像
        return img
    
    #加载测试图像
    test_img1 = cv2.imread("test_data/test1.jpg")
    test_img2 = cv2.imread("test_data/test2.jpg")
    
    #执行预测
    predicted_img1 = predict(test_img1)
    predicted_img2 = predict(test_img2)
    
    #显示两个图像
    cv2.imshow(subjects[0], predicted_img1)
    cv2.imshow(subjects[1], predicted_img2)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

    ps:6.30号就是家驹去世二十六周年了,希望成都的小伙伴们能聚一下,让我们一起缅怀。

    如果文章对您有一点点帮助,还请打赏一二,您的鼓励将是我前进的不竭动力

    公众号为“非著名IT表演艺术家”,比较中二,就是灵光一闪,然后这个名字就冒出来了……

    展开全文
  • 本课程演示了一个完整的人脸识别实战项目,包括一套完整的源码。 课程涵盖:人脸检测、特征点标定、人脸对齐、人脸比图、数据标注和模型训练等15个技术专题。
  • 人脸识别&ORC的Demo

    2019-01-06 19:22:56
    一.用到的jar包: face_sdk-1.3.4.jar json-20160810.jar ocr_sdk-1.3.4.jar 下载地址:https://files.cnblogs.com/files/DreamDrive/ocrdemo.rar 二.测试代码 FaceDetect.java ... 3 impo...

    一.用到的jar包:

    face_sdk-1.3.4.jar

    json-20160810.jar

    ocr_sdk-1.3.4.jar

    下载地址:https://files.cnblogs.com/files/DreamDrive/ocrdemo.rar

    二.测试代码

    FaceDetect.java

     1 import java.util.HashMap;
     2 
     3 import org.json.JSONObject;
     4 
     5 import com.baidu.aip.face.AipFace;
     6 /**
     7  * 百度云人脸检测demo
     8  * @author Administrator
     9  *
    10  */
    11 public class FaceDetect {
    12 
    13     private static AipFace apiFace=null;
    14     final static String APP_ID="9662379";
    15     final static String AIP_KEY="BGczNjdkZs5UQxUBlHzDWP6R";
    16     final static String AIP_TOKEN="lLL5C2nItGPnuXME2GM2PzfDRNtrCkRi";
    17     static {
    18         if(apiFace==null){
    19             apiFace=new AipFace(APP_ID,AIP_KEY,AIP_TOKEN);
    20         }
    21     }
    22     public void faceDetect(String path){
    23         HashMap<String,String> options=new HashMap<String,String>();
    24         options.put("max_face_num", "5");
    25         JSONObject response = apiFace.detect(path,options);
    26         System.out.println(response.toString());
    27 
    28         // 参数为本地图片文件二进制数组
    29 //        byte[] file = readImageFile(path);    // readImageFile函数仅为示例
    30 //        JSONObject response = apiFace.detect(file,options);
    31 //        System.out.println(response.toString());
    32     }
    33     
    34     public static void main(String[] args){
    35         new FaceDetect().faceDetect("n:/timg3.jpg");
    36     }
    37 }

    OcrDemo.java

     1 import java.util.HashMap;
     2 import org.json.JSONObject;
     3 import com.baidu.aip.ocr.AipOcr;
     4 public class OcrDemo {
     5 
     6     
     7     //设置APPID/AK/SK
     8     public static final String APP_ID = "9695214";
     9     public static final String API_KEY = "HxqwTu1M85G1UrG9DZKTNQzN";
    10     public static final String SECRET_KEY = "GVy7ah7MTRUczxS4hCuUvfCCV8oloRZX";
    11 
    12     public static void main(String[] args) {
    13         // 初始化一个OcrClient
    14         AipOcr client = new AipOcr(APP_ID, API_KEY, SECRET_KEY);
    15 
    16         // 可选:设置网络连接参数
    17         client.setConnectionTimeoutInMillis(2000);
    18         client.setSocketTimeoutInMillis(60000);
    19         HashMap<String, String> params=new HashMap<String,String>();
    20         // 调用身份证识别接口
    21         String idFilePath = "n:/shenfenzheng1.jpg";
    22         JSONObject idcardRes = client.idcard(idFilePath, true,params);
    23         System.out.println(idcardRes.toString(2));
    24 
    25         // 调用银行卡识别接口
    26         String bankFilePath = "n:/bankcard.png";
    27         JSONObject bankRes = client.bankcard(bankFilePath);
    28         System.out.println(bankRes.toString(2));
    29 
    30         // 调用通用识别接口
    31         String genFilePath = "n:/words.png";
    32         JSONObject genRes = client.basicGeneral(genFilePath, new HashMap<String, String>());
    33         System.out.println(genRes.toString(2));
    34 
    35         // 调用通用识别(含位置信息)接口
    36 //        String genFilePath = "test_general.jpg";
    37 //        JSONObject genRes = client.general(genFilePath, new HashMap<String, String>());
    38 //        System.out.println(genRes.toString(2));
    39     }
    40 }

     

    展开全文
  • 人脸识别demo

    2020-07-28 23:32:17
    百度OCR人脸识别小代码,请改一下自己的参数。如有不懂请在百度AI上看下文档
  • 百度在线人脸识别API简单实现教程

    万次阅读 2019-05-22 00:00:31
    这里,记录一下百度人脸识别在线API的调用,语言是python2.7,供大家一起学习参考 本教程目录如下 1.申请百度人脸识别应用 2.获取token 3.图片的base64编码 4.人脸识别 5.结果绘制与可视化 6.实现的完整源...

    这里,记录一下百度人脸识别在线API的调用,语言是python2.7,供大家一起学习参考

    本教程目录如下

    1.申请百度人脸识别应用

    2.获取token

    3.图片的base64编码

    4.人脸识别

    5.结果绘制与可视化

    6.实现的完整源代码


    1.申请百度人脸识别应用

    首先需要在百度智能云平台登录

    https://console.bce.baidu.com/ai/?_=1558444274128&fromai=1#/ai/face/overview/index

    登陆后创建应用,创建的应用是人脸识别的,默认已帮你勾选上了相关功能。

    创建应用后,点击管理应用,你就可以获取API Key和Secret Key

    2.获取token

    现在就可以编写代码调用在线的人脸检测API了

    首先是获取token,用于校验,代码如下,注意换成自己申请的API Key和Secret Key

    def getToken():
        global token
        # client_id 为官网获取的AK, client_secret 为官网获取的SK
        host = 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=你的API Key&client_secret=你的Secret Key'
        request = urllib2.Request(host)
        request.add_header('Content-Type', 'application/json; charset=UTF-8')
        response = urllib2.urlopen(request)
        content = response.read()
        if (content):
            token=json.loads(content)['access_token']

    3.图片的base64编码

    上传的用于检测的图片需经过Base64编码。需要注意的是,图片的base64编码是不包含图片头的,代码如下:

    def imgToBase64(imgPath):
        with open(imgPath, "rb") as f:  # 转为二进制格式
            base64_data = base64.b64encode(f.read())  # 使用base64进行加密
            return base64_data

    4.人脸识别

    最后就是调用接口进行人脸识别了

    def faceDetect(imgBase64):
        '''
        人脸检测与属性分析
        '''
        request_url = "https://aip.baidubce.com/rest/2.0/face/v3/detect"
        request_url = request_url + "?access_token=" + token
        request = urllib2.Request(request_url)
        request.add_header('Content-Type', 'application/json')
        data = {"image": imgBase64, "image_type": "BASE64","face_field":"age,beauty,expression,face_shape,gender"}
        response = urllib2.urlopen(request, urllib.urlencode(data))
        content = response.read()
        if content:
            return content

    这个函数中输入的是图片的base64编码,请求的参数中比较重要的是那个face_field,默认只返回人脸框的位置、概率和旋转角度,age(年龄预测),beauty(颜值打分),expression(表情)等更多属性,需要在这个参数中添加,具体的请参考官方说明文档:http://ai.baidu.com/docs#/Face-Detect-V3/top

    5.结果绘制与可视化

    人脸识别最后返回的是json数据,但我们往往需要画个框框,把人脸框出来,同时把一些预测的属性也标注上,这个代码我已经附在最后面了。

    最终实现的效果如下:

     

     

     

    6.实现的完整源代码

    下面我附上实现这些功能的完整代码:

    #coding:utf-8
    import urllib,urllib2, sys
    import ssl
    import json
    import base64
    import cv2
    global token
    
    def getToken():
        global token
        # client_id 为官网获取的AK, client_secret 为官网获取的SK
        host = 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=你的API Key&client_secret=你的Secret Key'
        request = urllib2.Request(host)
        request.add_header('Content-Type', 'application/json; charset=UTF-8')
        response = urllib2.urlopen(request)
        content = response.read()
        if (content):
            token=json.loads(content)['access_token']
    
    def faceDetect(imgBase64):
        '''
        人脸检测与属性分析
        '''
        request_url = "https://aip.baidubce.com/rest/2.0/face/v3/detect"
        request_url = request_url + "?access_token=" + token
        request = urllib2.Request(request_url)
        request.add_header('Content-Type', 'application/json')
        data = {"image": imgBase64, "image_type": "BASE64","face_field":"age,beauty,expression,face_shape,gender"}
        response = urllib2.urlopen(request, urllib.urlencode(data))
        content = response.read()
        if content:
            return content
    
    def imgToBase64(imgPath):
        with open(imgPath, "rb") as f:  # 转为二进制格式
            base64_data = base64.b64encode(f.read())  # 使用base64进行加密
            return base64_data
    
    
    if __name__=="__main__":
    
        getToken()
        imgPath=r"C:\Users\lee\Pictures\lena.jpg"
        result=json.loads(faceDetect(imgToBase64(imgPath)))['result']
        face_list=result['face_list'][0]
        location=face_list['location']
        age=face_list['age']
        beauty=face_list['beauty']
        expression=face_list['expression']['type']
        gender=face_list['gender']['type']
    
        img = cv2.imread(imgPath, cv2.IMREAD_COLOR)
        leftTopX=int(location['left'])
        leftTopY=int(location['top'])
        rightBottomX=int(leftTopX+int(location['width']))
        rightBottomY = int(leftTopY + int(location['height']))
        cv2.rectangle(img, (leftTopX, leftTopY), (rightBottomX, rightBottomY), (0, 255, 0), 2)
        font = cv2.FONT_HERSHEY_SIMPLEX
        # 第一个坐标表示起始位置
        cv2.putText(img,"age:"+str(age),(0, 20),font, 0.5, (200, 255, 255), 1)
        cv2.putText(img, "gender:" + gender.encode("utf-8"), (0, 40), font, 0.5, (200, 255, 255), 1)
        cv2.putText(img, "beauty:" + str(beauty), (0, 60), font, 0.5, (200, 255, 255), 1)
        cv2.putText(img, "expression:" + str(expression), (0, 80), font, 0.5, (200, 255, 255), 1)
        cv2.imshow('image', img)
        cv2.waitKey(0)
    
        print("end")

     

     

     

     

    展开全文
  • 其实很好理解,FMR就是识别错了(这个是前提),但是系统判定为正确的比例 FMR(False Non-Match Rate):错误没有匹配率 FNMR是识别对了(这个是前提),但是系统判定为错误的比例 EER(Equal Error Rate):等错误率 ...
  • opencv(人脸检测和识别

    万次阅读 多人点赞 2018-11-05 13:20:08
    Opencv的人脸检测函数,定义了具体可跟踪对象类型的数据文件。 Haar级联分类器,通过对比分析相邻图像区域来判断给定图像或子图像与已知对象是否匹配。 两个图像的相似程度可以通过它们对应特征的欧式距离来...
  • 有一个月没更新文章了,看到每天还有新朋友关注,觉得还是要多分享才好,今天来聊聊我理解的人脸识别人脸识别,让计算机告诉我这个镜头前的人脸是谁? 人脸识别,通过摄像头捕捉到人脸,将人脸部分截取出...
  • 人脸识别原理

    千次阅读 2019-09-20 17:10:21
    人脸识别主要分为人脸检测(face detection)、特征提取(feature extraction)和人脸识别(face recognition)三个过程。 人脸识别又可以分为两个大类:一类是确认,这是人脸图像与数据库中已存的该人图像比对的...
  • Matlab实现人脸识别

    万次阅读 多人点赞 2018-06-13 21:45:59
    最近在学习matlab图像处理部分,发现人脸识别这一块非常好玩,在这里做个总结。人脸识别之一:查找图片中的人脸并用方框圈出 这种类似于智能手机拍照时,屏幕里那个框任务头部的红框。大致步骤为:获取RGB图片---&...
  • 人脸识别(一)——人脸识别简介

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

    万次阅读 2019-01-07 08:53:50
    伴随着物联网、大数据、人工智能技术的日益成熟,人脸识别技术快速落地于各种智能化应用场景,其中人脸识别智能门禁在智慧社区中发挥着非常重要的作用。业主不需携带钥匙也不用刷卡,只要刷脸就能进出小区,不但快捷...
  • 人脸识别主要算法原理

    万次阅读 多人点赞 2012-09-03 15:07:39
    人脸识别主要算法原理 主流的人脸识别技术基本上可以归结为三类,即:基于几何特征的方法、基于模板的方法和基于模型的方法。 1. 基于几何特征的方法是最早、最传统的方法,通常需要和其他算法结合才能有比较好的...
  • 深入浅出人脸识别原理

    万次阅读 多人点赞 2018-08-02 14:56:34
    前不久Iphone X发布,革命性的取消了TouchID(指纹识别),而添加了更酷的 FaceID(人脸识别) 模块,FaceID 不简单的运用在解锁上,还可以在支付,表情等场景中应用,给开发者带来更酷更丰富的应用,Iphone X 在多个...
  • 看完之后如有不懂,请看:关于人脸和指纹识别共同交流方案,也可以关注微信公众号:雄雄的小课堂,回复:人脸识别群获取群号,群内有直接可以运行的源码可供下载,人脸识别所需的软件群内也有!!! 人脸识别,...
  • Android使用OpenCV实现「人脸检测」和「人脸识别

    万次阅读 多人点赞 2016-11-25 09:54:58
    Android使用OpenCV实现「人脸检测」和「人脸识别」DEMOOpenCV+JavaCV实现人脸识别—————————-分割线———————————效果图 先上效果图,不好弄gif 在网上找了在Android平台上使用OpenCV相关的教程,...
  • OpenCV实践之路——人脸识别之三识别自己的脸

    万次阅读 多人点赞 2017-11-19 13:00:15
    在之前OpenCV实践之路——人脸识别之一数据收集和预处理和OpenCV实践之路——人脸识别之二模型训练两篇博客中,已经把人脸识别的整个流程全部交代清楚了。包括今天这篇人脸识别方面的内容都已经在上述第二篇博客中的...
1 2 3 4 5 ... 20
收藏数 88,333
精华内容 35,333
关键字:

人脸识别