devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于OpenCV和Dlib的深度学习人脸识别技术实践与应用_opencv dlib

作者：你好赵伟 | 2024-04-22 06:11:10

赞

踩

opencv dlib

一、背景介绍

计算机视觉技术在当前人工智能发展进程中已然达到较高成熟度,一系列基础算法与应用场景获得广泛实践与验证。在算法层面,图像处理、目标检测、语义分割等多个领域的技术不断突破,准确率与效率持续提升。在应用上,人脸识别、车牌识别、医学图像分析等已步入商业化应用阶段,被广泛应用于安防监控、智能驾驶、医疗辅助诊断等领域,大幅提升效率并创造新的应用形式。

基于此,结合公司规划与业务需求,我们决定在人脸识别领域进行自主研发与应用。具体来看,公司主要面临以下应用需求:

  • 业务背景：主要应用于一些智能终端设备上，在进行权限验证和流程控制上需要进行人脸识别验证

  • 平台架构：平台整体架构以云+端的模式，一个云平台部署在地市或者省厅，下属分局和派出所等场所部署N个终端设备，每台设备配置双目摄像头，连接云端平台，实现人脸相关功能。

  • 部署架构：平台主要部署在地市和省厅，平台系统整体并发量并不算特别高，一般地市也就在20 ～ 30 QPS。但需要部署在专网，所以人脸服务需可做本地私有化部署，无法使用SaaS服务。

  • 功能需求：软件平台包括人脸库的管理，和人脸数据采集。终端设备主要包括人脸识别、人脸比对（1:1和1:N）、活体检测。

  • 人脸底库：根据实际部署需求，底库从万级到千万级不等。具体根据项目规模来。

通过自主研发,我们不仅能充分考量业务场景的特点,实现针对性的技术创新与效率优化,也能随时针对算法与模型进行调整升级,为公司整体技术实力与核心竞争力的提升奠定坚实基础。

本文将介绍如何使用 Dlib 库和深度学习来实现人脸识别，如何利用预训练网络和OpenCV库进行图像处理。OpenCV 库将用于执行一些简单的图像处理任务，例如将图像转换为灰度、调整图像大小等，从而轻松地在各种场景中应用人脸识别技术。

我们将使用 Dlib 提供的预训练网络。该网络已在超过 300 万张图像的数据集上进行了训练。该网络称为 ResNet-34。

二、人脸识别概述

人脸识别是一种通过分析个人面部特征来识别或验证身份的技术。它在验证个人身份、寻找失踪人员、识别罪犯等方面发挥着重要作用。该技术利用已知人脸的数据库，将其与未知人脸进行比较，以找到匹配并预测其身份。

为了实现这一目标，人脸识别采用了多种算法，包括特征脸、局部二进制模式和深度学习等。本文将深入探讨如何运用深度学习方法来进行人脸识别，以提高准确性和效率。通过学习这些技术，您将能够更好地理解人脸识别的原理和应用，并在实际场景中应用它们。无论是保障安全、提升便捷性还是推动科技创新，人脸识别都具有广阔的前景和潜力。

三、人脸识别步骤

人脸识别一般分为以下4步：

  1. 人脸检测：人脸识别流程的第一步是检测图像中的所有人脸。通过使用不同的人脸检测器（如Haar级联、HOG或基于深度学习的检测器），我们可以检测图像中的人脸。本文我们将使用 Dlib 提供的 HOG 人脸检测器实现。

  2. 面部对齐（可选）：使用面部标志来对齐或标准化面部，以提高识别系统的准确性。本文将跳过此步骤。

  3. 面部编码：将面部图像传递给模型，并提取面部特征。

  4. 人脸识别：将提取的人脸特征与已知人脸特征的数据库进行比较，尝试找到匹配。常用的算法包括K最近邻（KNN）、支持向量机（SVM）和随机森林等。

四、人脸识别算法及基本原理？

