Duplicate from opencv/face_detection_yunet

Co-authored-by: Abhishek Gola <abhishek-gola@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,26 @@
+
+# Caffe
+*.caffemodel filter=lfs diff=lfs merge=lfs -text
+
+# Tensorflow
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pbtxt filter=lfs diff=lfs merge=lfs -text
+
+# Torch
+*.t7 filter=lfs diff=lfs merge=lfs -text
+*.net filter=lfs diff=lfs merge=lfs -text
+
+# Darknet
+*.weights filter=lfs diff=lfs merge=lfs -text
+
+# ONNX
+*.onnx filter=lfs diff=lfs merge=lfs -text
+
+# NPY
+*.npy filter=lfs diff=lfs merge=lfs -text
+
+# Images
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+*.pyc
+**/__pycache__
+**/__pycache__/**
+
+.vscode
+
+build/
+**/build
+**/build/**

CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.24.0)
+project(opencv_zoo_face_detection_yunet)
+
+set(OPENCV_VERSION "4.10.0")
+set(OPENCV_INSTALLATION_PATH "" CACHE PATH "Where to look for OpenCV installation")
+
+# Find OpenCV
+find_package(OpenCV ${OPENCV_VERSION} REQUIRED HINTS ${OPENCV_INSTALLATION_PATH})
+
+add_executable(demo demo.cpp)
+target_link_libraries(demo ${OpenCV_LIBS})

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Shiqi Yu <shiqi.yu@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,90 @@
+# YuNet
+
+YuNet is a light-weight, fast and accurate face detection model, which achieves 0.834(AP_easy), 0.824(AP_medium), 0.708(AP_hard) on the WIDER Face validation set.
+
+Notes:
+
+- Model source: [here](https://github.com/ShiqiYu/libfacedetection.train/blob/a61a428929148171b488f024b5d6774f93cdbc13/tasks/task1/onnx/yunet.onnx).
+- This model can detect **faces of pixels between around 10x10 to 300x300** due to the training scheme.
+- For details on training this model, please visit https://github.com/ShiqiYu/libfacedetection.train.
+- This ONNX model has fixed input shape, but OpenCV DNN infers on the exact shape of input image. See https://github.com/opencv/opencv_zoo/issues/44 for more information.
+- `face_detection_yunet_2023mar_int8bq.onnx` represents the block-quantized version in int8 precision and is generated using [block_quantize.py](../../tools/quantize/block_quantize.py) with `block_size=64`.
+- Paper source: [Yunet: A tiny millisecond-level face detector](https://link.springer.com/article/10.1007/s11633-023-1423-y).
+
+Results of accuracy evaluation with [tools/eval](../../tools/eval).
+
+| Models      | Easy AP | Medium AP | Hard AP |
+| ----------- | ------- | --------- | ------- |
+| YuNet       | 0.8844  | 0.8656    | 0.7503  |
+| YuNet block | 0.8845  | 0.8652    | 0.7504  |
+| YuNet quant | 0.8810  | 0.8629    | 0.7503  |
+
+
+\*: 'quant' stands for 'quantized'.
+\*\*: 'block' stands for 'blockwise quantized'.
+
+
+## Demo
+
+### Python
+
+Run the following command to try the demo:
+
+```shell
+# detect on camera input
+python demo.py
+# detect on an image
+python demo.py --input /path/to/image -v
+
+# get help regarding various parameters
+python demo.py --help
+```
+
+### C++
+
+Install latest OpenCV and CMake >= 3.24.0 to get started with:
+
+```shell
+# A typical and default installation path of OpenCV is /usr/local
+cmake -B build -D OPENCV_INSTALLATION_PATH=/path/to/opencv/installation .
+cmake --build build
+
+# detect on camera input
+./build/demo
+# detect on an image
+./build/demo -i=/path/to/image -v
+# get help messages
+./build/demo -h
+```
+
+### Example outputs
+
+![webcam demo](./example_outputs/yunet_demo.gif)
+
+![largest selfie](./example_outputs/largest_selfie.jpg)
+
+## License
+
+All files in this directory are licensed under [MIT License](./LICENSE).
+
+## Reference
+
+- https://github.com/ShiqiYu/libfacedetection
+- https://github.com/ShiqiYu/libfacedetection.train
+
+## Citation
+
+If you use `YuNet` in your work, please use the following BibTeX entries:
+
+```
+@article{wu2023yunet,
+  title={Yunet: A tiny millisecond-level face detector},
+  author={Wu, Wei and Peng, Hanyang and Yu, Shiqi},
+  journal={Machine Intelligence Research},
+  volume={20},
+  number={5},
+  pages={656--665},
+  year={2023},
+  publisher={Springer}
+}
+```

demo.cpp

@@ -0,0 +1,213 @@
+#include "opencv2/opencv.hpp"
+
+#include <map>
+#include <vector>
+#include <string>
+#include <iostream>
+
+const std::map<std::string, int> str2backend{
+    {"opencv", cv::dnn::DNN_BACKEND_OPENCV}, {"cuda", cv::dnn::DNN_BACKEND_CUDA},
+    {"timvx",  cv::dnn::DNN_BACKEND_TIMVX},  {"cann", cv::dnn::DNN_BACKEND_CANN}
+};
+const std::map<std::string, int> str2target{
+    {"cpu", cv::dnn::DNN_TARGET_CPU}, {"cuda", cv::dnn::DNN_TARGET_CUDA},
+    {"npu", cv::dnn::DNN_TARGET_NPU}, {"cuda_fp16", cv::dnn::DNN_TARGET_CUDA_FP16}
+};
+
+class YuNet
+{
+public:
+    YuNet(const std::string& model_path,
+          const cv::Size& input_size = cv::Size(320, 320),
+          float conf_threshold = 0.6f,
+          float nms_threshold = 0.3f,
+          int top_k = 5000,
+          int backend_id = 0,
+          int target_id = 0)
+        : model_path_(model_path), input_size_(input_size),
+          conf_threshold_(conf_threshold), nms_threshold_(nms_threshold),
+          top_k_(top_k), backend_id_(backend_id), target_id_(target_id)
+    {
+        model = cv::FaceDetectorYN::create(model_path_, "", input_size_, conf_threshold_, nms_threshold_, top_k_, backend_id_, target_id_);
+    }
+
+    /* Overwrite the input size when creating the model. Size format: [Width, Height].
+    */
+    void setInputSize(const cv::Size& input_size)
+    {
+        input_size_ = input_size;
+        model->setInputSize(input_size_);
+    }
+
+    cv::Mat infer(const cv::Mat image)
+    {
+        cv::Mat res;
+        model->detect(image, res);
+        return res;
+    }
+
+private:
+    cv::Ptr<cv::FaceDetectorYN> model;
+
+    std::string model_path_;
+    cv::Size input_size_;
+    float conf_threshold_;
+    float nms_threshold_;
+    int top_k_;
+    int backend_id_;
+    int target_id_;
+};
+
+cv::Mat visualize(const cv::Mat& image, const cv::Mat& faces, float fps = -1.f)
+{
+    static cv::Scalar box_color{0, 255, 0};
+    static std::vector<cv::Scalar> landmark_color{
+        cv::Scalar(255,   0,   0), // right eye
+        cv::Scalar(  0,   0, 255), // left eye
+        cv::Scalar(  0, 255,   0), // nose tip
+        cv::Scalar(255,   0, 255), // right mouth corner
+        cv::Scalar(  0, 255, 255)  // left mouth corner
+    };
+    static cv::Scalar text_color{0, 255, 0};
+
+    auto output_image = image.clone();
+
+    if (fps >= 0)
+    {
+        cv::putText(output_image, cv::format("FPS: %.2f", fps), cv::Point(0, 15), cv::FONT_HERSHEY_SIMPLEX, 0.5, text_color, 2);
+    }
+
+    for (int i = 0; i < faces.rows; ++i)
+    {
+        // Draw bounding boxes
+        int x1 = static_cast<int>(faces.at<float>(i, 0));
+        int y1 = static_cast<int>(faces.at<float>(i, 1));
+        int w = static_cast<int>(faces.at<float>(i, 2));
+        int h = static_cast<int>(faces.at<float>(i, 3));
+        cv::rectangle(output_image, cv::Rect(x1, y1, w, h), box_color, 2);
+
+        // Confidence as text
+        float conf = faces.at<float>(i, 14);
+        cv::putText(output_image, cv::format("%.4f", conf), cv::Point(x1, y1+12), cv::FONT_HERSHEY_DUPLEX, 0.5, text_color);
+
+        // Draw landmarks
+        for (int j = 0; j < landmark_color.size(); ++j)
+        {
+            int x = static_cast<int>(faces.at<float>(i, 2*j+4)), y = static_cast<int>(faces.at<float>(i, 2*j+5));
+            cv::circle(output_image, cv::Point(x, y), 2, landmark_color[j], 2);
+        }
+    }
+    return output_image;
+}
+
+int main(int argc, char** argv)
+{
+    cv::CommandLineParser parser(argc, argv,
+        "{help  h           |                                   | Print this message}"
+        "{input i           |                                   | Set input to a certain image, omit if using camera}"
+        "{model m           | face_detection_yunet_2023mar.onnx  | Set path to the model}"
+        "{backend b         | opencv                            | Set DNN backend}"
+        "{target t          | cpu                               | Set DNN target}"
+        "{save s            | false                             | Whether to save result image or not}"
+        "{vis v             | false                             | Whether to visualize result image or not}"
+        /* model params below*/
+        "{conf_threshold    | 0.9                               | Set the minimum confidence for the model to identify a face. Filter out faces of conf < conf_threshold}"
+        "{nms_threshold     | 0.3                               | Set the threshold to suppress overlapped boxes. Suppress boxes if IoU(box1, box2) >= nms_threshold, the one of higher score is kept.}"
+        "{top_k             | 5000                              | Keep top_k bounding boxes before NMS. Set a lower value may help speed up postprocessing.}"
+    );
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    std::string input_path = parser.get<std::string>("input");
+    std::string model_path = parser.get<std::string>("model");
+    std::string backend = parser.get<std::string>("backend");
+    std::string target = parser.get<std::string>("target");
+    bool save_flag = parser.get<bool>("save");
+    bool vis_flag = parser.get<bool>("vis");
+
+    // model params
+    float conf_threshold = parser.get<float>("conf_threshold");
+    float nms_threshold = parser.get<float>("nms_threshold");
+    int top_k = parser.get<int>("top_k");
+    const int backend_id = str2backend.at(backend);
+    const int target_id = str2target.at(target);
+
+    // Instantiate YuNet
+    YuNet model(model_path, cv::Size(320, 320), conf_threshold, nms_threshold, top_k, backend_id, target_id);
+
+    // If input is an image
+    if (!input_path.empty())
+    {
+        auto image = cv::imread(input_path);
+
+        // Inference
+        model.setInputSize(image.size());
+        auto faces = model.infer(image);
+
+        // Print faces
+        std::cout << cv::format("%d faces detected:\n", faces.rows);
+        for (int i = 0; i < faces.rows; ++i)
+        {
+            int x1 = static_cast<int>(faces.at<float>(i, 0));
+            int y1 = static_cast<int>(faces.at<float>(i, 1));
+            int w = static_cast<int>(faces.at<float>(i, 2));
+            int h = static_cast<int>(faces.at<float>(i, 3));
+            float conf = faces.at<float>(i, 14);
+            std::cout << cv::format("%d: x1=%d, y1=%d, w=%d, h=%d, conf=%.4f\n", i, x1, y1, w, h, conf);
+        }
+
+        // Draw reults on the input image
+        if (save_flag || vis_flag)
+        {
+            auto res_image = visualize(image, faces);
+            if (save_flag)
+            {
+                std::cout << "Results are saved to result.jpg\n";
+                cv::imwrite("result.jpg", res_image);
+            }
+            if (vis_flag)
+            {
+                cv::namedWindow(input_path, cv::WINDOW_AUTOSIZE);
+                cv::imshow(input_path, res_image);
+                cv::waitKey(0);
+            }
+        }
+    }
+    else // Call default camera
+    {
+        int device_id = 0;
+        auto cap = cv::VideoCapture(device_id);
+        int w = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_WIDTH));
+        int h = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_HEIGHT));
+        model.setInputSize(cv::Size(w, h));
+
+        auto tick_meter = cv::TickMeter();
+        cv::Mat frame;
+        while (cv::waitKey(1) < 0)
+        {
+            bool has_frame = cap.read(frame);
+            if (!has_frame)
+            {
+                std::cout << "No frames grabbed! Exiting ...\n";
+                break;
+            }
+
+            // Inference
+            tick_meter.start();
+            cv::Mat faces = model.infer(frame);
+            tick_meter.stop();
+
+            // Draw results on the input image
+            auto res_image = visualize(frame, faces, (float)tick_meter.getFPS());
+            // Visualize in a new window
+            cv::imshow("YuNet Demo", res_image);
+
+            tick_meter.reset();
+        }
+    }
+
+    return 0;
+}

