基于 DNN 的人脸检测和识别

目录

• 简介
• 模型
• 代码
• 说明
  • 人脸识别
• 参考文献
• 鸣谢

上一教程：高级 API：TextDetectionModel 和 TextRecognitionModel
下一教程：转换 PyTorch 分类模型并通过 OpenCV Python 启动

原作者	Chengrui Wang，Yuantao Feng
兼容性	OpenCV >= 4.5.4

简介

在本节中，我们介绍基于 DNN 的人脸检测器 cv::FaceDetectorYN 类和基于 DNN 的人脸识别器 cv::FaceRecognizerSF 类。

模型

此模块需要有两种预训练模型（ONNX 格式）

• 人脸检测:
  • 大小：338KB
  • WIDER Face 验证集结果：0.830(简单)，0.824(中等)，0.708(困难)
• 人脸识别
  • 大小：36.9MB
  • 结果

数据库	准确度	阈值 (normL2)	阈值（余弦）
LFW	99.60%	1.128	0.363
CALFW	93.95%	1.149	0.340
CPLFW	91.05%	1.204	0.275
AgeDB-30	94.90%	1.202	0.277
CFP-FP	94.80%	1.253	0.212

代码

C++

• 可下载代码：单击此处 下载
• 代码一览

  #include <opencv2/dnn.hpp>
  #include <opencv2/imgproc.hpp>
  #include <opencv2/highgui.hpp>
  #include <opencv2/objdetect.hpp>
   
  #include <iostream>
   
  using namespace cv;
  using namespace std;
   
  static
  void visualize(Mat& input, int frame, Mat& faces, double fps, int thickness = 2)
  {
  std::string fpsString = cv::format("FPS : %.2f", (float)fps);
      if (frame >= 0)
  cout << "Frame " << frame << ", ";
  cout << "FPS: " << fpsString << endl;
      对于 (int i = 0; i < faces.行数; i++)
      {
          // 打印结果
  cout << "人脸 " << i
  << ", 左上角坐标: (" << faces.at<float>(i, 0) << ", " << faces.at<float>(i, 1) << "), "
  << "框宽度: " << faces.at<float>(i, 2) << ", 框高度: " << faces.at<float>(i, 3) << ", "
  << "得分: " << cv::format("%.2f", faces.at<float>(i, 14))
  << endl;
   
          // 绘制边界框
  rectangle(input, Rect2i(int(faces.at<float>(i, 0)), int(faces.at<float>(i, 1)), int(faces.at<float>(i, 2)), int(faces.at<float>(i, 3))), Scalar(0, 255, 0), thickness);
          // 绘制地标
  circle(input, Point2i(int(faces.at<float>(i, 4)), int(faces.at<float>(i, 5))), 2, Scalar(255, 0, 0), thickness);
  circle(input, Point2i(int(faces.at<float>(i, 6)), int(faces.at<float>(i, 7))), 2, Scalar(0, 0, 255), thickness);
  circle(input, Point2i(int(人脸.at<float>(i, 8)), int(人脸.at<float>(i, 9))), 2, Scalar(0, 255, 0), thickness);
  circle(input, Point2i(int(人脸.at<float>(i, 10)), int(人脸.at<float>(i, 11))), 2, Scalar(255, 0, 255), thickness);
  circle(input, Point2i(int(人脸.at<float>(i, 12)), int(人脸.at<float>(i, 13))), 2, Scalar(0, 255, 255), thickness);
      }
  putText(input, fpsString, Point(0, 15), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 2);
  }
   
  int main(int argc, char** argv)
  {
      CommandLineParser parser(argc, argv,
          "{help h | | 打印此消息}"
          "{image1 i1 | | 输入图像 1 的路径。用于通过 VideoCapture 检测时省略}"
          "{image2 i2 | | 输入图像 2 的路径。当给出 image1 和 image2 参数时，程序将尝试在这两个图像上找到人脸并运行人脸识别算法}"
          "{video v | 0 | 输入视频的路径}"
          "{scale sc | 1.0 | 用于调整输入视频帧大小的比例因子}"
          "{fd_model fd | face_detection_yunet_2021dec.onnx | 模型的路径。在 https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet 中下载 yunet.onnx}"
          "{fr_model fr | face_recognition_sface_2021dec.onnx | 人脸识别模型的路径。在 https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface 中下载该模型}"
          "{score_threshold | 0.9 | 过滤出分数 < 得分数_阈值的}"
          "{nms_threshold | 0.3 | 抑制 iou >= nms_threshold 的边界框}"
          "{top_k | 5000 | 在 NMS 前保留 top_k 边界框}"
          "{save s | false | 设为 true 以保存结果。当使用摄像头时，此标志无效}"
      );
      if (parser.has("help"))
      {
  parser.printMessage();
          return 0;
      }
   
      String fd_modelPath = parser.get<String>("fd_model");
      字符串 fr_modelPath = 解析器.获取<字符串>("fr_model");
   
      浮点数 scoreThreshold = 解析器.获取<浮点数>("score_threshold");
      浮点数 nmsThreshold = 解析器.获取<浮点数>("nms_threshold");
      整数 topK = 解析器.获取<整数>("top_k");
   
      布尔值 save = 解析器.获取<布尔值>("save");
      浮点数 scale = 解析器.获取<浮点数>("scale");
   
      双精度浮点数 cosine_similar_thresh = 0.363;
      双精度浮点数 l2norm_similar_thresh = 1.128;
   
      // 初始化 FaceDetectorYN
      Ptr<FaceDetectorYN> 检测器 = FaceDetectorYN::创建(fd_modelPath, "", 尺寸(320, 320), scoreThreshold, nmsThreshold, topK);
   
      TickMeter tm;
   
      // 如果输入是一幅图像
      如果 (解析器.拥有("image1"))
      {
          字符串 输入1 = 解析器.获取<字符串>("image1");
          矩阵 图像1 = imread(样本::查找文件(输入1));
          如果 (图像1.为空())
          {
  std::cerr << "无法读取图像：" << 输入1 << std::endl;
              return 2;
          }
   
          整数 图像宽度 = int(图像1.cols * scale);
          整数 图像高度 = int(图像1.rows * scale);
          resize(图像1, 图像1, 尺寸(图像宽度, 图像高度));
  tm.start();
   
          // 在推理前设置输入尺寸
  检测器->设置输入尺寸(图像1.尺寸());
   
          矩阵 faces1;
  检测器->检测(图像1, faces1);
          如果 (faces1.行 < 1)
          {
  std::cerr << "无法在 "" 中找到一张人脸 << 输入1 << std::endl;
              return 1;
          }
   
  tm.stop();
          // 在输入图像上绘制结果
  可视化(图像一, -1, faces1, tm.getFPS());
   
          // 如果保存为真，则保存结果
          如果 (save)
          {
  cout << "正在保存 result.jpg...\n";
              imwrite("result.jpg", 图像一);
          }
   
          // 可视化结果
          imshow("image1", image1);
          pollKey(); // 处理用户界面事件以显示内容
   
          if (parser.has("image2"))
          {
              String input2 = parser.get<String>("image2");
              Mat image2 = imread(samples::findFile(input2));
              if (image2.empty())
              {
  std::cerr << "无法读取 image2: " << input2 << std::endl;
                  return 2;
              }
   
  tm.reset();
  tm.start();
  detector->setInputSize(image2.size());
   
              Mat faces2;
  detector->detect(image2, faces2);
              if (faces2.rows < 1)
              {
  std::cerr << "无法在 " << input2 << " 中找到人脸" std::endl;
                  return 1;
              }
  tm.stop();
  visualize(image2, -1, faces2, tm.getFPS());
              如果 (save)
              {
  cout << "正在保存 result2.jpg...\n";
                  imwrite("result2.jpg", image2);
              }
              imshow("image2", image2);
              pollKey();
   
              // 初始化 FaceRecognizerSF
              Ptr<FaceRecognizerSF> faceRecognizer = FaceRecognizerSF::create(fr_modelPath, "");
   
   
              // 通过检测到的人脸中的第一个脸部对人脸图像进行对齐和裁剪。
              Mat aligned_face1, aligned_face2;
  faceRecognizer->alignCrop(image1, faces1.row(0), aligned_face1);
  faceRecognizer->alignCrop(image2, faces2.row(0), aligned_face2);
   
              // 使用给定的对齐人脸运行特征提取
              Mat feature1, feature2;
  faceRecognizer->feature(aligned_face1, feature1);
  feature1 = feature1.clone();
  faceRecognizer->feature(aligned_face2, feature2);
  feature2 = feature2.clone();
   
              double cos_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_COSINE);
              double L2_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_NORM_L2);
   
              如果 (cos_score >= cosine_similar_thresh)
              {
  std::cout << "它们有相同的身份；";
              }
              否则
              {
  std::cout << "它们有不同的身份；";
              }
  std::cout << "余弦相似度："  << cos_score << ", 阈值："  << cosine_similar_thresh << ".（较高值表示更高的相似度，最大 1.0）\n";
   
              如果 (L2_score <= l2norm_similar_thresh)
              {
  std::cout << "它们有相同的身份；";
              }
              否则
              {
  std::cout << "他们有不同的身份。";
              }
  std::cout << " NormL2 距离："  << L2_score << ", 阈值："  << l2norm_similar_thresh << ". (较低值表示较高的相似度，最低 0.0)\n";
          }
  cout << "按任意键退出..." << endl;
          waitKey(0);
      }
      否则
      {
          int frameWidth, frameHeight;
          VideoCapture capture;
  std::string video = parser.get<string>("video");
          如果 (video.size() == 1 && isdigit(video[0]))
  capture.open(parser.get<int>("video"));
          否则
  capture.open(samples::findFileOrKeep(video)); // 保持 GStreamer 管道
          如果 (capture.isOpened())
          {
  frameWidth = int(capture.get(CAP_PROP_FRAME_WIDTH) * scale);
  frameHeight = int(capture.get(CAP_PROP_FRAME_HEIGHT) * scale);
  cout << "视频 " << video
  << ": 宽 =" << frameWidth
  << ", 高 =" << frameHeight
  << endl;
          }
          否则
          {
  cout << "无法初始化视频捕获："  << video << "\n";
              return 1;
          }
   
  detector->setInputSize(Size(frameWidth, frameHeight));
   
  cout << "按 'SPACE' 保存帧，按其他任意键退出..." << endl;
          int nFrame = 0;
          对于 (;;)
          {
              // 获取帧
              Mat frame;
              如果 (!capture.read(frame))
              {
  cerr << "无法获取帧！停止\n";
                  终止;
              }
   
              resize(frame, frame, Size(frameWidth, frameHeight));
   
              // 推理
              Mat faces;
  tm.start();
  detector->detect(frame, faces);
  tm.stop();
   
              Mat result = frame.clone();
              // 在输入图像上绘制结果
  visualize(result, nFrame, faces, tm.getFPS());
   
              // 可视化结果
              imshow("Live", result);
   
              int key = waitKey(1);
              bool saveFrame = save;
              if (key == ' ')
              {
  saveFrame = true;
  key = 0; // handled
              }
   
              if (saveFrame)
              {
  std::string frame_name = cv::format("frame_%05d.png", nFrame);
  std::string result_name = cv::format("result_%05d.jpg", nFrame);
  cout << "Saving '" << frame_name << "' and '" << result_name << "' ...\n";
                  imwrite(frame_name, frame);
                  imwrite(result_name, result);
              }
   
  ++nFrame;
   
              if (key > 0)
                  终止;
          }
  cout << "Processed " << nFrame << " frames" << endl;
      }
  cout << "Done." << endl;
      return 0;
  }