基于深度学习的人脸识别算法是建立在卷积神经网络（CNN）的基础上的。这些算法中的一种被称为孪生网络，它由两个或多个相同的子网络组成。每个子网络共享相同的权重和参数。这种架构使得模型能够比较输入图像并找到它们之间的相似性，这对于人脸识别非常重要。

 目前，有许多先进的孪生网络架构被用于人脸识别，其中一些包括：

  1. VGG-Face：基于VGGNet的人脸识别模型，具有较高的准确性和鲁棒性。

  2. Dlib的基于ResNet的人脸识别模型：使用ResNet架构，该模型在人脸识别领域表现出色。

  3. FaceNet：通过将人脸图像映射到高维空间中的特征向量来实现人脸识别。

  4. OpenFace：采用深度神经网络进行人脸识别，具有较高的准确性和鲁棒性。

  5. Facebook DeepFace：Facebook开发的人脸识别系统，利用深度学习技术实现高精度的人脸识别。

  6. DeepID：通过多层神经网络学习人脸特征，实现准确的人脸识别。

  7. ArcFace：采用角度余弦损失函数来提高人脸识别的准确性。

  8. SFace：结合了判别性特征学习和度量学习的人脸识别算法，具有较高的鲁棒性和准确性。

在本文中，我们将使用Dlib基于ResNet-34架构的人脸识别模型。该模型通过深度学习技术实现了对人脸的准确识别，并在实际应用中取得了良好的效果。通过研究和理解这些基于深度学习的人脸识别算法及其工作原理，我们可以更好地应用它们于实际场景，并推动人脸识别技术的发展和创新。

在网络训练过程中，该模型使用了三个图像进行输入：

  1. "锚点"图像：这是给定的人物图像，作为训练的基准。

  2. "正样本"图像：这是与锚点图像相同人物的图像，用于训练网络识别相似人物。

  3. "负样本"图像：这是不同人物的图像，用于训练网络区分不同人物。

通过将这三个图像输入到网络中，网络会为每个图像生成一个128维的嵌入向量。

在训练过程中，神经网络使用损失函数来衡量嵌入向量之间的距离。如果相似人物的嵌入向量（即锚点和正样本图像）之间的距离较大，或者两个不同人物的嵌入向量（即锚点和负样本图像）之间的距离较小，则网络会受到惩罚。

通过这种训练方式，网络逐渐学习生成更接近的嵌入向量来表示相同人物的图像，同时将不同人物的图像生成更远离的嵌入向量。这样，网络就能够通过嵌入向量的距离来判断图像之间的相似性，从而实现准确的人脸识别。通过不断优化网络的训练过程，可以提高人脸识别算法的准确性和鲁棒性，使其在实际应用中更加可靠和有效。

孪生网络的训练过程示例

一旦网络训练完成，我们可以利用它为新图像生成嵌入向量。这些嵌入向量可用于训练人脸识别分类器，而分类器可以采用各种机器学习算法，如K最近邻（KNN）、支持向量机（SVM）和随机森林等。在本文中，我们将使用K最近邻算法。

然而，需要说明的是，我们并不需要从头开始训练模型，因为我们可以使用一个预训练好的模型。因此，我们的任务是获取这个预训练好的模型，并利用它为我们自己的数据集生成特征（也称为嵌入向量）。接着，我们将这些特征存储在数据库或文件中。

当我们获得一张新的图像时，我们会检测图像中的人脸，并从图像中提取出人脸区域，然后将其输入到模型中。模型会生成一个128维的嵌入向量。

最后，我们使用K最近邻算法计算这个新人脸嵌入向量与我们数据库中所有人脸嵌入向量之间的距离。距离最接近的人就是新图像中的人。

通过这样的流程，我们能够快速准确地识别人脸，实现高效的人脸识别应用。这种基于深度学习的人脸识别算法在安全领域、人脸支付、人脸门禁等多个领域具有广泛的应用前景。

五、人脸识别服务开发

5.1、安装必要依赖库

为了实现人脸识别功能，我们需要安装一些必要的依赖库，包括OpenCV、Dlib和Numpy（在安装之前，请确保已经安装了CMake）。

这些库都可以通过使用pip命令来进行安装。

首先，我们需要创建一个虚拟环境。然后，激活该虚拟环境，并使用pip命令来安装所需的库。

  1. $ python3 -m venv venv
  2. $ source venv/bin/activate
  3. $ pip install -r requirements.txt

