automatic import of python-face-detection

3 files changed, 488 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..dd63bb8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/face_detection-0.2.2.tar.gz
diff --git a/python-face-detection.spec b/python-face-detection.spec
new file mode 100644
index 0000000..ddf8e9e
--- /dev/null
+++ b/python-face-detection.spec
@@ -0,0 +1,486 @@
+%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.nju.edu.cn/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
+* Wed May 31 2023 Python_Bot <Python_Bot@openeuler.org> - 0.2.2-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..0d75030
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+1490398b20a627965fb098d5249a7ab5  face_detection-0.2.2.tar.gz