【深度学习】基于卷积神经网络（tensorflow）的人脸识别项目（四）

2023年7月29日上午2:03 • 人工智能 • 阅读 81

首先需要收集数据，我的想法是通过OpenCV调用摄像头进行收集人脸照片。
然后进行预处理，主要是对数据集分类，训练集、验证集、测试集。
开始训练模型，提前创建好标签键值对。
测试人脸识别效果，通过OpenCV捕获人脸照片然后对图片进行预处理最后传入模型中，然后将识别的结果通过文字的形式打印在屏幕上，以此循环，直到输入q退出。

本篇主要是对上述步骤中的第四步进行实现。最后分享整个全流程的完整项目代码。

测试人脸识别效果

设计思路

通过OpenCV打开摄像头捕捉人脸区域，然后对图片进行预处理（如灰度化、归一化等等），然后加载模型，把处理后的图片放入模型中进行预测，然后对预测的结果进行一个精度过滤就是对识别率低于90%的结果认为识别不准确，就会输出other表示不能高度识别。正常情况下输出每个文件所对应的label。

详细代码

加载模型

将我们之前训练好的模型通过load_model方法进行加载。

    MODEL_PATH = './me.face.model.h5'
    def load_model(self, file_path=MODEL_PATH):
        self.model = load_model(file_path)

人脸预测

这里对图片进行了归一化处理，并对预测结果进行了精度过滤。
注意： K.image_dim_ordering() =\= 'th': 如果报错的话请替换为 K.image_data_format() == 'channels_first' ” channels_last“对应原本的” tf“，” channels_first“对应原本的” th“。

    def face_predict(self, image):
        if K.image_data_format() == 'channels_first' and image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
            image = resize_image(image)
            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))
        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 = self.model.predict_proba(image)
        print('result:', result)
        my_result = list(result[0]).index(max(result[0]))
        max_result = max(result[0])
        print("result最大值下标:", my_result)
        if max_result > 0.90:
            return my_result
        else:
            return -1

主要逻辑

主要分为以下几步骤：

加载模型
预处理(设置摄像头、人脸区域的边框颜色、haar分类器的路径、label数组等)
捕获一帧图片
对图片灰度化
计算出人脸区域并框出
将人脸区域交给识别模型进行识别
将识别结果进行屏幕打印
然后3-7步骤循环。
输入q退出识别，然后释放所占用的资源

这个逻辑不是很复杂，下面直接进行代码展示，在代码中也有详细的注释说明：

import cv2
from keras_train import Model

if __name__ == '__main__':
    model = Model()
    model.load_model(file_path='./model/me.face.model.h5')

    color = (0, 255, 0)

    cap = cv2.VideoCapture(0)

    cascade_path = "./model/haarcascade_frontalface_alt2.xml"

    while True:
        _, frame = cap.read()

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

        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)

                human = {0: 'use2', 1: 'use3', 2: 'use4', -1: 'others', 3: 'use5', 4: 'LinXi07',
                         5: 'use7', 6: 'use8', 7: 'use1', 8: 'use9'}

                cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness=2)

                cv2.putText(frame, human[faceID],
                            (x + 30, y + 30),
                            cv2.FONT_HERSHEY_SIMPLEX,
                            1,
                            (255, 0, 255),
                            2)

        cv2.imshow("Face Identification System", frame)

        k = cv2.waitKey(10)

        if k & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

测试效果

这里对模型进行测试，并支持多个人脸同时识别，且识别率较高。（ 忽略掉人脸）

; 总结

从最开始的收集数据到中间的预处理再到后来的模型建立到最后的测试效果，这一路非常坎坷，不是数据格式不匹配导致报错，就是版本不匹配来回重装环境再就是模型识别率上不去。总算把这个完整的做出来了，路途坎坷但收获不菲。让我们一起加油吧！！！！

所有代码

这里我以文件进行分类，总共四个文件。

文件名说明frame_capture.py制作数据集keras_train.py训练模型评估模型load_data.py加载数据，预处理face_predict_use_keras.py预测模型

然后deep_learning用来存放每个人的照片。model用来存放模型好的模型以及harr分类器。

; face_predict_use_keras.py

import cv2
import sys

