Python3+OpenCV+TensorFlow进行人脸识别

Python3+OpenCV+TensorFlow进行人脸识别

前言

最近也是新开始研究深度学习，准备从比较成熟的人脸识别开始，但是发现网上的代码版本都比较老了，所以把自己踩完坑的新版本更新上来，方便大家参考一下。
Python版本：3.7.0
TensorFlow版本：2.3.1
OpenCV版本：4.4.0
Keras版本：2.4.3

参考原文1：https://blog.csdn.net/qq_42633819/article/details/81191308
参考原文2：https://blog.csdn.net/weilixin88/article/details/90680777
但是在后续修改过程中，查看keras文档时发现最早的模板可能出自keras模板代码

0、工作目录层级

整个目录层级是预先手动建好的，如果有需要自动建目录的可以自己加代码，但是因为属于python基础操作，就不再赘述了。

1、获取数据

这一块因为不是重点，所以只是简单修改了前人的代码结构，例如把可能需要修改的参数都放到了入口函数里，移除了多余的空行，把能放下的注释都放到了后面等，使整个代码更紧凑简洁。

import cv2


def catch_pic_from_video(window_name, camera_idx, catch_pic_num, classifier_path_name, pic_path_name):
    cv2.namedWindow(window_name)
    cap = cv2.VideoCapture(camera_idx, cv2.CAP_DSHOW)  # 视频来源，直接来自USB摄像头
    classifier = cv2.CascadeClassifier(classifier_path_name)  # 告诉OpenCV使用人脸识别分类器
    color = (0, 255, 0)  # 识别出人脸后要画的边框的颜色，RGB格式
    num = 0
    while cap.isOpened():
        ok, frame = cap.read()  # 读取一帧数据
        if not ok:
            break
        grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 将当前桢图像转换成灰度图像
        # 人脸检测，1.2和2分别为图片缩放比例和需要检测的有效点数
        face_rects = classifier.detectMultiScale(grey, scaleFactor=1.2, minNeighbors=3, minSize=(32, 32))
        if len(face_rects) > 0:  # 大于0则检测到人脸
            for face_rect in face_rects:  # 单独框出每一张人脸
                x, y, w, h = face_rect
                img_name = '%s/%d.jpg' % (pic_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__':
    classifier_path = 'C:\\Users\\A\\Desktop\\TF_CV\\haarcascade_frontalface_alt2.xml'
    pic_path = 'C:\\Users\\A\\Desktop\\TF_CV\\faces\\others'
    catch_pic_from_video("Get Face", 0, 1024, classifier_path, pic_path)

2、加载数据

这一块的修改也很少，和参考的代码几乎一致，也只有一些格式上的修改。

import os
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
    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)
                # cv2.imwrite('1.jpg', image)  # 放开这行代码，可以看到resize_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_array = np.array(images)
    print(images_array.shape)
    # 标注数据，'me'文件夹下都是自己图像，全部指定为0；另外一个文件夹下是别人的，全部指定为1
    # 如果要训练多个值，需要修改这个点，增加多个label_name和label_index的对应
    labels_array = np.array([0 if label.endswith('me') else 1 for label in labels])
    return images_array, labels_array


if __name__ == '__main__':
    images, labels = load_dataset("C:\\Users\\A\\Desktop\\TF_CV\\faces")

3、模型训练

修改点如下：

1. “from sklearn.cross_validation import train_test_split”改为了“from sklearn.model_selection import train_test_split”，因为随着版本变化，“cross_validation”已经弃用，改为了“model_selection”。
2. “from keras.layers import Convolution2D”改为了“from keras.layers import Conv2D”，呃…其实他们就是同一个东西，别名而已，但是这个短一点。
3. “if K.image_dim_ordering() == ‘th’”改为了“if K.image_data_format() == ‘channels_first’”，因为随着keras版本的升级，旧的值已经不能用了。现在后台如果是Tensorflow，那么这个值就是’channels_last’，其他的后台则是’channels_first’。
4. 在build_mode函数中，旧版本的代码运行好像会有报错，所以参考新版本的函数示例代码进行了修改，但是整个模型的结构和参数是没有改动的。
5. 在train函数中，把2021-01-01即将废弃的“model.fit_generator”修改为了“model.fit”，参数名称可能也有部分随之进行了修改。
6. 在do_predict函数中，把2021-01-01即将废弃的“result = self.model.predict_classes(image) ”修改为了“result = np.argmax(self.model.predict(image), axis=1)”，这是新的获取预测结果的方法。

