python关于opencv、keras环境下的人脸检测识别

人脸检测识别

计算机视觉入门最基本项目大概就是这人脸识别了，容易上手。本文是基于另外一篇博客基础上https://blog.csdn.net/qq_42633819/article/details/81191308，花了两晚上时间搞了一下，算是成功了吧（电脑显卡比较渣，摄像头不清晰，结果不理想。就不放最终正确识别的图像了）。

2.准备

大概需要一台电脑以及摄像头。

3.各种库、环境的安装

关于python安装就不多说了，本人装的Anaconda 3.7

opencv安装，参考

https://jingyan.baidu.com/article/fdbd4277bf0816b89e3f4807.html

keras 配置，直接在opencv环境下配置

sklearn、PLI也配置在opencv 环境下

Scikit-learn(sklearn)是机器学习中常用的第三方模块，对常用的机器学习方法进行了封装，包括回归(Regression)、降维(Dimensionality Reduction)、分类(Classfication)、聚类(Clustering)等方法。当我们面临机器学习问题时，便可根据下图来选择相应的方法。

PIL（Python Imaging Library）是Python常用的图像处理库，而Pillow是PIL的一个友好Fork，提供了了广泛的文件格式支持，强大的图像处理能力，主要包括图像储存、图像显示、格式转换以及基本的图像处理操作等。

4.人脸获取

利用opencv调用摄像头，获取500张你的脸的图像。创建python文件，命名为face_cut_save,代码如下：

[code]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("F:\\Anaconda\Anaconda3.7\\envs\opencv\\Library\\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/500' % (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("截取人脸", "H:/data-detect/1.mp4", 499, 'H:/data-detect/my_face')

先创建一个文件夹data-detect，把所有代码和数据都放这里。

在该文件夹下创建face_data文件用来存储人脸图像,my_face存储自已的脸图像，至少还要其他一个人脸图像存储在other文件下，model文件用来存储后期训练的模型。最后一行代码中，我用的是自己拍好的视频；若你要调用摄像头，把"H:/data-detect/1.mp4" 改为0就可以（建议调用摄像头）。第10行处classfier 注意文件路径。

在创建第二个python文件，命名为load_data,代码如下：

[code]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)
#标注数据
labels = np.array([0 if label.endswith('xie') 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("H:/data-detect/my_face")

注意文件路径和名字修改，此段代码主要是将人脸图像全部设定为统一大小。

5.训练模型

创建一个python文件，命名为face_train.

[code]import random
import numpy as np
from sklearn.model_selection 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 = './xie.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('./my_face/')
dataset.load()
model = Model()
model.build_model(dataset)
#先前添加的测试build_model()函数的代码
model.build_model(dataset)
#测试训练函数的代码
model.train(dataset)

if __name__ == '__main__':
dataset = Dataset('./my_face/')
dataset.load()
model = Model()
model.build_model(dataset)
model.train(dataset)
model.save_model(file_path = './model/xie.face.model.h5')

if __name__ == '__main__':
dataset = Dataset('./my_face/')
dataset.load()

#评估模型
model = Model()
model.load_model(file_path = './model/xie.face.model.h5')
model.evaluate(dataset)

运行程序结果正确以后，会得到一个xie.face.model.h5的文件，当然名字你可以修改修改。再进行下一步。（注意文件存储路径）

6.人脸检测与识别

创建一个python文件，命名为face_recongnized.

[code]import cv2
import sys
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/xie.face.model.h5')

#框住人脸的矩形边框颜色
color = (0, 255, 0)
#捕获指定摄像头的实时视频流
cap = cv2.VideoCapture(0)
#人脸识别分类器本地存储路径
cascade_path = "F:\\Anaconda\Anaconda3.7\\envs\opencv\\Library\\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,'xie',(x + 20, y + 20), cv2.FONT_HERSHEY_SIMPLEX, 1,(0,0,255), 2)
#坐标        #字体     #字号          #颜色  #字的线宽
else:
pass
cv2.imshow("recognized myself", frame)
#等待10毫秒看是否有按键输入
k = cv2.waitKey(10)
#如果输入q则退出循环
if k & 0xFF == ord('q'):
break
#释放摄像头并销毁所有窗口
cap.release()
cv2.destroyAllWindows()

到这里就结束了，如果成功了你可以在摄像头下识别你自己的脸。

接下来将整理一篇关于YOLO目标物体检测详细介绍的博文。欢迎继续收看。