%global _empty_manifest_terminate_build 0 Name: python-face-detection Version: 0.2.2 Release: 1 Summary: A simple and lightweight package for state of the art face detection with GPU support. License: apache-2.0 URL: https://github.com/hukkelas/DSFD-Pytorch-Inference Source0: https://mirrors.aliyun.com/pypi/web/packages/2f/dd/abf4ac463b376596b1e3e35d04c58f86a9b45c3c433448b4b5e0b3d5f467/face_detection-0.2.2.tar.gz BuildArch: noarch Requires: python3-torch Requires: python3-torchvision Requires: python3-numpy %description # State of the Art Face Detection in Pytorch with DSFD and RetinaFace This repository includes: - A High-Performance Pytorch Implementation of the paper "[DSFD: Dual Shot Face Detector" (CVPR 2019).](http://openaccess.thecvf.com/content_CVPR_2019/papers/Li_DSFD_Dual_Shot_Face_Detector_CVPR_2019_paper.pdf) adapted from the [original source code](https://github.com/TencentYoutuResearch/FaceDetection-DSFD). - Lightweight single-shot face detection from the paper [RetinaFace: Single-stage Dense Face Localisation in the Wild](https://arxiv.org/abs/1905.00641) adapted from https://github.com/biubug6/Pytorch_Retinaface. ![](example_det.jpg) **NOTE** This implementation can only be used for inference of a selection of models and all training scripts are removed. If you want to finetune any models, we recommend you to use the original source code. ## Install You can install this repository with pip (requires python>=3.6); ```bash pip install git+https://github.com/hukkelas/DSFD-Pytorch-Inference.git ``` You can also install with the `setup.py` ```bash python3 setup.py install ``` ## Getting started Run ``` python3 test.py ``` This will look for images in the `images/` folder, and save the results in the same folder with an ending `_out.jpg` ## Simple API To perform detection you can simple use the following lines: ```python import cv2 import face_detection print(face_detection.available_detectors) detector = face_detection.build_detector( "DSFDDetector", confidence_threshold=.5, nms_iou_threshold=.3) # BGR to RGB im = cv2.imread("path_to_im.jpg")[:, :, ::-1] detections = detector.detect(im) ``` This will return a tensor with shape `[N, 5]`, where N is number of faces and the five elements are `[xmin, ymin, xmax, ymax, detection_confidence]` ### Batched inference ```python import numpy as np import face_detection print(face_detection.available_detectors) detector = face_detection.build_detector( "DSFDDetector", confidence_threshold=.5, nms_iou_threshold=.3) # [batch size, height, width, 3] images_dummy = np.zeros((2, 512, 512, 3)) detections = detector.batched_detect(im) ``` ## Improvements ### Difference from DSFD For the original source code, see [here](https://github.com/TencentYoutuResearch/FaceDetection-DSFD). - Removal of all unnecessary files for training / loading VGG models. - Improve the inference time by about 30x (from ~6s to 0.2) with rough estimates using `time` (Measured on a V100-32GB GPU). The main improvements in inference time comes from: - Replacing non-maximum-suppression to a [highly optimized torchvision version](https://github.com/pytorch/vision/blob/19315e313511fead3597e23075552255d07fcb2a/torchvision/ops/boxes.py#L5) - Refactoring `init_priors`in the [SSD model](dsfd/face_ssd.py) to cache previous prior sizes (no need to generate this per forward pass). - Refactoring the forward pass in `Detect` in [`utils.py`](dsfd/utils.py) to perform confidence thresholding before non-maximum suppression - Minor changes in the forward pass to use pytorch 1.0 features ### Difference from RetinaFace For the original source code, see [here](https://github.com/biubug6/Pytorch_Retinaface). We've done the following improvements: - Remove gradient computation for inference (`torch.no_grad`). - Replacing non-maximum-suppression to a [highly optimized torchvision version](https://github.com/pytorch/vision/blob/19315e313511fead3597e23075552255d07fcb2a/torchvision/ops/boxes.py#L5) ## Inference time This is **very roughly** estimated on a 1024x687 image. The reported time is the average over 1000 forward passes on a single image. (With no cudnn benchmarking and no fp16 computation). | | DSFDDetector | RetinaNetResNet50 | RetinaNetMobileNetV1 | | -|-|-|-| | CPU (Intel 2.2GHz i7) *| 17,496 ms (0.06 FPS) | 2970ms (0.33 FPS) | 270ms (3.7 FPS) | | NVIDIA V100-32GB | 100ms (10 FPS) | | | | NVIDIA GTX 1060 6GB | 341ms (2.9 FPS) | 76.6ms (13 FPS) | 48.2ms (20.7 FPS) | | NVIDIA T4 16 GB | 482 ms (2.1 FPS) | 181ms (5.5 FPS) | 178ms (5.6 FPS) | *Done over 100 forward passes on a MacOS Mid 2014, 15-Inch. ## Changelog - September 1st 2020: added support for fp16/mixed precision inference - September 24th 2020: added support for TensorRT. ## TensorRT Inference (Experimental) You can run RetinaFace ResNet-50 with TensorRT: ```python from face_detection.retinaface.tensorrt_wrap import TensorRTRetinaFace inference_imshape =(480, 640) # Input to the CNN input_imshape = (1080, 1920) # Input for original video source detector = TensorRTRetinaFace(input_imshape, imshape) boxes, landmarks, scores = detector.infer(image) ``` ## Citation If you find this code useful, remember to cite the original authors: ``` @inproceedings{li2018dsfd, title={DSFD: Dual Shot Face Detector}, author={Li, Jian and Wang, Yabiao and Wang, Changan and Tai, Ying and Qian, Jianjun and Yang, Jian and Wang, Chengjie and Li, Jilin and Huang, Feiyue}, booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, year={2019} } @inproceedings{deng2019retinaface, title={RetinaFace: Single-stage Dense Face Localisation in the Wild}, author={Deng, Jiankang and Guo, Jia and Yuxiang, Zhou and Jinke Yu and Irene Kotsia and Zafeiriou, Stefanos}, booktitle={arxiv}, year={2019} ``` %package -n python3-face-detection Summary: A simple and lightweight package for state of the art face detection with GPU support. Provides: python-face-detection BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-face-detection # State of the Art Face Detection in Pytorch with DSFD and RetinaFace This repository includes: - A High-Performance Pytorch Implementation of the paper "[DSFD: Dual Shot Face Detector" (CVPR 2019).](http://openaccess.thecvf.com/content_CVPR_2019/papers/Li_DSFD_Dual_Shot_Face_Detector_CVPR_2019_paper.pdf) adapted from the [original source code](https://github.com/TencentYoutuResearch/FaceDetection-DSFD). - Lightweight single-shot face detection from the paper [RetinaFace: Single-stage Dense Face Localisation in the Wild](https://arxiv.org/abs/1905.00641) adapted from https://github.com/biubug6/Pytorch_Retinaface. ![](example_det.jpg) **NOTE** This implementation can only be used for inference of a selection of models and all training scripts are removed. If you want to finetune any models, we recommend you to use the original source code. ## Install You can install this repository with pip (requires python>=3.6); ```bash pip install git+https://github.com/hukkelas/DSFD-Pytorch-Inference.git ``` You can also install with the `setup.py` ```bash python3 setup.py install ``` ## Getting started Run ``` python3 test.py ``` This will look for images in the `images/` folder, and save the results in the same folder with an ending `_out.jpg` ## Simple API To perform detection you can simple use the following lines: ```python import cv2 import face_detection print(face_detection.available_detectors) detector = face_detection.build_detector( "DSFDDetector", confidence_threshold=.5, nms_iou_threshold=.3) # BGR to RGB im = cv2.imread("path_to_im.jpg")[:, :, ::-1] detections = detector.detect(im) ``` This will return a tensor with shape `[N, 5]`, where N is number of faces and the five elements are `[xmin, ymin, xmax, ymax, detection_confidence]` ### Batched inference ```python import numpy as np import face_detection print(face_detection.available_detectors) detector = face_detection.build_detector( "DSFDDetector", confidence_threshold=.5, nms_iou_threshold=.3) # [batch size, height, width, 3] images_dummy = np.zeros((2, 512, 512, 3)) detections = detector.batched_detect(im) ``` ## Improvements ### Difference from DSFD For the original source code, see [here](https://github.com/TencentYoutuResearch/FaceDetection-DSFD). - Removal of all unnecessary files for training / loading VGG models. - Improve the inference time by about 30x (from ~6s to 0.2) with rough estimates using `time` (Measured on a V100-32GB GPU). The main improvements in inference time comes from: - Replacing non-maximum-suppression to a [highly optimized torchvision version](https://github.com/pytorch/vision/blob/19315e313511fead3597e23075552255d07fcb2a/torchvision/ops/boxes.py#L5) - Refactoring `init_priors`in the [SSD model](dsfd/face_ssd.py) to cache previous prior sizes (no need to generate this per forward pass). - Refactoring the forward pass in `Detect` in [`utils.py`](dsfd/utils.py) to perform confidence thresholding before non-maximum suppression - Minor changes in the forward pass to use pytorch 1.0 features ### Difference from RetinaFace For the original source code, see [here](https://github.com/biubug6/Pytorch_Retinaface). We've done the following improvements: - Remove gradient computation for inference (`torch.no_grad`). - Replacing non-maximum-suppression to a [highly optimized torchvision version](https://github.com/pytorch/vision/blob/19315e313511fead3597e23075552255d07fcb2a/torchvision/ops/boxes.py#L5) ## Inference time This is **very roughly** estimated on a 1024x687 image. The reported time is the average over 1000 forward passes on a single image. (With no cudnn benchmarking and no fp16 computation). | | DSFDDetector | RetinaNetResNet50 | RetinaNetMobileNetV1 | | -|-|-|-| | CPU (Intel 2.2GHz i7) *| 17,496 ms (0.06 FPS) | 2970ms (0.33 FPS) | 270ms (3.7 FPS) | | NVIDIA V100-32GB | 100ms (10 FPS) | | | | NVIDIA GTX 1060 6GB | 341ms (2.9 FPS) | 76.6ms (13 FPS) | 48.2ms (20.7 FPS) | | NVIDIA T4 16 GB | 482 ms (2.1 FPS) | 181ms (5.5 FPS) | 178ms (5.6 FPS) | *Done over 100 forward passes on a MacOS Mid 2014, 15-Inch. ## Changelog - September 1st 2020: added support for fp16/mixed precision inference - September 24th 2020: added support for TensorRT. ## TensorRT Inference (Experimental) You can run RetinaFace ResNet-50 with TensorRT: ```python from face_detection.retinaface.tensorrt_wrap import TensorRTRetinaFace inference_imshape =(480, 640) # Input to the CNN input_imshape = (1080, 1920) # Input for original video source detector = TensorRTRetinaFace(input_imshape, imshape) boxes, landmarks, scores = detector.infer(image) ``` ## Citation If you find this code useful, remember to cite the original authors: ``` @inproceedings{li2018dsfd, title={DSFD: Dual Shot Face Detector}, author={Li, Jian and Wang, Yabiao and Wang, Changan and Tai, Ying and Qian, Jianjun and Yang, Jian and Wang, Chengjie and Li, Jilin and Huang, Feiyue}, booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, year={2019} } @inproceedings{deng2019retinaface, title={RetinaFace: Single-stage Dense Face Localisation in the Wild}, author={Deng, Jiankang and Guo, Jia and Yuxiang, Zhou and Jinke Yu and Irene Kotsia and Zafeiriou, Stefanos}, booktitle={arxiv}, year={2019} ``` %package help Summary: Development documents and examples for face-detection Provides: python3-face-detection-doc %description help # State of the Art Face Detection in Pytorch with DSFD and RetinaFace This repository includes: - A High-Performance Pytorch Implementation of the paper "[DSFD: Dual Shot Face Detector" (CVPR 2019).](http://openaccess.thecvf.com/content_CVPR_2019/papers/Li_DSFD_Dual_Shot_Face_Detector_CVPR_2019_paper.pdf) adapted from the [original source code](https://github.com/TencentYoutuResearch/FaceDetection-DSFD). - Lightweight single-shot face detection from the paper [RetinaFace: Single-stage Dense Face Localisation in the Wild](https://arxiv.org/abs/1905.00641) adapted from https://github.com/biubug6/Pytorch_Retinaface. ![](example_det.jpg) **NOTE** This implementation can only be used for inference of a selection of models and all training scripts are removed. If you want to finetune any models, we recommend you to use the original source code. ## Install You can install this repository with pip (requires python>=3.6); ```bash pip install git+https://github.com/hukkelas/DSFD-Pytorch-Inference.git ``` You can also install with the `setup.py` ```bash python3 setup.py install ``` ## Getting started Run ``` python3 test.py ``` This will look for images in the `images/` folder, and save the results in the same folder with an ending `_out.jpg` ## Simple API To perform detection you can simple use the following lines: ```python import cv2 import face_detection print(face_detection.available_detectors) detector = face_detection.build_detector( "DSFDDetector", confidence_threshold=.5, nms_iou_threshold=.3) # BGR to RGB im = cv2.imread("path_to_im.jpg")[:, :, ::-1] detections = detector.detect(im) ``` This will return a tensor with shape `[N, 5]`, where N is number of faces and the five elements are `[xmin, ymin, xmax, ymax, detection_confidence]` ### Batched inference ```python import numpy as np import face_detection print(face_detection.available_detectors) detector = face_detection.build_detector( "DSFDDetector", confidence_threshold=.5, nms_iou_threshold=.3) # [batch size, height, width, 3] images_dummy = np.zeros((2, 512, 512, 3)) detections = detector.batched_detect(im) ``` ## Improvements ### Difference from DSFD For the original source code, see [here](https://github.com/TencentYoutuResearch/FaceDetection-DSFD). - Removal of all unnecessary files for training / loading VGG models. - Improve the inference time by about 30x (from ~6s to 0.2) with rough estimates using `time` (Measured on a V100-32GB GPU). The main improvements in inference time comes from: - Replacing non-maximum-suppression to a [highly optimized torchvision version](https://github.com/pytorch/vision/blob/19315e313511fead3597e23075552255d07fcb2a/torchvision/ops/boxes.py#L5) - Refactoring `init_priors`in the [SSD model](dsfd/face_ssd.py) to cache previous prior sizes (no need to generate this per forward pass). - Refactoring the forward pass in `Detect` in [`utils.py`](dsfd/utils.py) to perform confidence thresholding before non-maximum suppression - Minor changes in the forward pass to use pytorch 1.0 features ### Difference from RetinaFace For the original source code, see [here](https://github.com/biubug6/Pytorch_Retinaface). We've done the following improvements: - Remove gradient computation for inference (`torch.no_grad`). - Replacing non-maximum-suppression to a [highly optimized torchvision version](https://github.com/pytorch/vision/blob/19315e313511fead3597e23075552255d07fcb2a/torchvision/ops/boxes.py#L5) ## Inference time This is **very roughly** estimated on a 1024x687 image. The reported time is the average over 1000 forward passes on a single image. (With no cudnn benchmarking and no fp16 computation). | | DSFDDetector | RetinaNetResNet50 | RetinaNetMobileNetV1 | | -|-|-|-| | CPU (Intel 2.2GHz i7) *| 17,496 ms (0.06 FPS) | 2970ms (0.33 FPS) | 270ms (3.7 FPS) | | NVIDIA V100-32GB | 100ms (10 FPS) | | | | NVIDIA GTX 1060 6GB | 341ms (2.9 FPS) | 76.6ms (13 FPS) | 48.2ms (20.7 FPS) | | NVIDIA T4 16 GB | 482 ms (2.1 FPS) | 181ms (5.5 FPS) | 178ms (5.6 FPS) | *Done over 100 forward passes on a MacOS Mid 2014, 15-Inch. ## Changelog - September 1st 2020: added support for fp16/mixed precision inference - September 24th 2020: added support for TensorRT. ## TensorRT Inference (Experimental) You can run RetinaFace ResNet-50 with TensorRT: ```python from face_detection.retinaface.tensorrt_wrap import TensorRTRetinaFace inference_imshape =(480, 640) # Input to the CNN input_imshape = (1080, 1920) # Input for original video source detector = TensorRTRetinaFace(input_imshape, imshape) boxes, landmarks, scores = detector.infer(image) ``` ## Citation If you find this code useful, remember to cite the original authors: ``` @inproceedings{li2018dsfd, title={DSFD: Dual Shot Face Detector}, author={Li, Jian and Wang, Yabiao and Wang, Changan and Tai, Ying and Qian, Jianjun and Yang, Jian and Wang, Chengjie and Li, Jilin and Huang, Feiyue}, booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition}, year={2019} } @inproceedings{deng2019retinaface, title={RetinaFace: Single-stage Dense Face Localisation in the Wild}, author={Deng, Jiankang and Guo, Jia and Yuxiang, Zhou and Jinke Yu and Irene Kotsia and Zafeiriou, Stefanos}, booktitle={arxiv}, year={2019} ``` %prep %autosetup -n face_detection-0.2.2 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-face-detection -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Fri Jun 09 2023 Python_Bot - 0.2.2-1 - Package Spec generated