基于深度学习Opencv的人脸识别系统—计算机专业课程设计(毕业设计)

基于深度学习Opencv的人脸识别系统

• 下载本文深度学习Opencv的人脸识别系统完整的代码和参考报告链接（或者可以文末联系博主koukou(壹壹23七2五六98)，获取源码和报告）https://download.csdn.net/download/shooter7/89093912
• 此处是另外一个系统描述的链接：基于机器学习KNN算法手写数字识别系统，可用于毕设课设。https://blog.csdn.net/shooter7/article/details/113337835

摘要

深度学习人脸识别是一种基于人工神经网络的图像处理技术，它通过学习大量人脸数据，自动提取人脸特征，实现对人脸的识别和检测。
本文采用基于OpenCV和keras的方法实现，基于深度学习的人脸识别在OpenCV中可以通过使用预训练的深度神经网络模型来实现。这些模型通常在大量标注的人脸数据上进行训练，学习到丰富的人脸特征表示。通过加载这些模型，OpenCV可以对输入图像进行人脸检测、特征点定位和人脸识别等操作。此外，OpenCV还支持实时视频流的处理，使得在实际应用中能够实现实时的人脸识别功能。总之，基于深度学习的人脸识别在OpenCV中的实现主要依赖于预训练的深度神经网络模型，这些模型提供了强大的人脸特征提取和识别能力。

调试导入和运行结果图

背景

近年来，随着深度学习技术的不断发展，人脸识别技术在准确性、速度和鲁棒性等方面取得了显著进步，广泛应用于安防监控、金融支付、社交媒体等领域。基于深度学习的人脸识别技术具有重要的意义。首先，它在安全领域发挥着关键作用，能够用于身份验证和监控，提高社会安全性。其次，该技术在个人设备如智能手机上的应用，为用户提供了便捷的身份识别方式，增强了用户隐私和数据安全。此外，人脸识别还广泛应用于客户服务、个性化推荐等领域，提升了用户体验和经济效率。

导入操作步骤

1. 本地安装python和pycharm， 解压源代码文件，导入pycharm
2. 在pycharm的setting中设置好venv虚拟环境
3. 在虚拟环境中安装好对应的包【opencv和keras】
4. 安装完成后运行face_capture.py就可以打开摄像头识别了
5. 安装路径下不要有中文，opencv会报错

报告和答辩PPT

关键代码

# -*- coding:utf-8 -*-
'''
opencv分类器参考文章 https://blog.csdn.net/u010402786/article/details/52261933
'''

import cv2

from model_train import Model
from data_input import read_name_list

faceData_file_path = './faceData/'
# 脸部图片文件路径

if __name__ == '__main__':
    cap = cv2.VideoCapture(0)
    # 读取dataset数据集下的子文件夹名称
    name_list = read_name_list(faceData_file_path)
    model = Model()
    model.load()
    while True:
        _, frame = cap.read()  # 获取摄像头图像
        frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)  # 图像灰度化
        cascade_path = "cv2_data/haarcascade_frontalface_alt.xml"  # opencv人脸检测分类器 人脸检测器（Haar_1）
        cascade = cv2.CascadeClassifier(cascade_path)  # 加载人脸检测分类器
        # 检测到的人脸
        facerect = cascade.detectMultiScale(frame_gray, scaleFactor=1.2, minNeighbors=3, minSize=(10, 10))
        # facerect = cascade.detectMultiScale(frame_gray, scaleFactor=1.01, minNeighbors=3, minSize=(3, 3))
        if len(facerect) > 0:  # 检测到人脸
            print(name_list)
            print('face detected')
            color = (0, 0, 255)  # opencv B-G-R 红色
            for rect in facerect:
                # 获取图像上人脸的左上角的x,y坐标，和人脸的宽和高
                x, y = rect[0:2]
                width, height = rect[2:4]
                image = frame[y - 10: y + height, x: x + width]
                cv2.rectangle(frame, (x - 10, y - 10), (x + width + 10, y + height + 10), color, 2)
                result = model.predict(image)
                print(name_list)
                print('result:', result)
                print('人物是:', name_list[result])
                cv2.putText(frame, name_list[result],
                            (int(x), int(y)),
                            cv2.FONT_HERSHEY_SIMPLEX, 1.2,
                            (0, 255, 0), 2)
        cv2.imshow('faceRecogniztion', frame)  # 显示图像
        k = cv2.waitKey(10)  # 10ms内等待输入
        if k == 27:  # ESC(ASCII码为27),按下ESC后 cv2.waitKey(),停止
            break
    # 释放摄像头
    cap.release()
    cv2.destroyAllWindows()