demo.py

@@ -0,0 +1,146 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+import argparse
+
+import numpy as np
+import cv2 as cv
+
+# Check OpenCV version
+opencv_python_version = lambda str_version: tuple(map(int, (str_version.split("."))))
+assert opencv_python_version(cv.__version__) >= opencv_python_version("4.10.0"), \
+       "Please install latest opencv-python for benchmark: python3 -m pip install --upgrade opencv-python"
+
+from yunet import YuNet
+
+# Valid combinations of backends and targets
+backend_target_pairs = [
+    [cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_TARGET_CPU],
+    [cv.dnn.DNN_BACKEND_CUDA,   cv.dnn.DNN_TARGET_CUDA],
+    [cv.dnn.DNN_BACKEND_CUDA,   cv.dnn.DNN_TARGET_CUDA_FP16],
+    [cv.dnn.DNN_BACKEND_TIMVX,  cv.dnn.DNN_TARGET_NPU],
+    [cv.dnn.DNN_BACKEND_CANN,   cv.dnn.DNN_TARGET_NPU]
+]
+
+parser = argparse.ArgumentParser(description='YuNet: A Fast and Accurate CNN-based Face Detector (https://github.com/ShiqiYu/libfacedetection).')
+parser.add_argument('--input', '-i', type=str,
+                    help='Usage: Set input to a certain image, omit if using camera.')
+parser.add_argument('--model', '-m', type=str, default='face_detection_yunet_2023mar.onnx',
+                    help="Usage: Set model type, defaults to 'face_detection_yunet_2023mar.onnx'.")
+parser.add_argument('--backend_target', '-bt', type=int, default=0,
+                    help='''Choose one of the backend-target pair to run this demo:
+                        {:d}: (default) OpenCV implementation + CPU,
+                        {:d}: CUDA + GPU (CUDA),
+                        {:d}: CUDA + GPU (CUDA FP16),
+                        {:d}: TIM-VX + NPU,
+                        {:d}: CANN + NPU
+                    '''.format(*[x for x in range(len(backend_target_pairs))]))
+parser.add_argument('--conf_threshold', type=float, default=0.9,
+                    help='Usage: Set the minimum needed confidence for the model to identify a face, defauts to 0.9. Smaller values may result in faster detection, but will limit accuracy. Filter out faces of confidence < conf_threshold.')
+parser.add_argument('--nms_threshold', type=float, default=0.3,
+                    help='Usage: Suppress bounding boxes of iou >= nms_threshold. Default = 0.3.')
+parser.add_argument('--top_k', type=int, default=5000,
+                    help='Usage: Keep top_k bounding boxes before NMS.')
+parser.add_argument('--save', '-s', action='store_true',
+                    help='Usage: Specify to save file with results (i.e. bounding box, confidence level). Invalid in case of camera input.')
+parser.add_argument('--vis', '-v', action='store_true',
+                    help='Usage: Specify to open a new window to show results. Invalid in case of camera input.')
+args = parser.parse_args()
+
+def visualize(image, results, box_color=(0, 255, 0), text_color=(0, 0, 255), fps=None):
+    output = image.copy()
+    landmark_color = [
+        (255,   0,   0), # right eye
+        (  0,   0, 255), # left eye
+        (  0, 255,   0), # nose tip
+        (255,   0, 255), # right mouth corner
+        (  0, 255, 255)  # left mouth corner
+    ]
+
+    if fps is not None:
+        cv.putText(output, 'FPS: {:.2f}'.format(fps), (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, text_color)
+
+    for det in results:
+        bbox = det[0:4].astype(np.int32)
+        cv.rectangle(output, (bbox[0], bbox[1]), (bbox[0]+bbox[2], bbox[1]+bbox[3]), box_color, 2)
+
+        conf = det[-1]
+        cv.putText(output, '{:.4f}'.format(conf), (bbox[0], bbox[1]+12), cv.FONT_HERSHEY_DUPLEX, 0.5, text_color)
+
+        landmarks = det[4:14].astype(np.int32).reshape((5,2))
+        for idx, landmark in enumerate(landmarks):
+            cv.circle(output, landmark, 2, landmark_color[idx], 2)
+
+    return output
+
+if __name__ == '__main__':
+    backend_id = backend_target_pairs[args.backend_target][0]
+    target_id = backend_target_pairs[args.backend_target][1]
+
+    # Instantiate YuNet
+    model = YuNet(modelPath=args.model,
+                  inputSize=[320, 320],
+                  confThreshold=args.conf_threshold,
+                  nmsThreshold=args.nms_threshold,
+                  topK=args.top_k,
+                  backendId=backend_id,
+                  targetId=target_id)
+
+    # If input is an image
+    if args.input is not None:
+        image = cv.imread(args.input)
+        h, w, _ = image.shape
+
+        # Inference
+        model.setInputSize([w, h])
+        results = model.infer(image)
+
+        # Print results
+        print('{} faces detected.'.format(results.shape[0]))
+        for idx, det in enumerate(results):
+            print('{}: {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f} {:.0f}'.format(
+                idx, *det[:-1])
+            )
+
+        # Draw results on the input image
+        image = visualize(image, results)
+
+        # Save results if save is true
+        if args.save:
+            print('Resutls saved to result.jpg\n')
+            cv.imwrite('result.jpg', image)
+
+        # Visualize results in a new window
+        if args.vis:
+            cv.namedWindow(args.input, cv.WINDOW_AUTOSIZE)
+            cv.imshow(args.input, image)
+            cv.waitKey(0)
+    else: # Omit input to call default camera
+        deviceId = 0
+        cap = cv.VideoCapture(deviceId)
+        w = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+        h = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+        model.setInputSize([w, h])
+
+        tm = cv.TickMeter()
+        while cv.waitKey(1) < 0:
+            hasFrame, frame = cap.read()
+            if not hasFrame:
+                print('No frames grabbed!')
+                break
+
+            # Inference
+            tm.start()
+            results = model.infer(frame) # results is a tuple
+            tm.stop()
+
+            # Draw results on the input image
+            frame = visualize(frame, results, fps=tm.getFPS())
+
+            # Visualize results in a new Window
+            cv.imshow('YuNet Demo', frame)
+
+            tm.reset()

face_detection_yunet_2023mar.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f2383e4dd3cfbb4553ea8718107fc0423210dc964f9f4280604804ed2552fa4
+size 232589

face_detection_yunet_2023mar_int8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:321aa5a6afabf7ecc46a3d06bfab2b579dc96eb5c3be7edd365fa04502ad9294
+size 100416

face_detection_yunet_2023mar_int8bq.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49f000ec501fef24739071fc7e68267d32209045b6822c0c72dce1da25726f10
+size 122489

yunet.py

@@ -0,0 +1,55 @@
+# This file is part of OpenCV Zoo project.
+# It is subject to the license terms in the LICENSE file found in the same directory.
+#
+# Copyright (C) 2021, Shenzhen Institute of Artificial Intelligence and Robotics for Society, all rights reserved.
+# Third party copyrights are property of their respective owners.
+
+from itertools import product
+
+import numpy as np
+import cv2 as cv
+
+class YuNet:
+    def __init__(self, modelPath, inputSize=[320, 320], confThreshold=0.6, nmsThreshold=0.3, topK=5000, backendId=0, targetId=0):
+        self._modelPath = modelPath
+        self._inputSize = tuple(inputSize) # [w, h]
+        self._confThreshold = confThreshold
+        self._nmsThreshold = nmsThreshold
+        self._topK = topK
+        self._backendId = backendId
+        self._targetId = targetId
+
+        self._model = cv.FaceDetectorYN.create(
+            model=self._modelPath,
+            config="",
+            input_size=self._inputSize,
+            score_threshold=self._confThreshold,
+            nms_threshold=self._nmsThreshold,
+            top_k=self._topK,
+            backend_id=self._backendId,
+            target_id=self._targetId)
+
+    @property
+    def name(self):
+        return self.__class__.__name__
+
+    def setBackendAndTarget(self, backendId, targetId):
+        self._backendId = backendId
+        self._targetId = targetId
+        self._model = cv.FaceDetectorYN.create(
+            model=self._modelPath,
+            config="",
+            input_size=self._inputSize,
+            score_threshold=self._confThreshold,
+            nms_threshold=self._nmsThreshold,
+            top_k=self._topK,
+            backend_id=self._backendId,
+            target_id=self._targetId)
+
+    def setInputSize(self, input_size):
+        self._model.setInputSize(tuple(input_size))
+
+    def infer(self, image):
+        # Forward
+        faces = self._model.detect(image)
+        return np.empty(shape=(0, 5)) if faces[1] is None else faces[1]