Python

• 可下载代码: 请点击 此处
• 代码一览

  import argparse
   
  import numpy as np
  import cv2 as cv
   
  def str2bool(v)
      if v.lower() in ['on', 'yes', 'true', 'y', 't']
          return True
      如果 v.lower() 在 ['off', 'no', 'false', 'n', 'f'] 中：
          返回 错误
      否则:
          提升 NotImplementedError
   
  parser = argparse.ArgumentParser()
  parser.add_argument('--image1', '-i1', type=str, help='输入图像 1 的路径。略过即可使用默认摄像头检测。')
  parser.add_argument('--image2', '-i2', type=str, help='输入图像 2 的路径。当给出图像 1 和图像 2 的参数时，程序会尝试在两张图像上找到面部并运行面部识别算法。')
  parser.add_argument('--video', '-v', type=str, help='输入视频的路径。')
  parser.add_argument('--scale', '-sc', type=float, default=1.0, help='用于调整输入视频帧大小的缩放因子。')
  parser.add_argument('--face_detection_model', '-fd', type=str, default='face_detection_yunet_2021dec.onnx', help='面部检测模型的路径。可在 https://github.com/opencv/opencv_zoo/tree/master/models/face_detection_yunet 下载该模型')
  parser.add_argument('--face_recognition_model', '-fr', type=str, default='face_recognition_sface_2021dec.onnx', help='面部识别模型的路径。可在 https://github.com/opencv/opencv_zoo/tree/master/models/face_recognition_sface 下载该模型')
  parser.add_argument('--score_threshold', type=float, default=0.9, help='过滤掉分数 < score_threshold 的面部。')
  parser.add_argument('--nms_threshold', type=float, default=0.3, help='抑制 iou >= nms_threshold 的包围框。')
  parser.add_argument('--top_k', type=int, default=5000, help='在 NMS 之前保留前 top_k 个包围框。')
  parser.add_argument('--save', '-s', type=str2bool, default=错误, help='设置为 true 可保存结果。使用摄像头时，此标记无效。')
  args = parser.parse_args()
   
  定义 visualize(input, faces, fps, thickness=2)
      如果 faces[1] 不是 空
          对于 idx, face 在 enumerate(faces[1])
  打印('面部 {}, 左上角坐标: ({:.0f}, {:.0f}), 框宽度: {:.0f}, 框高度 {:.0f}, 分数: {:.2f}'.format(idx, face[0], face[1], face[2], face[3], face[-1]))
   
  coords = face[:-1].astype(np.int32)
              cv.rectangle(input, (coords[0], coords[1]), (coords[0]+coords[2], coords[1]+coords[3]), (0, 255, 0), thickness)
              cv.circle(input, (coords[4], coords[5]), 2, (255, 0, 0), thickness)
              cv.circle(input, (coords[6], coords[7]), 2, (0, 0, 255), thickness)
              cv.circle(input, (coords[8], coords[9]), 2, (0, 255, 0), thickness)
              cv.circle(input, (coords[10], coords[11]), 2, (255, 0, 255), thickness)
              cv.circle(input, (coords[12], coords[13]), 2, (0, 255, 255), thickness)
      cv.putText(input, 'FPS: {:.2f}'.format(fps), (1, 16), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
   
  if __name__ == '__main__'
   
      
  detector = cv.FaceDetectorYN.create(
  args.face_detection_model,
          "",
          (320, 320),
  args.score_threshold,
  args.nms_threshold,
  args.top_k
      )
      
   
  tm = cv.TickMeter()
   
      # 如果输入的是图片
      if args.image1 is not None
  img1 = cv.imread(cv.samples.findFile(args.image1))
  img1Width = int(img1.shape[1]*args.scale)
  img1Height = int(img1.shape[0]*args.scale)
   
  img1 = cv.resize(img1, (img1Width, img1Height))
  tm.start()
   
          
  detector.setInputSize((img1Width, img1Height))
   
  faces1 = detector.detect(img1)
          
   
  tm.stop()
          assert faces1[1] is not None, '无法在 {} 中找到人脸'.format(args.image1)
   
          # 在输入图像中绘制结果
  visualize(img1, faces1, tm.getFPS())
   
          # 保存结果（如果 save 为 true）
          if args.save
  print('结果已保存到 result.jpg\n')
              cv.imwrite('result.jpg', img1)
   
          # 在新窗口中可视化结果
          cv.imshow("image1", img1)
   
          if args.image2 is not None
  img2 = cv.imread(cv.samples.findFile(args.image2))
   
  tm.reset()
  tm.start()
  detector.setInputSize((img2.shape[1], img2.shape[0]))
  faces2 = detector.detect(img2)
  tm.stop()
              断言 faces2[1] 为 非 None, “在 {} 中找不到面部”.format(args.image2)
  visualize(img2, faces2, tm.getFPS())
              cv.imshow("image2", img2)
   
              
  recognizer = cv.FaceRecognizerSF.create(
  args.face_recognition_model,"")
              
   
              
  face1_align = recognizer.alignCrop(img1, faces1[1][0])
  face2_align = recognizer.alignCrop(img2, faces2[1][0])
   
              # 提取特征
  face1_feature = recognizer.feature(face1_align)
  face2_feature = recognizer.feature(face2_align)
              
   
  cosine_similarity_threshold = 0.363
  l2_similarity_threshold = 1.128
   
              
  cosine_score = recognizer.match(face1_feature, face2_feature, cv.FaceRecognizerSF_FR_COSINE)
  l2_score = recognizer.match(face1_feature, face2_feature, cv.FaceRecognizerSF_FR_NORM_L2)
              
   
  msg = '不同的身份'
              如果 cosine_score >= cosine_similarity_threshold
  msg = '相同身份'
  print('他们有 {}。余弦相似度：{}，阈值：{}（值越高相似度越高，最大 1.0）。'.format(msg, cosine_score, cosine_similarity_threshold))
   
  msg = '不同的身份'
              如果 l2_score <= l2_similarity_threshold
  msg = '相同身份'
  print('他们有 {}。NormL2 距离：{}，阈值：{}（值越低相似度越高，最小 0.0）。'.format(msg, l2_score, l2_similarity_threshold))
          cv.waitKey(0)
      否则: # 省略输入以调用默认摄像头
          如果 args.video 非 None
  deviceId = args.video
          否则:
  deviceId = 0
  cap = cv.VideoCapture(deviceId)
  frameWidth = int(cap.get(cv.CAP_PROP_FRAME_WIDTH)*args.scale)
  frameHeight = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)*args.scale)
  detector.setInputSize([frameWidth, frameHeight])
   
          当 cv.waitKey(1) < 0
  hasFrame, frame = cap.read()
              如果 非 hasFrame
  print('未获取帧！')
                  终止
   
  frame = cv.resize(frame, (frameWidth, frameHeight))
   
              # 推断
  tm.start()
  faces = detector.detect(frame) # faces 是一个元组
  tm.stop()
   
              # 在输入图像中绘制结果
  visualize(frame, faces, tm.getFPS())
   
              # 可视化结果
              cv.imshow('实时', frame)
      cv.destroyAllWindows()