def catch_usb_video(window_name, camera_idx):
    '''使用cv2.imshow()的时候，如果图片太大，会显示不全并且无法调整。
    因此在cv2.imshow()的前面加上这样的一个语句：cv2.namedWindow('image', 0)，
    得到的图像框就可以自行调整大小，可以拉伸进行自由调整。'''
    cv2.namedWindow(window_name, 0)

    cap = cv2.VideoCapture(camera_idx)

    '''
    Haar特征是一种反映图像的灰度变化的，像素分模块求差值的一种特征。它分为三类：边缘特征、线性特征、中心特征和对角线特征。
    '''
    classfier = cv2.CascadeClassifier("./model/haarcascade_frontalface_alt2.xml")

    color = (0, 0, 255)
    num = 0
    while cap.isOpened():
        ok, frame = cap.read()
        if not ok:
            break

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

        faceRects = classfier.detectMultiScale(grey, scaleFactor=1.2, minNeighbors=3, minSize=(32, 32))

        if len(faceRects) > 0:
            for faceRect in faceRects:

                x, y, w, h = faceRect
                cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, 2)

                img_name = '%s/%d.jpg' % ('./deep_learning/zm', num)
                image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
                cv2.imwrite(img_name, image)
                num += 1
                if num > (500):
                    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 > (500):
            break

        cv2.imshow(window_name, frame)
        c = cv2.waitKey(1)
        if c & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

if __name__ == '__main__':
    catch_usb_video("face", 0)

keras_train.py

import random
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=3):

        images, labels = load_dataset(self.path_name)

        train_images, valid_images, train_labels, valid_labels = train_test_split(images, labels, test_size=0.2,
                                                                                  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))

        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')

            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')

            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

class Model:
    def __init__(self):
        self.model = None

    def build_model(self, dataset, nb_classes=3):

        self.model = Sequential()

        self.model.add(Convolution2D(32, 3, 3, border_mode='same',
                                     input_shape=dataset.input_shape))
        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=20, nb_epoch=10, data_augmentation=True):

        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:
            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 = ImageDataGenerator(
                featurewise_center=False,
                samplewise_center=False,
                featurewise_std_normalization=False,
                samplewise_std_normalization=False,
                zca_whitening=False,
                rotation_range=20,
                width_shift_range=0.2,
                height_shift_range=0.2,
                horizontal_flip=True,
                vertical_flip=False)

            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 = './me.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_data_format() == 'channels_first' and image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
            image = resize_image(image)
            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))
        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 = self.model.predict_proba(image)
        print('result:', result)
        my_result = list(result[0]).index(max(result[0]))
        max_result = max(result[0])
        print("result最大值下标:", my_result)
        if max_result > 0.90:
            return my_result
        else:
            return -1

if __name__ == '__main__':
    dataset = Dataset('.\\deep_learning')
    dataset.load(nb_classes=9)

    model = Model()
    model.build_model(dataset, nb_classes=9)
    model.train(dataset)
    model.save_model(file_path='./model/me.face.model.h5')

    model = Model()
    model.load_model(file_path='./model/me.face.model.h5')
    model.evaluate(dataset)

load_data.py

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]

    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)

                images.append(image)
                labels.append(path_name)

    return images, labels

def indentify(label):
    if label.endswith('use'):
        return 0
    elif label.endswith('use'):
        return 1
    elif label.endswith('use'):
        return 2
    elif label.endswith('use'):
        return 3
    elif label.endswith('use'):
        return 4
    elif label.endswith('use'):
        return 5
    elif label.endswith('use'):
        return 6
    elif label.endswith('use'):
        return 7
    elif label.endswith('use'):
        return 8

def load_dataset(path_name):
    images, labels = read_path(path_name)

    images = np.array(images)
    print(images.shape)

    labels = np.array([indentify(label) for label in labels])

    print(images,labels)
    return images, labels

if __name__ == '__main__':
    images, labels = load_dataset('./deep_learning')

face_predict_use_keras.py

import cv2
from keras_train import Model

if __name__ == '__main__':

    model = Model()
    model.load_model(file_path='./model/me.face.model.h5')

    color = (0, 255, 0)

    cap = cv2.VideoCapture(0)

    cascade_path = "./model/haarcascade_frontalface_alt2.xml"

    while True:
        _, frame = cap.read()

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

        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)

                human = {0: 'use3', 1: 'use4', 2: 'use8', -1: 'others', 3: 'use88', 4: 'LinXi07',
                         5: 'use2', 6: 'use', 7: 'use1', 8: 'use7'}

                cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness=2)

                cv2.putText(frame, human[faceID],
                            (x + 30, y + 30),
                            cv2.FONT_HERSHEY_SIMPLEX,
                            1,
                            (255, 0, 255),
                            2)

        cv2.imshow("Face Identification System", frame)

        k = cv2.waitKey(10)

        if k & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

以上就是全部代码啦。有啥疑问就评论区讨论奥。