5.2、准备人脸数据集

本文将使用Labeled Faces in the Wild (LFW)数据集进行人脸识别任务。该数据集包含了超过13,000张从网络上收集的面部图像。

这个数据集被分成了5749个目录，每个目录中包含了一个人的1到530张图像。因此，整个数据集中包含了5749个不同的人。

要下载这个数据集，您可以前往LFW数据集网站并点击"Download"按钮。

然后单击All images as gzipped tar file链接进行下载，下载完成后。会得到一个名为lfw.tgz的压缩文件。

解压缩lfw.tgz文件后，您将获得数据集中的所有图像。在本文中，我们将仅选择4个不同的人来执行人脸识别任务。我选择的人物是：阿诺·施瓦辛格、让·克雷蒂安、小泉纯一郎和雷杰普·塔伊普·埃尔多安。

 同时，我们还删除了那些包含多张面孔的图像，因为我们的算法假设每张图像中只有一个或多个属于同一个人的面孔。

5.3、项目整体结构

本教程的项目结构如下：

  1. tree --filelimit 10 --dirsfirst
  2. ├── dataset
  3. │   ├── Arnold_Schwarzenegger  [35 entries]
  4. │   ├── Jean_Chretien  [48 entries]
  5. │   ├── Junichiro_Koizumi  [47 entries]
  6. │   └── Recep_Tayyip_Erdogan  [24 entries]
  7. ├── examples  [14 entries]
  8. ├── models
  9. │   ├── dlib_face_recognition_resnet_model_v1.dat
  10. │   └── shape_predictor_68_face_landmarks.dat
  11. ├── venv
  12. ├── encodings.pickle
  13. ├── face_encoding.py
  14. ├── face_recognition_images.py
  15. ├── face_recognition_videos.py
  16. ├── requirements.txt
  17. └── utils.py

以下是每个目录/文件的简要说明：

  • dataset/：包含我们想要识别的人的图像。

  • example/：包含一些示例图像，我们将使用它们来测试我们的人脸识别系统。

  • models/：包含我们将用于生成人脸嵌入的预训练模型。

  • venv/：我们的虚拟环境。

  • codings.pickle：包含我们数据集中的人脸嵌入的文件。这些嵌入将由face_encoding.py脚本生成。

  • face_encoding.py：此文件包含用于生成数据集中的人脸嵌入的代码。

  • face_recognition_images.py：该文件包含用于对图像执行人脸识别的代码。

  • face_recognition_videos.py：此文件包含对视频执行人脸识别的代码。

  • requirements.txt：包含我们需要安装的库的列表。您可以使用命令pip install -rrequirements.txt安装它们。

  • utils.py：为了使我们的代码更有条理，我们将把所有实用函数放在这个文件中。

5.4、提取人脸特征

在进行人脸识别之前，我们首先需要加载待识别人物的图像。然后，我们将从这些图像中提取出面部区域，并为每个面部区域生成相应的面部嵌入。接下来，让我们导入所需的包和模型。请打开utils.py文件，并编写以下代码：

  1. import dlib
  2. from glob import glob 
  3. import cv2
  4. import numpy as np
  5. import os
  6.  
  7. # 加载人脸检测器、关键点预测器和人脸识别模型
  8. face_detector = dlib.get_frontal_face_detector()
  9. shape_predictor = dlib.shape_predictor("models/shape_predictor_68_face_landmarks.dat")
  10. face_encoder = dlib.face_recognition_model_v1("models/dlib_face_recognition_resnet_model_v1.dat")

人脸检测器（face_ detector）用于检测输入图像中的人脸区域。

地标预测器 ( ***shape_predictor*** ) 用于定位面部区域中的面部地标。我们需要面部标志来生成面部嵌入。

人脸编码器模型（face_encoder）用于生成人脸嵌入。

接下来，我们将获取数据集中图像的路径。让我们为此创建一个辅助函数：

  1. # 更改此处以包括您想要支持的其他图像格式（例如.bmp）
  2. VALID_EXTENSIONS = ['.png', '.jpg', '.jpeg']
  3.  
  4. def get_image_paths(root_dir, class_names):
  5.     """ 获取数据集中图像的路径"""
  6.     image_paths = []