说明

C++

    // 初始化 FaceDetectorYN
    Ptr<FaceDetectorYN> 检测器 = FaceDetectorYN::创建(fd_modelPath, "", 尺寸(320, 320), scoreThreshold, nmsThreshold, topK);

        // 在推理前设置输入尺寸
检测器->设置输入尺寸(图像1.尺寸());
 
        矩阵 faces1;
检测器->检测(图像1, faces1);
        如果 (faces1.行 < 1)
        {
std::cerr << "无法在 "" 中找到一张人脸 << 输入1 << std::endl;
            return 1;
        }

Python

detector = cv.FaceDetectorYN.create(
args.face_detection_model,
        "",
        (320, 320),
args.score_threshold,
args.nms_threshold,
args.top_k
    )

        # 在推理前设置输入大小
detector.setInputSize((img1Width, img1Height))
 
faces1 = detector.detect(img1)

检测输出 faces 是一个类型为 CV_32F 的二维数组，其行是检测到的面部实例，列是面部的位置和 5 个面部标记。每一行中的格式如下

x1, y1, w, h, x_re, y_re, x_le, y_le, x_nt, y_nt, x_rcm, y_rcm, x_lcm, y_lcm

, 其中 x1, y1, w, h 是面部边界框的左上角坐标、宽度和高度，{x, y}_{re, le, nt, rcm, lcm} 分别表示右眼、左眼、鼻尖、嘴的右角和左角的坐标。

