精华内容
下载资源
问答
  • OpenCV的contrib模板中有一个FaceRecognizer类,它实现以上这些人脸识别算法。 1 2 3 4 initModule_contrib(); model= Algorithm::create(facerecAlgorithm); model->train(preprocessedFaces, faceLabels); 这一...

    主要有以下步骤:

    1、人脸检测

    2、人脸预处理

    3、从收集的人脸训练机器学习算法

    5、收尾工作

    人脸检测算法:

    基于Haar的脸部检测器的基本思想是,对于面部正面大部分区域而言,会有眼睛所在区域应该比前额和脸颊更暗,嘴巴应该比脸颊更暗等情形。它通常执行大约20个这样的比较来决定所检测的对象是否为人脸,实际上经常会做上千次。

    基于LBP的人脸检测器基本思想与基于Haar的人脸检测器类似,但它比较的是像素亮度直方图,例如,边缘、角落和平坦区域的直方图。

    这两种人脸检测器可通过训练大的图像集找到人脸,这些图像集在opencv中存在XML文件中以便后续使用。

    这些级联分类检测器通常至少需使用1000个独特的人脸图像和10000个非人脸图像作为训练,训练时间一般LBP要几个小时,

    Haar要一个星期。

    项目中的关键代码如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    initDetectors

    faceCascade.load(faceCascadeFilename);

    eyeCascade1.load(eyeCascadeFilename1);

    eyeCascade2.load(eyeCascadeFilename2);

    initWebcam

    videoCapture.open(cameraNumber);

    cvtColor(img, gray, CV_BGR2GRAY);

    //有需要则缩小图片使检测运行更快,之后要恢复原来大小

    resize(gray, inputImg, Size(scaledWidth, scaledHeight));

    equalizeHist(inputImg, equalizedImg);

    cascade.detectMultiScale(equalizedImg......);

    人脸预处理:

    实际中通常训练(采集图像)和测试(来自摄像机图像)的图像会有很大不同,受(如光照、人脸方位、表情等),

    结果会很差,因此用于训练的数据集很重要。

    人脸预处理目的是减少这类问题,有助于提高整个人脸识别系统的可靠性。

    人脸预处理的最简单形式就是使用equalizeHist()函数做直方图均衡,这与人脸检测那步一样。

    实际中,为了让检测算法更可靠,会使用面部特征检测(如,检测眼睛、鼻子、嘴巴和眉毛),本项目只使用眼睛检测。

    使用OpenCV自带的训练好的眼部探测器。如,正面人脸检测完毕后,得到一个人脸,在使用眼睛检测器提取人脸的左眼区域和右眼区域,并对每个眼部区域进行直方图均衡。

    这步涉及的操作有以下内容:

    1、几何变换和裁剪

    人脸对齐很重要,旋转人脸使眼睛保持水平,缩放人脸使眼睛之间距离始终相同,平移人脸使眼睛总是在所需高度上水平居中,

    裁剪人脸外围(如图像背景、头发、额头、耳朵和下巴)。

    2、对人脸左侧和右侧分别用直方图均衡

    3、平滑

    用双边滤波器来减少图像噪声

    4、椭圆掩码

    将剩余头发和人脸图像背景去掉

    项目中的关键代码如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    detectBothEyes(const Mat &face, CascadeClassifier &eyeCascade1, CascadeClassifier &eyeCascade2,

    Point &leftEye, Point &rightEye, Rect*searchedLeftEye, Rect*searchedRightEye);

    topLeftOfFace= face(Rect(leftX, topY, widthX, heightY));

    //在左脸区域内检测左眼

    detectLargestObject(topLeftOfFace, eyeCascade1, leftEyeRect, topLeftOfFace.cols);

    //右眼类似,这样眼睛中心点就得到了

    leftEye= Point(leftEyeRect.x+ leftEyeRect.width/2, leftEyeRect.y+ leftEyeRect.height/2);

    //再得到两眼的中点,然后计算两眼之间的角度

    Point2f eyesCenter= Point2f( (leftEye.x+ rightEye.x)* 0.5f, (leftEye.y+ rightEye.y)* 0.5f );

    //仿射扭曲(Affine Warping)需要一个仿射矩阵

    rot_mat= getRotationMatrix2D(eyesCenter, angle, scale);

    //现在可变换人脸来得到检测到的双眼出现在人脸的所需位置

    warpAffine(gray, warped, rot_mat, warped.size());

    //先对人脸左侧和右侧分开进行直方图均衡

    equalizeHist(leftSide, leftSide);

    equalizeHist(rightSide, rightSide);

    //再合并,这里合并时左侧1/4和右侧1/4直接取像素值,中间的2/4区域像素值通过一定计算进行处理。

    //双边滤波

    bilateralFilter(warped, filtered,0,20.0,2.0);

    //采用椭圆掩码来删除一些区域

    filtered.copyTo(dstImg, mask);

    收集并训练人脸:

    一个好的数据集应包含人脸变换的各种情形,这些变化可能出现在训练集中。如只测试正面人脸,则只需训练图像有完全正面人脸即可。

    因此一个好的训练集应包含很多实际情形。

    本项目收集的图像之间至少有一秒的间隔,使用基于L2范数的相对错误评价标准来比较两幅图像素之间的相似性。

    1

    2

    errorL2= norm(A, B, CV_L2);

    similarity= errorL2/ (double)(A.rows* A.cols);

    再与收集新人脸的阈值相比来决定是否收集这次图像。

    可用很多技巧来获取更多的训练数据,如,使用镜像人脸、加入随机噪声、改变人脸图像的一些像素、旋转等。

    1

    2

    //翻转

    flip(preprocessedFace, mirroredFace,1);

    对每个人收集到足够多的人脸图像后,接下来必须选择适合人脸识别的机器学习算法,通过它来学习收集的数据,从而训练出一个人脸识别系统。

    人脸识别算法:

    1、特征脸,也称PCA(主成分分析)

    2、Fisher脸,也称LDA(线性判别分析)

    3、局部二值模式直方图(Local Binary Pattern Histograms,LBPH)

    OpenCV提供了CV::Algorithm类,该类有几种不同的算法,用其中一种算法就可以完成简单而通用的人脸识别。

    OpenCV的contrib模板中有一个FaceRecognizer类,它实现以上这些人脸识别算法。

    1

    2

    3

    4

    initModule_contrib();

    model= Algorithm::create(facerecAlgorithm);

    model->train(preprocessedFaces, faceLabels);

    这一代码将执行所选人脸识别的整个训练算法。

    人脸识别:

    1、人脸识别:通过人脸来识别这个人

    可以简单调用FaceRecognizer::predict()函数来识别照片中的人,

    int identity = model->predict(preprocessedFace);

    它带来的问题是它总能预测给定的人(即使输入图像不属于训练集中的人)。

    解决此问题的办法是制定置信度标准,置信度过低则可判读是一个不认识的人。

    2、人脸验证:验证图像中是否有想找的人

    为了验证是否可靠,或者说系统是否能对一个不认识的人进行正确识别,这需要进行人脸验证。

    这里计算置信度的方法是:

    使用特征向量和特征值重构人脸图,然后将输入的图像与重构图进行比较。如果一个人在训练集中有多张人脸图,用特征向量和特征

    值重构后应该有非常好的效果,如果没有则差别很大,表明它可能是一个未知的人脸。

    subspaceProject()函数将人脸图像映射到特征空间,再用subspaceReconstruct()函数从特征空间重构图像。

    收尾:交互式GUI

    利用OpenCV函数很容易绘制一些组件,鼠标点击等。

    以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,同时也希望多多支持服务器之家!

    原文链接:http://www.cnblogs.com/ht-beyond/p/5188234.html

    展开全文
  • 一、dlib以及opencv-python库安装介于我使用的是jupyter notebook,所以在安装dlib和opencv-python时是在这个命令行安装的dlib安装方法:1.若可以,直接使用上图所示命令行输入以下命令:pip install cmakepip ...

    一、dlib以及opencv-python库安装

    介于我使用的是jupyter notebook,所以在安装dlib和opencv-python时是在

    2020070111443339.jpg

    这个命令行安装的

    dlib安装方法:

    1.若可以,直接使用上图所示命令行输入以下命令:

    pip install cmake

    pip install boost

    pip install dlib

    若安装了visual studio2019应该就可以直接pip install dlib,至少我是这样

    由于很多在执行第三句时都会报错,所以这里提供第二种办法

    2.去dlib官网:http://dlib.net/ 或者 https://github.com/davisking/dlib 下载压缩包

    下载完成后,解压缩

    在安装dlib前需要安装Boost和Cmake,dlib19之后你需要安装vs2015以上的IDE,本人是安装的vs2019,(建议先安装好VS之后再安装Cmake和 boost)

    Cmake安装

    我下的是

    2020070111443340.png

    直接安装之后,配置环境变量

    Boost下载

    安装boost:下载地址:http://www.boost.org/

    2020070111443341.png

    如果vs安装的是2015以上的版本,可以直接进行下一步,最好安装最新版本,不然会找不到b2命令

    下载之后将其解压缩,进入boost_1_73_0文件夹中,找到bootstrap.bat批处理文件,双击运行,等待运行完成后(命令行自动消失)会生成两个文件b2.exe和bjam.exe

    2020070111443442.png

    然后将这两个文件复制到boost_1_73_0根文件夹下:

    同样开启一个命令行,定位到这个文件夹,运行命令:

    b2 install

    这个安装需要一段时间,耐心等候。

    利用b2编译库文件:

    b2 -a –with-python address-model=64 toolset=msvc runtime-link=static

    之前你cmake下载的64位这里(address-model)写64,如果是32位的就把之前的64改成32

    安装完成后配置boost环境变量

    安装dlib

    进入你的dlib解压路径,输入python setup.py install

    成功之后会在文件夹中看见dlib和dlib.egg-info ,将这两个文件夹复制到你的python安装的目录下的Lib文件中:

    —>例如我的python环境为python2.7,

    —>所以将其放在python2-7文件夹的Python2-7\Lib\site-packages中

    —>这时,就已经完成了dlib的配置

    opencv-python安装方法

    在Anaconda Prompt下输入以下命令

    pip install opencv-python

    但如果一直失败,建议在Anaconda Prompt下输入以下命令

    pip install -i https://pypi.tuna.tsinghua.edu.cn/simple opencv-python

    二、dlib的68点模型

    dlib的68点模型,使用网络上大神训练好的特征预测器,用来进行python代码人脸识别的特征预测。

    三、Python实现人脸识别&表情判别

    """

    从视屏中识别人脸,并实时标出面部特征点

    """

    import sys

    import dlib # 人脸识别的库dlib

    import numpy as np # 数据处理的库numpy

    import cv2 # 图像处理的库OpenCv

    class face_emotion():

    def __init__(self):

    # 使用特征提取器get_frontal_face_detector

    self.detector = dlib.get_frontal_face_detector()

    # dlib的68点模型,使用作者训练好的特征预测器

    self.predictor = dlib.shape_predictor("F:/face.dat")

    # 建cv2摄像头对象,这里使用电脑自带摄像头,如果接了外部摄像头,则自动切换到外部摄像头

    self.cap = cv2.VideoCapture(0)

    # 设置视频参数,propId设置的视频参数,value设置的参数值

    self.cap.set(3, 480)

    # 截图screenshoot的计数器

    self.cnt = 0

    def learning_face(self):

    # 眉毛直线拟合数据缓冲

    line_brow_x = []

    line_brow_y = []

    # cap.isOpened() 返回true/false 检查初始化是否成功

    while (self.cap.isOpened()):

    # cap.read()

    # 返回两个值:

    # 一个布尔值true/false,用来判断读取视频是否成功/是否到视频末尾

    # 图像对象,图像的三维矩阵

    flag, im_rd = self.cap.read()

    # 每帧数据延时1ms,延时为0读取的是静态帧

    k = cv2.waitKey(1)

    # 取灰度

    img_gray = cv2.cvtColor(im_rd, cv2.COLOR_RGB2GRAY)

    # 使用人脸检测器检测每一帧图像中的人脸。并返回人脸数rects

    faces = self.detector(img_gray, 0)

    # 待会要显示在屏幕上的字体

    font = cv2.FONT_HERSHEY_SIMPLEX

    # 如果检测到人脸

    if (len(faces) != 0):

    # 对每个人脸都标出68个特征点

    for i in range(len(faces)):

    # enumerate方法同时返回数据对象的索引和数据,k为索引,d为faces中的对象

    for k, d in enumerate(faces):

    # 用红色矩形框出人脸

    cv2.rectangle(im_rd, (d.left(), d.top()), (d.right(), d.bottom()), (0, 0, 255))

    # 计算人脸热别框边长

    self.face_width = d.right() - d.left()

    # 使用预测器得到68点数据的坐标

    shape = self.predictor(im_rd, d)

    # 圆圈显示每个特征点

    for i in range(68):

    cv2.circle(im_rd, (shape.part(i).x, shape.part(i).y), 2, (0, 255, 0), -1, 8)

    # cv2.putText(im_rd, str(i), (shape.part(i).x, shape.part(i).y), cv2.FONT_HERSHEY_SIMPLEX, 0.5,

    # (255, 255, 255))

    # 分析任意n点的位置关系来作为表情识别的依据

    mouth_width = (shape.part(54).x - shape.part(48).x) / self.face_width # 嘴巴咧开程度

    mouth_higth = (shape.part(66).y - shape.part(62).y) / self.face_width # 嘴巴张开程度

    # print("嘴巴宽度与识别框宽度之比:",mouth_width_arv)

    # print("嘴巴高度与识别框高度之比:",mouth_higth_arv)

    # 通过两个眉毛上的10个特征点,分析挑眉程度和皱眉程度

    brow_sum = 0 # 高度之和

    frown_sum = 0 # 两边眉毛距离之和

    for j in range(17, 21):

    brow_sum += (shape.part(j).y - d.top()) + (shape.part(j + 5).y - d.top())

    frown_sum += shape.part(j + 5).x - shape.part(j).x

    line_brow_x.append(shape.part(j).x)

    line_brow_y.append(shape.part(j).y)

    # self.brow_k, self.brow_d = self.fit_slr(line_brow_x, line_brow_y) # 计算眉毛的倾斜程度

    tempx = np.array(line_brow_x)

    tempy = np.array(line_brow_y)

    z1 = np.polyfit(tempx, tempy, 1) # 拟合成一次直线

    self.brow_k = -round(z1[0], 3) # 拟合出曲线的斜率和实际眉毛的倾斜方向是相反的

    brow_hight = (brow_sum / 10) / self.face_width # 眉毛高度占比

    brow_width = (frown_sum / 5) / self.face_width # 眉毛距离占比

    # print("眉毛高度与识别框高度之比:",round(brow_arv/self.face_width,3))

    # print("眉毛间距与识别框高度之比:",round(frown_arv/self.face_width,3))

    # 眼睛睁开程度

    eye_sum = (shape.part(41).y - shape.part(37).y + shape.part(40).y - shape.part(38).y +

    shape.part(47).y - shape.part(43).y + shape.part(46).y - shape.part(44).y)

    eye_hight = (eye_sum / 4) / self.face_width

    # print("眼睛睁开距离与识别框高度之比:",round(eye_open/self.face_width,3))

    # 分情况讨论

    # 张嘴,可能是开心或者惊讶

    if round(mouth_higth >= 0.03):

    if eye_hight >= 0.056:

    cv2.putText(im_rd, "amazing", (d.left(), d.bottom() + 20), cv2.FONT_HERSHEY_SIMPLEX,

    0.8,

    (0, 0, 255), 2, 4)

    else:

    cv2.putText(im_rd, "happy", (d.left(), d.bottom() + 20), cv2.FONT_HERSHEY_SIMPLEX, 0.8,

    (0, 0, 255), 2, 4)

    # 没有张嘴,可能是正常和生气

    else:

    if self.brow_k <= -0.3:

    cv2.putText(im_rd, "angry", (d.left(), d.bottom() + 20), cv2.FONT_HERSHEY_SIMPLEX, 0.8,

    (0, 0, 255), 2, 4)

    else:

    cv2.putText(im_rd, "nature", (d.left(), d.bottom() + 20), cv2.FONT_HERSHEY_SIMPLEX, 0.8,

    (0, 0, 255), 2, 4)

    # 标出人脸数

    cv2.putText(im_rd, "Faces: " + str(len(faces)), (20, 50), font, 1, (0, 0, 255), 1, cv2.LINE_AA)

    else:

    # 没有检测到人脸

    cv2.putText(im_rd, "No Face", (20, 50), font, 1, (0, 0, 255), 1, cv2.LINE_AA)

    # 添加说明

    im_rd = cv2.putText(im_rd, "S: screenshot", (20, 400), font, 0.8, (0, 0, 255), 1, cv2.LINE_AA)

    im_rd = cv2.putText(im_rd, "Q: quit", (20, 450), font, 0.8, (0, 0, 255), 1, cv2.LINE_AA)

    # 按下s键截图保存

    if (k == ord('s')):

    self.cnt += 1

    cv2.imwrite("screenshoot" + str(self.cnt) + ".jpg", im_rd)

    # 按下q键退出

    if (k == ord('q')):

    break

    # 窗口显示

    cv2.imshow("camera", im_rd)

    # 释放摄像头

    self.cap.release()

    # 删除建立的窗口

    cv2.destroyAllWindows()

    if __name__ == "__main__":

    my_face = face_emotion()

    my_face.learning_face()

    2020070111443443.jpg

    2020070111443444.jpg

    2020070111443445.jpg

    2020070111443446.jpg

    四、参考文章

    到此这篇关于Python+Dlib+Opencv实现人脸采集并表情判别的文章就介绍到这了,更多相关Python Dlib Opencv 人脸采集内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • opencv人脸表情识别

    2020-12-28 16:01:46
    前一段时间,我写了一篇关于线性判别分析的文章,这是一种通常用于降维和分类的统计方法。它是由伟大的统计学家RA Fisher爵士发明的,他在1936年发表的论文“在分类学问题中使用多次测量”中成功地将其用于花朵分类...
  • 因为项目上的需要,我需要去训练一个人脸识别的系统,但是机器视觉方向并不是我特别喜欢的方向,所以我特别急功求成,想尽快搭建一个人脸识别系统,其实在git上已经有很多相关论文还有已经训练好的模型,大家如果想...

    因为项目上的需要,我需要去训练一个人脸识别的系统,但是机器视觉方向并不是我特别喜欢的方向,所以我特别急功求成,想尽快搭建一个人脸识别系统,其实在git上已经有很多相关论文还有已经训练好的模型,大家如果想去了解这方面的知识,这篇文章并不适合您看。当然,时间是必须去付出的,大家如果喜欢这方面的方向,就好好斟酌一下,神经网络现在应用的很广,推荐Tensorflow框架,实在是太简单方便搭建了。当然不要光只学框架,具体的原理一定要搞清楚,推荐Coursera-Andrew ng-MachineLearing课程,没看过就相当于没学过,这是经典,而且入门简单,好好学,好好吸收,原理就这样。好吧,接下来我就将这10天的工作总结在此吧。

    【2019/3/11】鉴于文章关注好像挺多了,过2天我会尝试将代码放到github上,我不知道是否能上传这么大量的图片。

    一,材料准备

    Anaconda3-4.2.0

    这是一个python3.5.2的集成环境,特别好用和方便,方便管理需要用的包。

    9844be7e33fd?utm_campaign

    二,学习教程

    Python3

    这个学习教程无所谓的,你可以看书,也可以找网站来自学,当然必须先有python3的基础知识了。

    9844be7e33fd?utm_campaign

    Tensorflow

    这个我推荐莫烦大牛的基础Tensorflow视频教程,不过这个课程说实在的是过于简单,就是快速的让人了解整个过程,其实面对的还是一些有基础的人,所以一定要看Coursera-Andrew ng-MachineLearing这课程,经典!经典!经典!重要的东西说3遍。当然学习框架的东西最好还是去tensoflow官方(好难打开)去细酌,当然tensorFlow中文社区也行,看自己喜欢,八仙过海,各显神通。

    9844be7e33fd?utm_campaign

    opencv3

    这个就没什么好说的了,直接看官方的教程,一点点敲,一点点尝试,这是3.0的教程,2.0在某些方面上不一样,我觉得可以直接入3.0。当然个人也极度推荐看毛星云大牛博客,当然自己先需要懂c++,然后去搞懂每个原理就好,更多东西,还是回归官网,官网说的为准。

    9844be7e33fd?utm_campaign

    三,环境布置

    1.安装anaconda3

    我刚刚给的链接是个exe文件,所以这我就不用说了吧,就是傻瓜式的下一步,选择安装就好。

    注意:这里可能有人纠结选择什么,我选择的是这个。

    9844be7e33fd?utm_campaign

    安装完成后,一般所有软件都会在这里。

    9844be7e33fd?utm_campaign

    2.安装opencv3

    打开开始找到Anaconda Prompt,并以管理员身份运行,其实就是个普通终端罢了。

    9844be7e33fd?utm_campaign

    输入以下命令,然后按下y即可。

    conda install -c https://conda.anaconda.org/menpo opencv3

    9844be7e33fd?utm_campaign

    安装完成后我们可以用以下命令试试是否正常使用,没反应就是最好的反应了啊,能正常使用。

    python

    import cv2

    9844be7e33fd?utm_campaign

    3.安装tensorflow

    同样地,打开开始找到Anaconda Prompt,并以管理员身份运行,输入以下命令,这时候使用的Tensorflow1.3.0

    #Anaconda安装完成后,打开Anaconda Prompt,输入如下命令,创建Tensorflow虚拟环境。

    conda create -n tensorflow python=3.5

    #进入Tensorflow虚拟环境

    activate tensorflow

    退出Tensorflow虚拟环境

    deactivate tensorflow

    安装Tensorflow

    pip install tensorflow

    亲测可用,完成了之后,同样可以输入以下命令来进行测试。

    python

    import tensorflow

    9844be7e33fd?utm_campaign

    用anaconda3就是这么方便,很多东西都集成好在一个地方,如果想卸载,其实很简单,直接把anaconda3卸载了,什么都脱离了你的环境了。就是这么好用。

    四,源代码

    ps:下面步骤如果没提示到的文件和数据包,不需要管,我会在每一个文件对应需要下载和安装什么东西,一步一步进行讲述

    9844be7e33fd?utm_campaign

    spyder工具

    我们使用的编辑工具叫spyder,anaconda3自带工具,在开始输入spyder即可找到。

    9844be7e33fd?utm_campaign

    main.py

    首先去opencv官网,下载一个opencv包,将下面的两个文件放入xml文件夹。

    9844be7e33fd?utm_campaign

    然后可以运行以下代码,当然要注意我们的----------------------------ps:位置,等等我们将到对应位置之后,遍可打开,将得到你渴望的效果。慢慢来,心急吃不到热豆腐,先试试人脸识别怎么样,这是opencv的demo改写的,就是利用haar_like分类器进行分类,有2部判断,先判断是否是人脸,是人脸的话,判断人脸有没眼睛,如果有这个就是人脸。当然相关论文知识我的这篇文章不会详细介绍,大家可以上网去找,我只想用最简单的方式给大家带来效果

    代码

    # -*- coding: utf-8 -*-

    """

    Created on Tue Oct 17 10:14:19 2017

    @author: Gavinjou

    """

    import cv2

    import numpy as np

    import datetime

    #----------------------------ps:讲到年龄,性别的时候可以打开

    #import age_sex as myahesex

    #调用自己的表情文档

    #----------------------------ps:讲到表情识别的时候可以打开

    #import model as mymodel

    #调用自己的headpose文档

    #----------------------------ps:讲到头部姿态的时候可以打开

    #import headpose as myheadpose

    #haar人脸识别分类器数据位置

    face_cascade_name = "xml/haarcascade_frontalface_alt2.xml"

    #眼睛识别,提高准确率

    eyes_cascade_name = "xml/haarcascade_eye.xml"

    #窗口命名

    window_name = "Face detection"

    #定义人脸识别分类器

    face_cascade = cv2.CascadeClassifier(face_cascade_name)

    if face_cascade.empty() :

    raise IOError('Unable to load the face cascade classifier xml file')

    #定义眼睛检测分类器

    eyes_cascade = cv2.CascadeClassifier(eyes_cascade_name)

    if eyes_cascade.empty() :

    raise IOError('Unable to load the eye cascade classifier xml file')

    #年龄

    age_list=['(0, 2)','(4, 6)','(8, 12)','(15, 20)','(25, 32)','(38, 43)','(48, 53)','(60, 100)']

    #性别

    gender_list=['Male','Female']

    #得到性别识别器

    #----------------------------ps:讲到年龄,性别的时候可以打开

    #age_net=myahesex.get_age_net()

    #得到年龄识别器

    #----------------------------ps:讲到年龄,性别的时候可以打开

    #gender_net = myahesex.get_gender_net()

    #人脸识别画框

    def detectAndDisplay(frame,scale):

    #算法开始时间

    startTime = datetime.datetime.now()

    #将原图转化为灰度图片

    frame_gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)

    #灰度直方图均衡化

    frame_gray = cv2.equalizeHist(frame_gray)

    #改变图像大小,使用双线性差值

    rows, cols = frame_gray.shape

    #缩小灰度图片加速计算

    smallImage = cv2.resize(frame_gray,(int(round(cols/scale)),round(int(rows/scale))),interpolation=cv2.INTER_CUBIC)

    #人脸侦测

    faces = face_cascade.detectMultiScale(smallImage,1.1,2,cv2.CASCADE_SCALE_IMAGE,(30, 30))

    index=int(1)

    for faceRect in faces:

    x,y,w,h = faceRect

    #左上角

    LUpoint = (int(round(x * scale)),int(round(y * scale)))

    #右上角

    RDpoint = (int(round((x+w-1) * scale)),int(round((y+h-1) * scale)))

    #人脸映像

    faceROI = frame_gray[int(round(y * scale)):int(round((y+h-1) * scale)), int(round(x * scale)):int(round((x+w-1) * scale))]

    #三维人脸映像

    faceROI2 = frame[int(round(y * scale)):int(round((y+h-1) * scale)), int(round(x * scale)):int(round((x+w-1) * scale))]

    #眼睛识别

    eyes = eyes_cascade.detectMultiScale(faceROI,1.1,2,cv2.CASCADE_SCALE_IMAGE,(30, 30))

    if len(eyes) !=2 :

    continue

    #得到角度参数

    #----------------------------ps:讲到头部姿态的时候可以打开

    #pitch,yaw,roll= myheadpose.predict_head_pose(faceROI2)

    #print(pitch,yaw,roll)

    #得到性别

    #----------------------------ps:讲到年龄,性别的时候可以打开

    #gender_prediction = gender_net.predict([faceROI2])

    #print(gender_list[gender_prediction[0].argmax()])

    #得到年龄

    #----------------------------ps:讲到年龄,性别的时候可以打开

    #age_prediction = age_net.predict([faceROI2])

    #print(age_list[age_prediction[0].argmax()])

    #得到所有表情参数

    #----------------------------ps:讲到表情识别的时候可以打开

    #facemodel=mymodel.predict_emotion(faceROI)

    #得到最大值位置

    #----------------------------ps:讲到表情识别的时候可以打开

    #_positon = np.argmax(facemodel)

    #画正方形

    cv2.rectangle(frame,LUpoint,RDpoint,(0, 0, 255),2,8)

    #标记

    cv2.putText(frame,str(index),LUpoint,cv2.FONT_HERSHEY_SIMPLEX,2.0,(0, 0, 255))

    #----------------------------ps:讲到表情识别的时候可以打开

    #cv2.putText(frame,mymodel.emotion_labels[_positon],LUpoint,cv2.FONT_HERSHEY_SIMPLEX,1.0,(0, 0, 255))

    index+=1

    cv2.imshow(window_name,frame)

    #算法结束时间

    endTime = datetime.datetime.now()

    print (endTime - startTime)

    #---detectAndDisplay

    #main

    #初始化窗口

    cv2.namedWindow(window_name,cv2.WINDOW_NORMAL)

    capture = cv2.VideoCapture(0)

    while(capture.isOpened()):

    ret, frame = capture.read()

    #判断是否最后一帧

    if ret:

    detectAndDisplay(frame,2.0)

    #按q退出程序

    if cv2.waitKey(30) & 0xFF == ord('q'):

    break

    #释放视频

    capture.release()

    cv2.destroyAllWindows()

    效果图

    9844be7e33fd?utm_campaign

    model.py

    这是我参考的两篇文章,第一篇是参考代码文章,第二篇是作者的文章,第三篇是安装keras教程,这是训练好的结果,所以可以直接调用,这时我测试部分就不写了,直接使用参考代码文章代码即可测试。

    这时需要将作者github上的文件夹下载,并放置刚刚的目录结构中。利用以下代码即可测试

    9844be7e33fd?utm_campaign

    安装keras

    具体请按照这篇文章进行操作

    代码

    # -*- coding: utf-8 -*-

    """

    Created on Wed Oct 18 15:36:48 2017

    @author: Gavinjou

    """

    import cv2

    import sys

    import json

    import time

    import numpy as np

    from keras.models import model_from_json

    root_model="real-time_emotion_analyzer-master"

    #动作表情

    #愤怒,害怕,开心,伤心,惊喜,平静

    emotion_labels = ['angry', 'fear', 'happy', 'sad', 'surprise', 'neutral']

    # load json and create model arch

    json_file = open(root_model+'/model.json','r')

    loaded_model_json = json_file.read()

    json_file.close()

    print("加载keras模型成功")

    model = model_from_json(loaded_model_json)

    # load weights into new model

    model.load_weights(root_model+'/model.h5')

    print("加载权重成功")

    #定义预测函数

    def predict_emotion(face_image_gray):

    resized_img = cv2.resize(face_image_gray, (48,48), interpolation = cv2.INTER_AREA)

    # cv2.imwrite(str(index)+'.png', resized_img)

    image = resized_img.reshape(1, 1, 48, 48)

    list_of_list = model.predict(image, batch_size=1, verbose=1)

    angry, fear, happy, sad, surprise, neutral = [prob for lst in list_of_list for prob in lst]

    return [angry, fear, happy, sad, surprise, neutral]

    #img_gray = cv2.imread('C:/Users/Gavinjou/Desktop/FaceRecognation/real-time_emotion_analyzer-master/meme_faces/happy-fear.png')

    #img_gray = cv2.cvtColor(img_gray, cv2.COLOR_BGR2GRAY)

    #angry, fear, happy, sad, surprise, neutral = predict_emotion(img_gray)

    效果图

    这时候还记得我们main.py,有----------------------------ps:标记吗,将----------------------------ps:讲到表情识别的时候可以打开下面的语句全部打开,然后运行main.py

    9844be7e33fd?utm_campaign

    headpose.py

    头部姿态识别我是按照这篇文章来进行使用的,这是原版的作者的文章,其实人家写的真够详细了,各种demo都告诉你怎么用了,直接调用就好,人家模型都是训练好的了,直接用就好。

    这时需要将作者github上的文件夹下载,并放置刚刚的目录结构中。利用以下代码即可测试,记得把文件夹名字改成我这个,不过也无所谓啦,就是个路径问题,当然自己去修改一下代码路径也是没问题的。测试代码我就不讲了,作者的文章上清清楚楚写了demo,自己写一遍测试一下即可。

    9844be7e33fd?utm_campaign

    9844be7e33fd?utm_campaign

    安装dlib

    打开Anaconda Prompt,输入如下命令,安装dlib

    conda install -c conda-forge dlib=19.4

    注意: 这是我折腾最久的,我不知道你是否能安装上,我是参考了几篇文章都无法装上,然后不知道搜了哪个位置的文章,使用一条命令就把dlib装上了。如果不行的话,我也推荐我之前参考的文章的链接去试试,但我并没有成功,总说什么Unicode不对。然后就放弃了。我用的材料是boost1.57.0,cmake3.8.2,dlib19.4.0

    代码

    # -*- coding: utf-8 -*-

    """

    Created on Wed Oct 18 20:10:15 2017

    @author: Gavinjou

    """

    import tensorflow as tf

    from deepgazemaster.deepgaze.head_pose_estimation import CnnHeadPoseEstimator

    #图像大小设定

    width = 64

    height= 64

    sess = tf.Session()

    my_head_pose_estimator = CnnHeadPoseEstimator(sess)

    my_head_pose_estimator.load_pitch_variables("deepgazemaster/etc/tensorflow/head_pose/pitch/cnn_cccdd_30k.tf")

    my_head_pose_estimator.load_yaw_variables("deepgazemaster/etc/tensorflow/head_pose/yaw/cnn_cccdd_30k")

    my_head_pose_estimator.load_roll_variables("deepgazemaster/etc/tensorflow/head_pose/roll/cnn_cccdd_30k.tf")

    #输入的图像大小必须要相等(64>=x,64>=x,3),x代表输入

    def predict_head_pose (face_image):

    #resized_img = cv2.resize(face_image, (width,height), interpolation = cv2.INTER_AREA)

    pitch = my_head_pose_estimator.return_pitch(face_image)

    yaw = my_head_pose_estimator.return_yaw(face_image)

    roll = my_head_pose_estimator.return_roll(face_image)

    return [pitch,yaw,roll]

    效果图

    这时候还记得我们main.py,有----------------------------ps:标记吗,将----------------------------ps:讲到头部姿态的时候可以打开下面的语句全部打开,然后运行main.py

    这时我多加了一个语句

    9844be7e33fd?utm_campaign

    输出便如下图了

    9844be7e33fd?utm_campaign

    age_sex.py

    年龄,性别识别部分我是参照我是参考该第一篇作者的文章,利用的是caffe神经网络框架,不过新的caffe好像还是会出问题,所以我还是会一步步让大家运行我的整份代码,第二篇修改caffe的文章。不用紧张,我们继续一步步来。

    这是需要将作者的整份代码下载下来,放文件根目录下

    9844be7e33fd?utm_campaign

    9844be7e33fd?utm_campaign

    这时候还没完成呢,还需要作者已经训练好的模型放到这个master文件中。这个文章还是原作者模型的参考文章,有时间还是好好看看。

    我下载的是作者最原始的训练好的模型,下完完成之后解压,创建一个文件名为cnn_age_gender_models的文件,把解压缩文件全部放进去。

    9844be7e33fd?utm_campaign

    9844be7e33fd?utm_campaign

    安装caffe

    网上很少有anaconda3+python3.5的caffe安装,就算有,也是特别麻烦,还有各种编译的烦事,还不一定成功,得谢谢第二篇文章上知乎上朋友的回答,2个回答的朋友已经告诉你怎么把caffe放到anaconda3中调用了,当然如果你不想编译,真得谢天谢地。第一篇文章已经提供了python35的预编译版本,开心吧。接下来我再来一步一步的说该怎么装

    首先打开第一篇文章,下载caffe到我们程序根目录当中

    9844be7e33fd?utm_campaign

    9844be7e33fd?utm_campaign

    因为代码中并不需要添加到anaconda3环境当中所以我就不需要演示怎么放进环境中了,其实代码已经声明路径添加上去罢了。

    修改caffe

    参考文章

    打开caffe/python/caffe/io.py 第258行,修改成以下代码

    9844be7e33fd?utm_campaign

    if ms != self.inputs[in_][1:]:

    in_shape = self.inputs[in_][1:]

    m_min, m_max = mean.min(), mean.max()

    normal_mean = (mean - m_min) / (m_max - m_min)

    mean = resize_image(normal_mean.transpose((1,2,0)),in_shape[1:]).transpose((2,0,1)) * (m_max - m_min) + m_min

    #raise ValueError('Mean shape incompatible with input shape.')

    打开caffe/python/caffe/classifier.py 第96行,修改成以下代码

    9844be7e33fd?utm_campaign

    代码

    import os

    import numpy as np

    import matplotlib.pyplot as plt

    caffe_root = './caffe/'

    import sys

    sys.path.insert(0, caffe_root + 'python')

    import caffe

    plt.rcParams['figure.figsize'] = (10, 10)

    plt.rcParams['image.interpolation'] = 'nearest'

    plt.rcParams['image.cmap'] = 'gray'

    mean_filename='./AgeGenderDeepLearning-master/cnn_age_gender_models/mean.binaryproto'

    proto_data = open(mean_filename, "rb").read()

    a = caffe.io.caffe_pb2.BlobProto.FromString(proto_data)

    mean = caffe.io.blobproto_to_array(a)[0]

    """

    age_net_pretrained='./AgeGenderDeepLearning-master/cnn_age_gender_models/age_net.caffemodel'

    age_net_model_file='./AgeGenderDeepLearning-master/cnn_age_gender_models/deploy_age.prototxt'

    age_net = caffe.Classifier(age_net_model_file, age_net_pretrained,

    mean=mean,

    channel_swap=(2,1,0),

    raw_scale=255,

    image_dims=(256, 256))

    gender_net_pretrained='./AgeGenderDeepLearning-master/cnn_age_gender_models/gender_net.caffemodel'

    gender_net_model_file='./AgeGenderDeepLearning-master/cnn_age_gender_models/deploy_gender.prototxt'

    gender_net = caffe.Classifier(gender_net_model_file, gender_net_pretrained,

    mean=mean,

    channel_swap=(2,1,0),

    raw_scale=255,

    image_dims=(256, 256))

    """

    def get_age_net():

    age_net_pretrained='./AgeGenderDeepLearning-master/cnn_age_gender_models/age_net.caffemodel'

    age_net_model_file='./AgeGenderDeepLearning-master/cnn_age_gender_models/deploy_age.prototxt'

    age_net = caffe.Classifier(age_net_model_file, age_net_pretrained,

    mean=mean,

    channel_swap=(2,1,0),

    raw_scale=255,

    image_dims=(256, 256))

    return age_net

    def get_gender_net():

    gender_net_pretrained='./AgeGenderDeepLearning-master/cnn_age_gender_models/gender_net.caffemodel'

    gender_net_model_file='./AgeGenderDeepLearning-master/cnn_age_gender_models/deploy_gender.prototxt'

    gender_net = caffe.Classifier(gender_net_model_file, gender_net_pretrained,

    mean=mean,

    channel_swap=(2,1,0),

    raw_scale=255,

    image_dims=(256, 256))

    return gender_net

    """

    gender_net = get_gender_net()

    age_list=['(0, 2)','(4, 6)','(8, 12)','(15, 20)','(25, 32)','(38, 43)','(48, 53)','(60, 100)']

    gender_list=['Male','Female']

    example_image = './AgeGenderDeepLearning-master/cnn_age_gender_models/example_image.jpg'

    input_image = caffe.io.load_image(example_image)

    print(input_image.shape)

    _ = plt.imshow(input_image)

    prediction = gender_net.predict([input_image])

    print ('predicted gender:', gender_list[prediction[0].argmax()])

    """

    效果图

    这时候还记得我们main.py,有----------------------------ps:标记吗,将#----------------------------ps:讲到年龄,性别的时候可以打开下面的语句全部打开,然后运行main.py

    可以看到性别是Female,年龄在(38-43)区间。。 我曹,我是女的,还那么老。。

    9844be7e33fd?utm_campaign

    五,总结

    上面都是很基础的东西,只是个乱调用,但是很快就做出模型来,可以满足一下小心脏,当然,如果要自己去研究这东西,这是最好的,我是没什么心思搞这个方向,所以我更想快点能调用来使用。但是这个程序速度跑起来有点慢,如果大家有什么好建议的话,可以留言给我,如果在配置上还出了些什么问题,也可以留言,我基本每天都上一下简书的。

    最后还有一份性别,年龄代码。我是参考了这篇文章的代码,可是训练出来的模型很有问题,梯度一直没下降,而且调用的时候也各种出状况,我跑了2天的数据,一点卵用也没,待我好好看看TensorFlow,我再整理一下,先保留着。

    import os

    import glob

    import tensorflow as tf

    from tensorflow.contrib.layers import *

    from tensorflow.contrib.slim.python.slim.nets.inception_v3 import inception_v3_base

    import numpy as np

    from random import shuffle

    import datetime

    #年龄区间

    age_table=['(0, 2)','(4, 6)','(8, 12)','(15, 20)','(25, 32)','(38, 43)','(48, 53)','(60, 100)']

    #性别

    sex_table=['f','m'] # f:女; m:男

    # AGE==True 训练年龄模型,False,训练性别模型

    AGE = False

    if AGE == True:

    #获取长度

    lables_size = len(age_table) # 年龄

    else:

    #获取长度

    lables_size = len(sex_table) # 性别

    face_set_fold = 'AdienceBenchmarkOfUnfilteredFacesForGenderAndAgeClassification'

    #拼接路径

    fold_0_data = os.path.join(face_set_fold, 'fold_0_data.txt')

    fold_1_data = os.path.join(face_set_fold, 'fold_1_data.txt')

    fold_2_data = os.path.join(face_set_fold, 'fold_2_data.txt')

    fold_3_data = os.path.join(face_set_fold, 'fold_3_data.txt')

    fold_4_data = os.path.join(face_set_fold, 'fold_4_data.txt')

    face_image_set = os.path.join(face_set_fold, 'aligned')

    #拼接路径

    def parse_data(fold_x_data):

    #数据集存储

    data_set = []

    with open(fold_x_data, 'r') as f:

    #用于标记第一行,第一行数据全部是名称,全部不读

    line_one = True

    for line in f:

    tmp = []

    #如果是第一行,继续

    if line_one == True:

    line_one = False

    continue

    #获取所在文件编号

    tmp.append(line.split('\t')[0])

    #获取对应图片名称

    tmp.append(line.split('\t')[1])

    #获取年龄区间

    tmp.append(line.split('\t')[3])

    #获取性别

    tmp.append(line.split('\t')[4])

    #查看对应文件夹是否存在

    file_path = os.path.join(face_image_set, tmp[0])

    #如果存在

    if os.path.exists(file_path):

    #获取该文件所有图片

    filenames = glob.glob(file_path + "/*.jpg")

    #查找图片是否在这批文件中

    for filename in filenames:

    if tmp[1] in filename:

    break

    #将数据挂载到内存

    if AGE == True:

    if tmp[2] in age_table:

    data_set.append([filename, age_table.index(tmp[2])])

    else:

    if tmp[3] in sex_table:

    data_set.append([filename, sex_table.index(tmp[3])])

    #返回数据集

    return data_set

    """

    #------读取数据

    startTime = datetime.datetime.now()

    #读取所有文件的数据集

    data_set_0 = parse_data(fold_0_data)

    data_set_1 = parse_data(fold_1_data)

    data_set_2 = parse_data(fold_2_data)

    data_set_3 = parse_data(fold_3_data)

    data_set_4 = parse_data(fold_4_data)

    #合并所有数据

    data_set = data_set_0 + data_set_1 + data_set_2 + data_set_3 + data_set_4

    #打乱数据

    shuffle(data_set)

    endTime = datetime.datetime.now()

    print ("完成读取数据时间:"+str(endTime - startTime))

    #------读取数据

    """

    # 缩放图像的大小

    IMAGE_HEIGHT = 227

    IMAGE_WIDTH = 227

    # 读取缩放图像

    #待放入字符串

    jpg_data = tf.placeholder(dtype=tf.string)

    #待解码jpg图片

    decode_jpg = tf.image.decode_jpeg(jpg_data, channels=3)

    #对待读取图片重置size

    resize = tf.image.resize_images(decode_jpg, [IMAGE_HEIGHT, IMAGE_WIDTH])

    #优化转换

    resize = tf.cast(resize, tf.uint8) / 255

    #读取图片并重置图片数据

    def resize_image(file_name):

    #读取图片

    with tf.gfile.FastGFile(file_name, 'rb') as f:

    image_data = f.read()

    #加载程序

    with tf.Session() as sess:

    image = sess.run(resize, feed_dict={jpg_data: image_data})

    return image

    #批量数据处理

    pointer = 0

    def get_next_batch(data_set, batch_size=128):

    global pointer

    batch_x = []

    batch_y = []

    for i in range(batch_size):

    batch_x.append(resize_image(data_set[pointer][0]))

    batch_y.append(data_set[pointer][1])

    pointer += 1

    return batch_x, batch_y

    #分批大小

    #batch_size = 128

    batch_size = 1

    #总个数

    #num_batch = len(data_set) // batch_size

    num_batch = 1

    print("总共的batch数量---"+str(num_batch))

    #输入的数据大小

    X = tf.placeholder(dtype=tf.float32, shape=[batch_size, IMAGE_HEIGHT, IMAGE_WIDTH, 3])

    #输出数据大小

    Y = tf.placeholder(dtype=tf.int32, shape=[batch_size])

    def conv_net(nlabels, images, pkeep=1.0):

    weights_regularizer = tf.contrib.layers.l2_regularizer(0.0005)

    with tf.variable_scope("conv_net", "conv_net", [images],reuse=True) as scope:

    with tf.contrib.slim.arg_scope([convolution2d, fully_connected], weights_regularizer=weights_regularizer, biases_initializer=tf.constant_initializer(1.), weights_initializer=tf.random_normal_initializer(stddev=0.005), trainable=True):

    with tf.contrib.slim.arg_scope([convolution2d], weights_initializer=tf.random_normal_initializer(stddev=0.01)):

    conv1 = convolution2d(images, 96, [7,7], [4, 4], padding='VALID', biases_initializer=tf.constant_initializer(0.), scope='conv1')

    pool1 = max_pool2d(conv1, 3, 2, padding='VALID', scope='pool1')

    norm1 = tf.nn.local_response_normalization(pool1, 5, alpha=0.0001, beta=0.75, name='norm1')

    conv2 = convolution2d(norm1, 256, [5, 5], [1, 1], padding='SAME', scope='conv2')

    pool2 = max_pool2d(conv2, 3, 2, padding='VALID', scope='pool2')

    norm2 = tf.nn.local_response_normalization(pool2, 5, alpha=0.0001, beta=0.75, name='norm2')

    conv3 = convolution2d(norm2, 384, [3, 3], [1, 1], biases_initializer=tf.constant_initializer(0.), padding='SAME', scope='conv3')

    pool3 = max_pool2d(conv3, 3, 2, padding='VALID', scope='pool3')

    flat = tf.reshape(pool3, [-1, 384*6*6], name='reshape')

    full1 = fully_connected(flat, 512, scope='full1')

    drop1 = tf.nn.dropout(full1, pkeep, name='drop1')

    full2 = fully_connected(drop1, 512, scope='full2')

    drop2 = tf.nn.dropout(full2, pkeep, name='drop2')

    with tf.variable_scope('output',reuse=True) as scope:

    weights = tf.Variable(tf.random_normal([512, nlabels], mean=0.0, stddev=0.01), name='weights')

    biases = tf.Variable(tf.constant(0.0, shape=[nlabels], dtype=tf.float32), name='biases')

    output = tf.add(tf.matmul(drop2, weights), biases, name=scope.name)

    return output

    """

    def training():

    logits = conv_net(lables_size, X)

    def optimizer(eta, loss_fn):

    global_step = tf.Variable(0, trainable=False)

    optz = lambda lr: tf.train.MomentumOptimizer(lr, 0.9)

    lr_decay_fn = lambda lr,global_step : tf.train.exponential_decay(lr, global_step, 100, 0.97, staircase=True)

    return tf.contrib.layers.optimize_loss(loss_fn, global_step, eta, optz, clip_gradients=4., learning_rate_decay_fn=lr_decay_fn)

    def loss(logits, labels):

    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = logits, labels = labels)

    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    regularization_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)

    total_loss = cross_entropy_mean + 0.01 * sum(regularization_losses)

    loss_averages = tf.train.ExponentialMovingAverage(0.9)

    loss_averages_op = loss_averages.apply([cross_entropy_mean] + [total_loss])

    with tf.control_dependencies([loss_averages_op]):

    total_loss = tf.identity(total_loss)

    return total_loss

    # loss

    total_loss = loss(logits, Y)

    # optimizer

    train_op = optimizer(0.001, total_loss)

    saver = tf.train.Saver(tf.global_variables())

    with tf.Session() as sess:

    sess.run(tf.global_variables_initializer())

    global pointer

    epoch = 0

    while True:

    print("start-----"+str(epoch))

    pointer = 0

    for batch in range(num_batch):

    startTime = datetime.datetime.now()

    batch_x, batch_y = get_next_batch(data_set, batch_size)

    _, loss_value = sess.run([train_op, total_loss], feed_dict={X:batch_x, Y:batch_y})

    print(epoch, batch, loss_value)

    endTime = datetime.datetime.now()

    print ("一次batch时间训练:"+str(endTime - startTime))

    saver.save(sess, './age.ckpt' if AGE == True else './sex.ckpt')

    epoch += 1

    print("end-----"+str(epoch))

    training()

    """

    # 检测性别和年龄

    # 把batch_size改为1

    def detect_age_or_sex(image_path):

    logits = conv_net(lables_size, X)

    saver = tf.train.Saver()

    with tf.Session() as sess:

    saver.restore(sess, './age.ckpt' if AGE == True else './sex.ckpt')

    softmax_output = tf.nn.softmax(logits)

    res = sess.run(softmax_output, feed_dict={X:[resize_image(image_path)]})

    res = np.argmax(res)

    if AGE == True:

    return age_table[res]

    else:

    return sex_table[res]

    print(detect_age_or_sex("1.jpg"))

    展开全文
  • 文章目录基本步骤1、定位图片中的脸2、在面部ROI中检测出关键的面部结构什么是ROI补充函数rect_to_bb,将rect转成坐标点补充函数...面部检测可以使用很多方式实现,比如说OpenCV内嵌的Haar级联,预训练好的HOG+ 先行SVM

    基本步骤

    1、定位图片中的脸

    • 面部检测可以使用很多方式实现,比如说OpenCV内嵌的Haar级联,预训练好的HOG+ 先行SVM对象检测,或者使用深度学习算法进行面部识别。无论什么方法,我们最终都是要获得标定面部的选区

    2、在面部ROI中检测出关键的面部结构

    • 主要给出对应面部选区,我们就可以进行面部特征点的检测。有很多不同的面部特征点检测器,但是所有的方法基本上都是针对以下几个器官:嘴、左右眼睫毛、左右眼、鼻子、下巴等。
    • Dlib库中常用的面部特征检测器是One millisecond face alignment with an ensemble of regression trees。这个方法使用了一个人工标注的测试集,标注的内容是围绕面部特征的特定的坐标,坐标表示的是像素点之间的距离。有了这个训练集,就可以训练出来一个集成的回归树,用来检测面部的特征。这个特征检测器的可以进行实时高精度检测。
    • 如果想要的更加深入的了解这个技术,可以通过连接,读相关的文章,配合Dlib的官方文档。
    • 文章的连接
    • Dlib官方文档
    • 在Dlib库中的预先训练好的面部特征检测是针对人脸结构上的68个特征点,分布如下。

    在这里插入图片描述

    什么是ROI
    • 图像处理中,从被处理图像以方框、圆、椭圆等不规则多边形方式勾勒出的需要处理的区域,成为感兴趣区域,ROI。
    补充函数rect_to_bb,将rect转成坐标点
    • 描述:将检测器检测出来的rect转换成具体的长方形框的坐标点
    • 原理:detecor返回的值是rect,数据的形式是(x,y,height,width)
    def rect_to_bb(rect):
    	# take a bounding predicted by dlib and convert it
    	# to the format (x, y, w, h) as we would normally do
    	# with OpenCV
    	x = rect.left()
    	y = rect.top()
    	w = rect.right() - x
    	h = rect.bottom() - y
    	# return a tuple of (x, y, w, h)
    	return (x, y, w, h)
    
    补充函数shape__to__np
    • 描述:将包含的68个面部区域的坐标点的shape转为numpy数组
    def shape_to_np(shape, dtype="int"):
    	# initialize the list of (x, y)-coordinates
    	coords = np.zeros((68, 2), dtype=dtype)
    	# loop over the 68 facial landmarks and convert them
    	# to a 2-tuple of (x, y)-coordinates
    	for i in range(0, 68):
    		coords[i] = (shape.part(i).x, shape.part(i).y)
    	# return the list of (x, y)-coordinates
    	return coords
    
    补充函数resive
    • 描述:将图片按照要求设定大小
    • 参数:image是cv2.imread的对象
    •   	 width和height是新指定的大小参数
      
    def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
        # initialize the dimensions of the image to be resized and
        # grab the image size
        dim = None
        (h, w) = image.shape[:2]
    
        # if both the width and height are None, then return the
        # original image
        if width is None and height is None:
            return image
    
        # check to see if the width is None
        if width is None:
            # calculate the ratio of the height and construct the
            # dimensions
            r = height / float(h)
            dim = (int(w * r), height)
    
        # otherwise, the height is None
        else:
            # calculate the ratio of the width and construct the
            # dimensions
            r = width / float(w)
            dim = (width, int(h * r))
    
        # resize the image
        resized = cv2.resize(image, dim, interpolation=inter)
    
        # return the resized image
        return resized
    

    主要代码

    导入相关的包
    # import the necessary packages
    import numpy as np
    import argparse
    import dlib
    import cv2
    
    初始化面部检测器和面部特征预测器
    # initialize dlib's face detector (HOG-based) and then create
    # the facial landmark predictor
    # 初始化基于HOG预测的预先训练好的检测器
    detector = dlib.get_frontal_face_detector()
    # 使用的shape-predictor去加载的下载的面部特征训练器
    # 括号里的是检测器的路径
    predictor = dlib.shape_predictor("the path of the detector")
    
    打开图片并读取,将之转换为的灰度图片,固定大小
    # 使用opencv打开图片
    image = cv2.imread("1.jpg")
    # 统一图片的大小
    image = imutils.resize(image,width = 500)
    # 将图片转为灰度图片,将BGR图片转为灰度图片
    gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
    
    • 具体resize函数
    def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
        # initialize the dimensions of the image to be resized and
        # grab the image size
        dim = None
        (h, w) = image.shape[:2]
    
        # if both the width and height are None, then return the
        # original image
        if width is None and height is None:
            return image
    
        # check to see if the width is None
        if width is None:
            # calculate the ratio of the height and construct the
            # dimensions
            r = height / float(h)
            dim = (int(w * r), height)
    
        # otherwise, the height is None
        else:
            # calculate the ratio of the width and construct the
            # dimensions
            r = width / float(w)
            dim = (width, int(h * r))
    
        # resize the image
        resized = cv2.resize(image, dim, interpolation=inter)
    
        # return the resized image
        return resized
    
    • imread的具体的输出,每一个像素点是以(r,g,b)的形式进行保存的,结果如下

    在这里插入图片描述
    原图片的shape输出,对应的是heightweightchannel,总共是rgb三个颜色的通道,像素点是711*474
    在这里插入图片描述

    • 修改之后的图片尺寸

    在这里插入图片描述

    • 转换之后的灰度图片,仅仅只有一个单通道

    在这里插入图片描述

    调用加载好的检测器,对目标进行检测
    • 第一个参数是需要检测的图片
    • 第二个参数是图片的层数,这里是单层图片,只有一个灰度层
    # detect face in the grayscale face
    # detecting the bounding box of faces in our image
    # the second parameter is the number of image pyramid layer
    # prior applying the detector we must upscaling the image
    rects = detector(gray,1)
    

    在这里插入图片描述

    • rects的结果是的坐标和weight和height两对参数
    遍历所有是别人出来的人脸
    for (i,rect) in enumerate(rects):
        # i对应的是目标的索引,rect对应是每一个框的起始点坐标和长宽
        # 定位人脸的关键点,返回的定位之后的68个关键点的位置
        shape = predictor(gray,rect)
        # shape是输出之后坐标点,是(68,2),68个点,每个点都是二维的,将所有的坐标点转为numpy数组
        shape = face_utils.shape_to_np(shape)
    
        # 将rect检测人脸的边框转为绘制矩形框的具体位置
        (x,y,w,h) = face_utils.rect_to_bb(rect)
        # 绘制人脸的矩形框
        cv2.rectangle(image,(x,y),(x+w,y+h),(0,255,0),2)
    
        # 设置矩形框的文字部分
        cv2.putText(image,"Face #{}".format(i+1),(x-10,y-10),
                    cv2.FONT_HERSHEY_SIMPLEX,0.5,(0,255,0),2)
    
        # 循环遍历所有的点,将之在原图上进行标注
        for (x,y) in shape:
            cv2.circle(image,(x,y),1,(0,0,255),-1)
    
    • 具体的函数face_utils.shape_to_np的具体代码,将shape的输出结果转为numpy数组
    def shape_to_np(shape, dtype="int"):
    	# initialize the list of (x, y)-coordinates
    	coords = np.zeros((68, 2), dtype=dtype)
    	# loop over the 68 facial landmarks and convert them
    	# to a 2-tuple of (x, y)-coordinates
    	for i in range(0, 68):
    		coords[i] = (shape.part(i).x, shape.part(i).y)
    	# return the list of (x, y)-coordinates
    	return coords
    
    输出修改之后的图片
    # show the output image with the face detections + facial landmarks
    cv2.imshow("Output",image)
    cv2.waitKey(0)
    

    最终的代码

    # import the necessary packages
    
    # import argparse
    import cv2
    import dlib
    
    import imutils
    # the package below from the writer
    from imutils import face_utils
    
    
    # intialize dlib face detector adn then create the facial landmark predictor
    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
    
    # load the image,resize it and convert it into grayscale
    # resice the size of the image into 500 width
    # image = cv2.imread(args["image"])
    image = cv2.imread("1.jpg")
    image = imutils.resize(image,width = 500)
    gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
    
    # detect face in the grayscale face
    # detecting the bounding box of faces in our image
    # the second parameter is the number of image pyramid layer
    # prior applying the detector we must upscaling the image
    rects = detector(gray,1)
    
    
    # Given the coordinates of the face in the image
    # loop over the face detections
    for (i,rect) in enumerate(rects):
        # determine the facial landmarks for the face region
        # convert the coordiantes of the facial landmark to numpy array
        # predictor is to detect the facila landmark
        shape = predictor(gray,rect)
        # convert the dlib objects to a numpy array
        shape = face_utils.shape_to_np(shape)
    
        # convert dlib's rectangle to a OpenCV-style bounding box(x,y,w,h)
        # then draw the face bounding box
        (x,y,w,h) = face_utils.rect_to_bb(rect)
        cv2.rectangle(image,(x,y),(x+w,y+h),(0,255,0),2)
    
        # show the face number
        cv2.putText(image,"Face #{}".format(i+1),(x-10,y-10),
                    cv2.FONT_HERSHEY_SIMPLEX,0.5,(0,255,0),2)
    
        # loop over the (x,y)-coordinates for the facial lanmarks
        # and draw the on the image
        for (x,y) in shape:
            cv2.circle(image,(x,y),1,(0,0,255),-1)
    
    # show the output image with the face detections + facial landmarks
    cv2.imshow("Output",image)
    cv2.waitKey(0)
    

    实验效果

    在这里插入图片描述

    分析与总结

    • 里面有一个的imutils的包下载地址,不过下不了也没关系,我已经把对应原函数附在了对应调用的地方,你们可以自己改一下
    展开全文
  • 主要有以下步骤:1、人脸检测2、人脸预处理3、从收集的人脸训练机器学习算法4、人脸识别5、收尾工作人脸检测算法:基于Haar的脸部检测器的基本思想是,对于面部正面大部分区域而言,会有眼睛所在区域应该比前额和...
  • 代码基于python3和opencv框架,可能需要安装所需的module; 功能描述 --实现笔记本摄像头获取人脸的面部表情识别,happy,angry,neural,sad.. --实现指定路径下视频中人脸的识别.. 验证成功,未做改动,源自github
  • 广告关闭腾讯云11.11云上盛惠 ,...emotion-recognition - real time emotion recognitionemotion-recognition实时表情识别github项目地址:https:github.comomar178emotion-recognition? 项目描述我们人类的脸有...
  • 介绍introduction从opencv2.4开始,加入了新的类facerecognizer,我们可以使用它便捷地进行人脸识别实验。本文既介绍代码使用,又介绍算法原理。(他写的源代码,我们可以在opencvopencv\modules\contrib\doc\...
  • 代码基于python3和opencv框架,可能需要安装所需的module;...--实现笔记本摄像头获取人脸的面部表情识别,happy,angry,neural,sad.. --实现指定路径下视频中人脸的识别.. 验证成功,未做改动,源自github
  • python如何实现表情识别?本篇文章小编给大家分享一下python实现表情识别代码示例...实现思路使用OpenCV识别图片中的脸,在使用keras进行表情识别。效果预览实现代码本文表情识别是使用keras实现的,型数据使用的是o...
  • /usr/bin/env python#coding=utf-8import osfrom PIL import Image, ImageDrawimport cvdef detect_object(image):'''检测图片,获取人脸在图片中的坐标'''grayscale = cv.CreateImage((image.width, image.height),...
  • 在github下载源码https://github.com/serengil/deepface 然后安装deepface包 pip install deepface
  • 实现思路使用OpenCV识别图片中的脸,在使用keras进行表情识别。效果预览实现代码与《性别识别》相似,本文表情识别也是使用keras实现的,和性别识别相同,型数据使用的是oarriaga/face_classification的,代码如下:...
  • 实现思路使用OpenCV识别图片中的脸,在使用keras进行表情识别。效果预览实现代码与《性别识别》相似,本文表情识别也是使用keras实现的,和性别识别相同,型数据使用的是oarriaga/face_classification的,代码如下:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,557
精华内容 622
关键字:

opencvpython表情识别

python 订阅