python和opencv人脸表情识别_Windows+Anaconda3+Tensorflow+Opencv3 --人脸识别，年龄，性别，表情识别，头部姿态教程...

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

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

一，材料准备

Anaconda3-4.2.0

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

二，学习教程

Python3

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

Tensorflow

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

opencv3

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

三，环境布置

1.安装anaconda3

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

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

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

2.安装opencv3

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

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

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

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

python

import cv2

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

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

四，源代码

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

spyder工具

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

main.py

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

然后可以运行以下代码，当然要注意我们的----------------------------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()

效果图

model.py

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

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

安装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

headpose.py

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

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

安装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

这时我多加了一个语句

输出便如下图了

age_sex.py

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

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

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

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

安装caffe

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

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

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

修改caffe

参考文章

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

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行，修改成以下代码

代码

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）区间。。 我曹，我是女的，还那么老。。

五，总结

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

最后还有一份性别，年龄代码。我是参考了这篇文章的代码，可是训练出来的模型很有问题，梯度一直没下降，而且调用的时候也各种出状况，我跑了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"))