get_image_paths **()函数有两个参数：root_dir和class_names。rootdir是数据集的路径。classnames是我们想要识别的每个人的姓名列表。class_names**列表如下所示：

  1. >>> class_names
  2. [‘Huangjiaju’, 'Zhangguorong', 'Recep_Tayyip_Erdogan', 'Jean_Chretien', 'Junichiro_Koizumi', 'Arnold_Schwarzenegger']

现在，我们将循环遍历类名，对于每个类名，我们将循环遍历目录中的图像，并将图像的路径添加到 image_paths 列表中。

  1.     # 循环遍历类名
  2.     for class_name in class_names:
  3.         # 获取当前类目录中文件的路径
  4.         class_dir = os.path.sep.join([root_dir, class_name])
  5.         class_file_paths = glob(os.path.sep.join([class_dir, '*.*']))
  6.  
  7.         # 循环遍历当前类目录中的文件路径
  8.         for file_path in class_file_paths:
  9.             # 提取当前文件的文件扩展名
  10.             ext = os.path.splitext(file_path)[1]
  11.  
  12.             # 如果文件扩展名不在有效扩展名列表中，则忽略该文件
  13.             if ext.lower() not in VALID_EXTENSIONS:
  14.                 print("Skipping file: {}".format(file_path))
  15.                 continue
  16.  
  17.             # 将当前图像的路径添加到图像路径列表中
  18.             image_paths.append(file_path)
  19.  
  20.     return image_paths

glob **()**函数返回当前类目录中文件的路径列表。我们循环遍历文件路径并提取当前文件的文件扩展名。如果文件扩展名无效（不是图像），我们将跳过它并继续下一个。

如果文件扩展名有效（图像），我们将当前图像的路径添加到image_paths列表中。让我们测试一下get_image_paths()函数。

  1. >>> from utils import get_image_paths
  2. >>> class_names = ['Recep_Tayyip_Erdogan', 'Jean_Chretien', 'Junichiro_Koizumi', 'Arnold_Schwarzenegger']
  3. >>> image_paths = get_image_paths("dataset", class_names)
  4. >>> image_paths
  5. ['dataset/Recep_Tayyip_Erdogan/Recep_Tayyip_Erdogan_0017.jpg', 'dataset/Recep_Tayyip_Erdogan/Recep_Tayyip_Erdogan_0013.jpg', 'dataset/Recep_Tayyip_Erdogan/Recep_Tayyip_Erdogan_0012.jpg', ...]

如您所见，get_image_paths()函数返回数据集中图像的路径列表。接下来，我们将创建一个辅助函数来从图像中提取面部区域。为此，我们将使用 Dlib 人脸检测器。

  1. def face_rects(image):
  2.     # 将图像转换为灰度图像
  3.     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
  4.     # 在灰度图像中检测人脸
  5.     rects = face_detector(gray, 1)
  6.     # 返回边界框
  7.     return rects

face_rects **()**函数将图像作为输入并将我们的面部检测器应用于它。它返回图像中面部区域的边界框。现在我们有了边界框，我们可以使用它们来应用地标预测器并获取面部地标。

  1. def face_landmarks(image):
  2.     return [shape_predictor(image, face_rect) for face_rect in face_rects(image)]

该函数循环遍历每个面部区域的边界框。对于每个面部区域，它应用地标预测器。它返回一个包含每个面部区域的面部标志的列表。现在，最后一步是为每个面部区域生成面部嵌入。同样，我们将为此创建一个辅助函数。

  1. def face_encodings(image):
  2.     # 计算每个人脸的面部嵌入。`compute_face_descriptor`函数返回一个描述图像中人脸的128维向量
  3.     return [np.array(face_encoder.compute_face_descriptor(image, face_landmark)) 
  4.             for face_landmark in face_landmarks(image)]