面部识别

面部检测之后，运行以下代码从面部图像中提取面部特征。

C++

            // 初始化 FaceRecognizerSF
            Ptr<FaceRecognizerSF> faceRecognizer = FaceRecognizerSF::create(fr_modelPath, "");

            // 通过检测到的人脸中的第一个脸部对人脸图像进行对齐和裁剪。
            Mat aligned_face1, aligned_face2;
faceRecognizer->alignCrop(image1, faces1.row(0), aligned_face1);
faceRecognizer->alignCrop(image2, faces2.row(0), aligned_face2);
 
            // 使用给定的对齐人脸运行特征提取
            Mat feature1, feature2;
faceRecognizer->feature(aligned_face1, feature1);
feature1 = feature1.clone();
faceRecognizer->feature(aligned_face2, feature2);
feature2 = feature2.clone();

Python

recognizer = cv.FaceRecognizerSF.create(
args.face_recognition_model,"")

            # 校准面部
face1_align = recognizer.alignCrop(img1, faces1[1][0])
face2_align = recognizer.alignCrop(img2, faces2[1][0])
 
            # 提取特征
face1_feature = recognizer.feature(face1_align)
face2_feature = recognizer.feature(face2_align)

获得两幅面部图像的面部特征 特征 1 和 特征 2 后，运行以下代码计算两张面部之间的身份差异。

C++

            double cos_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_COSINE);
            double L2_score = faceRecognizer->match(feature1, feature2, FaceRecognizerSF::DisType::FR_NORM_L2);

Python

cosine_score = recognizer.match(face1_feature, face2_feature, cv.FaceRecognizerSF_FR_COSINE)
l2_score = recognizer.match(face1_feature, face2_feature, cv.FaceRecognizerSF_FR_NORM_L2)

例如，如果余弦距离大于或等于 0.363，或范数 L2 距离小于或等于 1.128，则两张面部具有相同身份。

参考

• https://github.com/ShiqiYu/libfacedetection
• https://github.com/ShiqiYu/libfacedetection.train
• https://github.com/zhongyy/SFace

致谢

感谢 于仕琪教授 和 冯元涛 训练并提供了面部检测模型。

感谢 邓教授、钟博士生 和 王硕士生 训练并提供了面部识别模型。