Original: https://blog.csdn.net/qq_45254369/article/details/126492132
Author: 林夕07
Title: 【深度学习】基于卷积神经网络（tensorflow）的人脸识别项目（四）

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/721523/

转载文章受原作者版权保护。转载请注明原作者出处！

人工智能

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

数据分析项目-股票数据分析

目录需求：股票分析数据处理 df的持久化存储 df.to_xxx() 加载外部数据 pd.read_xxx() 将Unnamed: 0列进行删除将date列的字符串类型的时间…

人工智能 2023年7月7日
0065
OFDM雷达信号模糊函数MATLAB仿真分析

OFDM雷达信号模糊函数MATLAB仿真分析 OFDM大家都不陌生，特别是主要研究通信大法的小伙伴们。正交频分复用 (OFDM) 是一种可以在多个正交子载波上编码通信数据的多载波…

人工智能 2023年6月24日
0097
CleanMyMac X2023免费清理苹果电脑Mac磁盘空间

CleanMyMac X2023只需两个简单步骤就可以把系统里那些乱七八糟的无用文件统统清理掉，节省宝贵的磁盘空间。CleanMyMac X2023，X代表界面上的最大升级，功能方…

人工智能 2023年6月29日
0074
第三节课 Pandas，Numpy的简单使用

1、安装numpy 2、numpy的操作 3、相关操作 4、Pandas数据分析 5、绘图 6、数据清洗 pip install numpy 安装jupyter，安装noteboo…

人工智能 2023年7月18日
0051
【Python数据分析】利用Python替换EXCEL表格中指定的数据

如何利用Python替换EXCEL表格中指定的数据？今天与大家一起分享一下DataFrame对象的replace（）函数，replace（）函数可EXCEl中的数据内容，其语法格式…

人工智能 2023年7月14日
0082
JDK19虚拟线程初探（二）

简介在上一篇文章中，我们已经简单的介绍了JEP 425: Virtual Threads (Preview)，以及如何使用虚拟线程编写例程，本文中将继续介绍虚拟线程的底层机制和核…

人工智能 2023年6月27日
0090
Java-多线程的使用

一基本概念：程序、进程、线程为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身…

人工智能 2023年6月28日
0062
Sophon KG升级3.1：打破数据间壁垒，解放企业生产力

知识图谱作为AI从感知智能迈向认知智能的基础，始终是将多元概念及关系有机整合并推理出新知识的关键技术。在刚刚过去的星环科技2022春季新品发布周上，星环科技知识图谱平台Sophon…

人工智能 2023年6月10日
0088
Pandas常用数据结构

一、 Pandas 概述 Pandas(Python Data Analysis Library)是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas …

人工智能 2023年7月7日
0086
【菜菜的sklearn课堂笔记】聚类算法Kmeans-聚类算法的模型评估指标

啊哦~你想找的内容离你而去了哦内容不存在，可能为如下原因导致： ① 内容还在审核中 ② 内容以前存在，但是由于不符合新的规定而被删除 ③ 内容地址错误 ④ 作者删除了内容。可…

人工智能 2023年7月31日
0090
华为机试题 24点

1、描述 2、解题思路暴力法穷举所有的可能的组合（题目只需找到任意满足24点的式子即可）。 4 x 4 x 3 x 4 x 2 x 4 x 1= 256 x 6 = 1536 (…

人工智能 2023年6月4日
0085
NoveAI本地环境搭建、AI作画

鉴于按照别人的教程安装过程中遇到各种问题,极其痛苦,所以还是自己也整理总结一份. 1 diffusion vs GAN 所谓扩散算法diffusion是指先将一幅画面逐步加入噪点，…

人工智能 2023年7月26日
0060
dataframe聚合

dataframe聚合 import pandas as pds = pd.read_csv(‘…/conf/dataframe.csv’) #…

人工智能 2023年7月8日
0059
软件项目管理–进度计划

软件项目管理–进度计划项目初始–项目计划–项目执行控制–项目结束项目计划：范围计划成本计划进度计划质量计划配置管理计划人员与沟通计划风险计划合同计划集成计划 …

人工智能 2023年6月29日
0072
【论文阅读】Speaker-Conditional Chain Model for Speech Separation and Extraction

Speaker-Conditional Chain Model for Speech Separation and Extraction 表格总结暂略文章结构 Abstract…

人工智能 2023年5月25日
0067
python dataframe去除重复项_详解pandas使用drop_duplicates去除DataFrame重复项参数

Pandas之drop_duplicates：去除重复项 DataFrame.drop_duplicates(subset=None, keep=’first&#821…

人工智能 2023年7月7日
0083

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31