因此，这里的face_encodings()函数将图像作为输入并循环遍历每个面部区域的面部标志。对于每个面部区域，它应用面部编码器并生成面部嵌入。它返回一个包含每个面部区域的面部嵌入的列表。让我们测试一下我们的face_encodings()函数。

  1. >>> from utils import face_encodings
  2. >>> import cv2
  3. >>> image = cv2.imread("dataset/Recep_Tayyip_Erdogan/Recep_Tayyip_Erdogan_0017.jpg")
  4. >>> face_encodings(image)
  5. [array([-0.06507568,  0.09282234, -0.05310396,  0.02033956, -0.05189228,
  6.         0.0038331 ,  0.02058978, -0.16266678,  0.16215618, -0.07854272,
  7.         0.22294444, -0.02746225, -0.21170133, -0.10646843,  0.12207212,
  8.         0.08830512, -0.1529105 , -0.15543598, -0.13133761, -0.07789465,
  9.        -0.01266594, -0.03342287, -0.07684287, -0.01465143, -0.16457887,
  10.        -0.29837033, -0.07858203, -0.06912123,  0.10793255, -0.06668072,
  11.         0.05952527, -0.01771747, -0.18992454, -0.10981462,  0.09109481,
  12.         0.06847958, -0.06725877, -0.02276845,  0.15260877, -0.05116167,
  13.        -0.13816157, -0.05038669,  0.10000665,  0.25293767,  0.11579101,
  14.         0.09511411,  0.05221565, -0.10308918, ...])]
  15. >>> face_encodings(image)[0].shape
  16. (128,)

如您所见，face_encodings()函数返回一个列表，其中包含图像中每个人脸区域的人脸嵌入。每个人脸嵌入都是一个 128 维的 Numpy 数组。

我们将从数据集中的每个图像生成人脸嵌入开始。然后我们将面部嵌入存储在字典中。字典的键将是数据集中每个人的姓名，值将是该人的每个图像的面部嵌入列表。

最后，我们将字典保存到磁盘。打开face_encoding.py文件并添加以下代码：

  1. import pickle
  2. import cv2
  3. import os
  4.  
  5. from utils import get_image_paths
  6. from utils import face_encodings
  7.  
  8.  
  9. root_dir = "dataset"
  10. class_names = os.listdir(root_dir)
  11.  
  12. # 获取图像的路径
  13. image_paths = get_image_paths(root_dir, class_names)
  14. # 初始化一个字典来存储每个人的姓名和相应的编码
  15. name_encondings_dict = {}

我们将使用pickle模块将字典保存到文件中，以便稍后在测试人脸识别系统时使用它。这里我们使用get_image_paths()函数来获取数据集中图像的路径。我们还初始化一个字典来存储标签（每个人的名字）和相应的面部嵌入。现在，我们将循环图像的路径并为每个图像生成面部嵌入。

  1. # 初始化处理的图像数量
  2. nb_current_image = 1
  3. # 现在我们可以循环遍历图像路径，定位人脸并对其进行编码
  4. for image_path in image_paths:
  5.     print(f"Image processed {nb_current_image}/{len(image_paths)}")
  6.     # 加载图像
  7.     image = cv2.imread(image_path)
  8.     # 获取人脸嵌入
  9.     encodings = face_encodings(image)
  10.     # 从图像路径中获取姓名
  11.     name = image_path.split(os.path.sep)[-2]
  12.     # 获取当前姓名的编码
  13.     e = name_encondings_dict.get(name, [])
  14.     # 更新当前姓名的编码列表
  15.     e.extend(encodings)
  16.     # 更新当前姓名的编码列表
  17.     name_encondings_dict[name] = e
  18.     nb_current_image += 1

所以这里我们循环遍历图像的路径。对于每条路径，我们使用 OpenCV 加载图像并使用face_encodings()函数生成人脸嵌入。

回想一下，在内部，face_encodings()函数应用面部检测器来获取图像中面部区域的边界框，然后应用标志预测器来获取面部标志。最后，它使用面部标志应用面部编码器来生成面部嵌入。

我们还从图像的路径中获取人名。图像路径的格式为 dataset /RecepTayyipErdogan/RecepTayyipErdogan_0017.jpg。因此，我们可以通过使用目录分隔符 ( os.path.sep )分割路径并获取列表的倒数第二个元素来获取人员的姓名。