• model_train

# encoding: utf-8
'''
@author: weiyang_tang
@contact: weiyang_tang@126.com
@file: model_train.py
@time: 2019-02-22 10:18
@desc: 训练模型
'''

from __future__ import print_function

import random

import numpy as np
from keras import backend as K
from keras.layers import Convolution2D, MaxPooling2D
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.models import Sequential
from keras.models import load_model
from keras.optimizers import SGD
from keras.preprocessing.image import ImageDataGenerator
from keras.utils import np_utils
# from sklearn.cross_validation import train_test_split
from sklearn.model_selection import train_test_split

from data_input import extract_data, resize_with_pad, IMAGE_SIZE, read_file

faceData_file_path = './faceData/'


class Dataset(object):

    def __init__(self):
        self.X_train = None
        self.X_valid = None
        self.X_test = None
        self.Y_train = None
        self.Y_valid = None
        self.Y_test = None

        def read(self, img_rows=IMAGE_SIZE, img_cols=IMAGE_SIZE, img_channels=3, nb_classes=3):
            # images, labels = extract_data('./faceData/')
            images, labels, counter = read_file(faceData_file_path)
            nb_classes = counter
            print(nb_classes)
            print(images)
            print(labels)
            labels = np.reshape(labels, [-1])
            # numpy.reshape
            X_train, X_test, y_train, y_test = train_test_split(images, labels, test_size=0.3,
                                                                random_state=random.randint(0, 100))
            X_valid, X_test, y_valid, y_test = train_test_split(images, labels, test_size=0.5,
                                                                random_state=random.randint(0, 100))
            if K.image_dim_ordering() == 'th':
                X_train = X_train.reshape(X_train.shape[0], 3, img_rows, img_cols)
                X_valid = X_valid.reshape(X_valid.shape[0], 3, img_rows, img_cols)
                X_test = X_test.reshape(X_test.shape[0], 3, img_rows, img_cols)
                input_shape = (3, img_rows, img_cols)
            else:
                X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 3)
                X_valid = X_valid.reshape(X_valid.shape[0], img_rows, img_cols, 3)
                X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 3)
                input_shape = (img_rows, img_cols, 3)

            # the data, shuffled and split between train and test sets
            print('X_train shape:', X_train.shape)
            print(X_train.shape[0], 'train samples')
            print(X_valid.shape[0], 'valid samples')
            print(X_test.shape[0], 'test samples')
            # convert class vectors to binary class matrices
            Y_train = np_utils.to_categorical(y_train, nb_classes)
            Y_valid = np_utils.to_categorical(y_valid, nb_classes)
            Y_test = np_utils.to_categorical(y_test, nb_classes)
            X_train = X_train.astype('float32')
            X_valid = X_valid.astype('float32')
            X_test = X_test.astype('float32')
            X_train /= 255
            X_valid /= 255
            X_test /= 255
            self.X_train = X_train
            self.X_valid = X_valid
            self.X_test = X_test
            self.Y_train = Y_train
            self.Y_valid = Y_valid
            self.Y_test = Y_test