主要的修改点就是以上几点，可能有些遗漏。

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 Conv2D, 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_data_format() == 'channels_first':
            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()
        # 1 二维卷积层+激活函数层
        self.model.add(Conv2D(32, (3, 3), padding='same', input_shape=dataset.input_shape, activation='relu'))
        self.model.add(Conv2D(32, (3, 3), activation='relu'))  # 2 二维卷积层+激活函数层
        self.model.add(MaxPooling2D((2, 2)))  # 3 池化层
        self.model.add(Dropout(0.25))  # 4 Dropout层
        self.model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))  # 5 二维卷积层+激活函数层
        self.model.add(Conv2D(64, (3, 3), activation='relu'))  # 6 二维卷积层+激活函数层
        self.model.add(MaxPooling2D((2, 2)))  # 7 池化层
        self.model.add(Dropout(0.25))  # 8 Dropout层
        self.model.add(Flatten())  # 9 Flatten层
        self.model.add(Dense(512))  # 10 Dense层,又被称作全连接层
        self.model.add(Activation('relu'))  # 11 激活函数层
        self.model.add(Dropout(0.5))  # 12 Dropout层
        self.model.add(Dense(nb_classes))  # 13 Dense层
        self.model.add(Activation('softmax'))  # 14 分类层，输出最终结果
        self.model.summary()  # 输出模型概况

    # 训练模型
    def train(self, dataset, batch_size=20, epoch=20, 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=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(datagen.flow(dataset.train_images, dataset.train_labels, batch_size=batch_size),
                           batch_size=batch_size, epochs=epoch,
                           steps_per_epoch=dataset.train_images.shape[0]//batch_size,
                           validation_data=(dataset.valid_images, dataset.valid_labels))

    def save_model(self, file_path):
        self.model.save(file_path)

    def load_model(self, file_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 do_predict(self, image):
        # 依然是根据后端系统确定维度顺序
        if K.image_data_format() == 'channels_first' 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_data_format() == 'channels_last' 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
        result = np.argmax(self.model.predict(image), axis=1)  # 给出类别预测：0或者1，如果有多个label_index也可以
        print('result: %d' % result)
        return result[0]  # 返回类别预测结果


if __name__ == '__main__':
    dataset = Dataset('./faces/')
    dataset.load()
    model = Model()
    model.build_model(dataset)
    model.train(dataset)
    model.save_model(file_path='./model/test.faces.model.h5')
    model.evaluate(dataset)

在模型训练这一步，我一共准备了2个人，约共2000个样本，部分运行结果如下：

(1863, 64, 64, 3)
1304 train samples
559 valid samples
932 test samples

Total params: 6,489,634
Trainable params: 6,489,634
Non-trainable params: 0

Epoch 19/20
65/65 [] - 21s 323ms/step - loss: 0.0296 - accuracy: 0.9945 - val_loss: 0.0027 - val_accuracy: 0.9982
Epoch 20/20
65/65 [] - 21s 323ms/step - loss: 0.0307 - accuracy: 0.9891 - val_loss: 1.8013e-04 - val_accuracy: 1.0000
30/30 [==============================] - 3s 98ms/step - loss: 3.8547e-04 - accuracy: 1.0000
accuracy: 100.00%

可以看到评估准确率是100%，实际使用中准确度也还可以，但是绝对达不到100%（捂脸）

4、人脸识别

还是少量修改，主要是代码结构方面的。

import cv2
from training import Model


def rec_face(model_path, classifier_path):
    model = Model()  # 加载模型
    model.load_model(file_path=model_path)
    cap = cv2.VideoCapture(0)  # 捕获指定摄像头的实时视频流
    color = (0, 0, 255)  # 框住人脸的矩形边框颜色
    while True:  # 循环检测识别人脸
        ret, frame = cap.read()  # 读取一帧视频
        if ret is True:
            frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 图像灰化，降低计算复杂度
        else:
            continue
        cascade = cv2.CascadeClassifier(classifier_path)  # 使用人脸识别分类器，读入分类器
        # 利用分类器识别出哪个区域为人脸
        face_rects = cascade.detectMultiScale(frame_gray, scaleFactor=1.2, minNeighbors=3, minSize=(32, 32))
        if len(face_rects) > 0:
            for face_rect in face_rects:
                x, y, w, h = face_rect
                image = frame[y - 10: y + h + 10, x - 10: x + w + 10]  # 截取脸部图像提交给模型识别这是谁
                face_id = model.do_predict(image)
                if face_id == 0:  # 如果是“我”
                    cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness=2)
                    # 文字提示是谁，如果不止两个人，在这里加判断
                    cv2.putText(frame, 'Me',
                                (x + 30, y + 30),  # 坐标
                                cv2.FONT_HERSHEY_DUPLEX,  # 字体
                                1,  # 字号
                                (0, 255, 0),  # 颜色
                                2)  # 字的线宽
                elif face_id == 1:
                    cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness=2)
                    cv2.putText(frame, 'Others',
                                (x + 30, y + 30),  # 坐标
                                cv2.FONT_HERSHEY_DUPLEX,  # 字体
                                1,  # 字号
                                (0, 255, 255),  # 颜色
                                2)  # 字的线宽
        cv2.imshow("Recognition", frame)
        k = cv2.waitKey(10)  # 等待10毫秒看是否有按键输入
        if k & 0xFF == ord('q'):  # 如果输入q则退出循环
            break
    cap.release()  # 释放摄像头并销毁所有窗口
    cv2.destroyAllWindows()


if __name__ == '__main__':
    model_path = './model/test.faces.model.h5'  # training脚本生成的model文件路径
    classifier_path = 'C:\\Users\\A\\Desktop\\TF_CV\\haarcascade_frontalface_alt2.xml'  # 人脸识别分类器本地存储路径
    rec_face(model_path, classifier_path)

最后，祝大家码运昌隆…