接下来，我们尝试从字典中获取当前人的面部嵌入列表。如果字典中没有这个人的名字，我们会为面部嵌入初始化一个空列表。

然后，我们使用为当前图像生成的人脸嵌入来扩展嵌入列表。最后，我们使用当前人的新面部嵌入列表更新字典。

循环之后，我们将拥有一个字典，其中包含每个人的姓名以及该人的每个图像的相应面部嵌入列表。

字典看起来像这样：

  1. >>> name_encondings_dict
  2. {'Recep_Tayyip_Erdogan': [array([-0.05895536,  0.07766615,  ...]), 
  3.                           array([-0.04809677,  0.08508434,  ...]),
  4.                           ...], 
  5. 'Jean_Chretien': [array([-0.18319653,  -0.18853943, ...]),
  6.                   array([-0.065067637,  0.13090725, ...]),
  7.                   ...],
  8. 'Junichiro_Koizumi': [array([-0.18313943, 0.07619441, ...]),
  9.                       array([-0.18313943,  0.0761441, ...]),
  10.                       ...],
  11. 'Arnold_Schwarzenegger': [array([-0.117762501,  0.152411991, ...]),
  12.                           array([-0.117625501,  0.152341991, ...]),
  13.                           ...],
  14. }

最后一步是使用pickle模块将字典保存到文件中。

  1. # 将名称编码字典保存到磁盘
  2. with open("encodings.pickle", "wb") as f:
  3.     pickle.dump(name_encondings_dict, f)

现在，我们可以运行face_encoding.py脚本来为数据集中的每个图像生成人脸嵌入。打开终端，导航到项目目录，然后运行以下命令：

  1. $ python face_encoding.py
  2. Image processed 1/162
  3. Image processed 2/162
  4. Image processed 3/162
  5. ...
  6. Image processed 160/162
  7. Image processed 161/162
  8. Image processed 162/162

脚本运行完成后，您应该在项目目录中看到一个名为encodings.pickle的文件。该文件包含带有每个人的姓名的字典以及该人的每个图像的相应面部嵌入列表。

5.5、人脸识别比对

现在我们有了面部嵌入，我们可以开始识别图像中的面部。我们将在face_recognition_images.py文件中编写以下代码：

  1. import pickle
  2. import cv2
  3.  
  4. from utils import face_rects
  5. from utils import face_encodings
  6.  
  7. # 加载编码 + 名称字典
  8. with open("encodings.pickle", "rb") as f:
  9.     name_encodings_dict = pickle.load(f)
  10.  
  11. # 加载输入图像
  12. image = cv2.imread("examples/18.jpeg")
  13. # 为输入图像中的每个人脸获取128维面部嵌入
  14. encodings = face_encodings(image)
  15. # 此列表将包含图像中检测到的每个人脸的名称
  16. names = []

我们首先加载包含每个人的姓名和相应的面部嵌入列表的字典。接下来，我们使用 OpenCV 加载输入图像，并使用face_encodings()函数为图像中的每个人脸生成人脸嵌入。

下一步是循环面部嵌入并将其与数据集中每个人的面部嵌入进行比较。我们需要另一个辅助函数来计算当前面部嵌入与数据集中每个人的面部嵌入之间的距离。

如果当前人脸嵌入与数据库中的人脸嵌入之间的距离小于阈值，则该人脸被视为匹配，因此我们将当前人的“匹配数”增加 1。

通过查看代码更容易理解这个逻辑。打开utils.py文件并添加以下代码：

  1. def nb_of_matches(known_encodings, unknown_encoding):
  2.     # 计算当前人脸编码与数据库中所有人脸编码之间的欧氏距离
  3.     distances = np.linalg.norm(known_encodings - unknown_encoding, axis=1)
  4.     # 仅保留小于阈值的距离
  5.     small_distances = distances <= 0.6
  6.     # 返回匹配数量
  7.     return sum(small_distances)

nb_of_matches **()**函数采用两个参数：数据集中每个人的面部嵌入列表 ( known_encodings ) 和输入图像中当前面部的面部嵌入 ( unknown_encoding )。