class Model(object):
    FILE_PATH = './model/model.h5'
    def __init__(self):
        self.model = None
    def build_model(self, dataset, nb_classes=3):
        images, labels, counter = read_file(faceData_file_path)
        nb_classes = counter
        self.model = Sequential()
        self.model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape=dataset.X_train.shape[1:]))
        self.model.add(Activation('relu'))
        self.model.add(Convolution2D(32, 3, 3))
        self.model.add(Activation('relu'))
        self.model.add(MaxPooling2D(pool_size=(2, 2)))
        self.model.add(Dropout(0.25))
        self.model.add(Convolution2D(64, 3, 3, border_mode='same'))
        self.model.add(Activation('relu'))
        self.model.add(Convolution2D(64, 3, 3))
        self.model.add(Activation('relu'))
        self.model.add(MaxPooling2D(pool_size=(2, 2)))
        self.model.add(Dropout(0.25))
        self.model.add(Flatten())
        self.model.add(Dense(512))
        self.model.add(Activation('relu'))
        self.model.add(Dropout(0.5))
        self.model.add(Dense(nb_classes))
        self.model.add(Activation('softmax'))
        self.model.summary()

    def train(self, dataset, batch_size=32, nb_epoch=40, data_augmentation=True):
        # let's train the model using SGD + momentum (how original).
        sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
        self.model.compile(loss='categorical_crossentropy',
                           optimizer=sgd,
                           metrics=['accuracy'])
        if not data_augmentation:
            print('Not using data augmentation.')
            self.model.fit(dataset.X_train, dataset.Y_train,
                           batch_size=batch_size,
                           nb_epoch=nb_epoch,
                           validation_data=(dataset.X_valid, dataset.Y_valid),
                           shuffle=True)
        else:
            print('Using real-time data augmentation.')
            # this will do preprocessing and realtime data augmentation
            datagen = ImageDataGenerator(
                featurewise_center=False,  # set input mean to 0 over the dataset
                samplewise_center=False,  # set each sample mean to 0
                featurewise_std_normalization=False,  # divide inputs by std of the dataset
                samplewise_std_normalization=False,  # divide each input by its std
                zca_whitening=False,  # apply ZCA whitening
                rotation_range=20,  # randomly rotate images in the range (degrees, 0 to 180)
                width_shift_range=0.2,  # randomly shift images horizontally (fraction of total width)
                height_shift_range=0.2,  # randomly shift images vertically (fraction of total height)
                horizontal_flip=True,  # randomly flip images
                vertical_flip=False)  # randomly flip images
            # compute quantities required for featurewise normalization
            # (std, mean, and principal components if ZCA whitening is applied)
            datagen.fit(dataset.X_train)
            # fit the model on the batches generated by datagen.flow()
            self.model.fit_generator(datagen.flow(dataset.X_train, dataset.Y_train,
                                                  batch_size=batch_size),
                                     samples_per_epoch=dataset.X_train.shape[0],
                                     nb_epoch=nb_epoch,
                                     validation_data=(dataset.X_valid, dataset.Y_valid))

    def save(self, file_path=FILE_PATH):
        print('Model Saved.')
        self.model.save(file_path)

    def load(self, file_path=FILE_PATH):
        print('Model Loaded.')
        self.model = load_model(file_path)

    def predict(self, image):
        if K.image_dim_ordering() == 'th' and image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
            image = resize_with_pad(image)
            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))
        elif K.image_dim_ordering() == 'tf' and image.shape != (1, IMAGE_SIZE, IMAGE_SIZE, 3):
            image = resize_with_pad(image)
            image = image.reshape((1, IMAGE_SIZE, IMAGE_SIZE, 3))
        image = image.astype('float32')
        image /= 255  # 将图像矩阵转化到0-1之间
        result = self.model.predict_proba(image)
        max_index = np.argmax(result)  # 找出概率最高的
        print('准确度为', result[0][max_index])
        # if (result < 0.8):  # 获取识别的可靠性
        #     return -1
        result = self.model.predict_classes(image)

        return result[0]

    def evaluate(self, dataset):
        score = self.model.evaluate(dataset.X_test, dataset.Y_test, verbose=0)
        print("%s: %.2f%%" % (self.model.metrics_names[1], score[1] * 100))


if __name__ == '__main__':
    dataset = Dataset()
    dataset.read()

    model = Model()
    model.build_model(dataset)
    model.train(dataset, nb_epoch=10)
    model.save()

    model = Model()
    model.load()
    model.evaluate(dataset)

• 下载本文深度学习Opencv的人脸识别系统完整的代码和参考报告链接（或者可以文末联系博主koukou(壹壹23七2五六98)，获取源码和报告）https://download.csdn.net/download/shooter7/89093912
• 此处是另外一个系统描述的链接：基于机器学习KNN算法手写数字识别系统，可用于毕设课设。https://blog.csdn.net/shooter7/article/details/113337835