它计算当前人脸编码与数据库中所有人脸编码之间的欧几里德距离。然后，它仅保留小于阈值的距离（如果距离小于阈值，则认为面部匹配）。

最后，将距离小于阈值的次数相加，得到当前人脸的匹配数。现在，我们可以循环输入图像中每个人脸的人脸嵌入，并使用nb_of_matches()函数来获取每个人脸的匹配数。

  1. # 导入辅助函数
  2. from utils import nb_of_matches
  3.  
  4. # 循环遍历编码
  5. for encoding in encodings:
  6.     # 初始化一个字典来存储人名和匹配次数
  7.     counts = {}
  8.     # 循环遍历已知编码
  9.     for (name, encodings) in name_encodings_dict.items():
  10.         # 计算当前编码与已知人脸编码之间的匹配次数，并将匹配次数存储在字典中
  11.         counts[name] = nb_of_matches(encodings, encoding)
  12.     # 检查所有匹配次数是否都等于0，如果没有任何名称匹配，则将名称设置为"Unknown"
  13.     if all(count == 0 for count in counts.values()):
  14.         name = "Unknown"
  15.     # 否则，获取匹配次数最高的名称
  16.     else:
  17.         name = max(counts, key=counts.get)
  18.  
  19.     # 将名称添加到名称列表中
  20.     names.append(name)

因此，我们首先初始化一个字典来跟踪每个人的匹配次数。然后，使用已知编码的字典，我们调用nb_of_matches()函数来获取当前面部编码的匹配次数，并将其存储在计数字典中。

接下来，我们使用counts字典来获取匹配次数最多的人的名字。如果没有任何人匹配（所有匹配次数等于0），我们将名称设置为“未知”。然后，我们将该名称添加到名称列表中。

最后一步是在输入图像中的每个人脸周围绘制一个矩形，并在矩形顶部写下人的名字。

  1. # 使用`face_rects`函数循环遍历输入图像中人脸的矩形
  2. for rect, name in zip(face_rects(image), names):
  3.     # 使用`rect`变量获取每个人脸的边界框
  4.     x1, y1, x2, y2 = rect.left(), rect.top(), rect.right(), rect.bottom()
  5.     # 绘制人脸的边界框以及人名
  6.     cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
  7.     cv2.putText(image, name, (x1, y1 - 10), 
  8.             cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 2)
  9.  
  10. # 显示输出图像
  11. cv2.imshow("image", image)
  12. cv2.waitKey(0)

我们使用 face_rects() 函数返回输入图像中每个面的矩形列表。这些矩形由Dlib库提供。我们遍历矩形并获取每个面的边界框。然后，我们在每张脸周围画一个矩形，并在矩形顶部写下人的名字。最后，我们使用OpenCV显示输出图像。

现在，是时候测试我们的人脸识别算法了。我已经在示例文件夹中添加了一些图像。以下是我们的人脸识别算法的输出示例：

 在这个例子中，我测试了示例文件夹内的一些图像。正如您所看到的，算法正确识别了图像中每个人的面孔。现在，如果输入图像中有多个人怎么办？让我们看一个例子：

正如您所看到的，算法正确识别了同一图像中的三张脸。如果某个人的面孔不在我们的数据集中怎么办？让我们看一个例子：

 我们的数据集不包含右侧人的图像，但我们的算法足够聪明，可以将他标记为“Unknown”人。关于视频中的人脸识别，代码与图像代码几乎相同。唯一的区别是我们需要循环播放视频的帧。

六、总结

本文介绍了人脸识别技术在计算机视觉领域的应用和发展。首先，文章提到了计算机视觉技术在人工智能中的成熟度和广泛应用，特别是在图像处理、目标检测和语义分割等领域的突破。然后，文章指出了公司在人脸识别领域进行自主研发与应用的需求和背景，包括业务背景、平台架构、部署架构和功能需求等。接着，文章介绍了如何使用Dlib库和深度学习来实现人脸识别，并利用预训练网络和OpenCV库进行图像处理。最后，文章概述了人脸识别的定义、应用和步骤，包括人脸检测、面部对齐、面部编码和人脸识别。文章还提到了基于深度学习的人脸识别算法及其工作原理。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/467190
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号