Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
大约 1 年 前同步成功

通知 282
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 13cc2d57 编写于 作者: C chenjian 提交者： GitHub
浏览文件
操作

Update face detection modules docs according to the template (#1598)

上级 8b6b029f
隐藏空白更改
内联 并排
Showing with 1136 addition and 731 deletion
modules/image/face_detection/pyramidbox_face_detection/README.md
浏览文件 @ 13cc2d57
```shell
$ hub install pyramidbox_face_detection==1.1.0
```
# pyramidbox_face_detection
<p align="center">
<img src="https://bj.bcebos.com/paddlehub/paddlehub-img/pyramidbox_face_detection_network.png" hspace='10'/> <br />
Pyramidbox模型框架图
</p>
|模型名称|pyramidbox_face_detection|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|PyramidBox|
|数据集|WIDER FACE数据集|
|是否支持Fine-tuning|否|
|模型大小|220MB|
|最新更新日期|2021-02-26|
|数据指标|-|
模型详情请参考[论文](https://arxiv.org/pdf/1803.07737.pdf)
## 一、模型基本信息
## 命令行预测
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131602468-351eb3fb-81e3-4294-ac8e-b49a3a0232cb.jpg" width='50%' hspace='10'/>
<br />
</p>
```
hub run pyramidbox_face_detection --input_path "/PATH/TO/IMAGE"
```
## API
- ### 模型介绍
```python
def face_detection(images=None,
paths=None,
use_gpu=False,
output_dir='detection_result',
visualization=False,
score_thresh=0.15):
```
- PyramidBox是一种基于SSD的单阶段人脸检测器，它利用上下文信息解决困难人脸的检测问题。PyramidBox在六个尺度的特征图上进行不同层级的预测。该工作主要包括以下模块：LFPN、PyramidAnchors、CPM、Data-anchor-sampling。该PaddleHub Module的预训练数据集为WIDER FACE数据集，可支持预测。
预测API，检测输入图片中的所有人脸位置。
**参数**
## 二、安装
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* use\_gpu (bool): 是否使用 GPU；
* output\_dir (str): 图片的保存路径，当为 None 时，默认设为 detection\_result；
* visualization (bool): 是否将识别结果保存为图片文件；
* score\_thresh (float): 检测置信度的阈值。
- ### 1、环境依赖
**返回**
- paddlepaddle >= 1.6.2
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字包括'path', 'data', 相应的取值为：
* path (str): 原输入图片的路径；
* data (list): 检测结果，list的每一个元素为 dict，各字段为:
* confidence (float): 识别的置信度；
* left (int): 边界框的左上角x坐标；
* top (int): 边界框的左上角y坐标；
* right (int): 边界框的右下角x坐标；
* bottom (int): 边界框的右下角y坐标。
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- ### 2、安装
将模型保存到指定路径。
- ```shell
$ hub install pyramidbox_face_detection
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
**参数**
## 三、模型API预测
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- ### 1、命令行预测
## 代码示例
- ```shell
$ hub run pyramidbox_face_detection --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
```python
import paddlehub as hub
import cv2
- ### 2、代码示例
face_detector = hub.Module(name="pyramidbox_face_detection")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection((paths=['/PATH/TO/IMAGE'])
```
- ```python
import paddlehub as hub
import cv2
## 服务部署
face_detector = hub.Module(name="pyramidbox_face_detection")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 3、API
## 第一步：启动PaddleHub Serving
- ```python
def face_detection(images=None,
paths=None,
use_gpu=False,
output_dir='detection_result',
visualization=False,
score_thresh=0.15)
```
运行启动命令：
```shell
$ hub serving start -m pyramidbox_face_detection
```
- 检测输入图片中的所有人脸位置。
这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- **参数**
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- score_thresh (float): 置信度的阈值。
## 第二步：发送预测请求
**NOTE:** paths和images两个参数选择其一进行提供数据
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **返回**
```python
import requests
import json
import cv2
import base64
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
- **参数**
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_face_detection"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
# 打印预测结果
print(r.json()["results"])
```
## 查看代码
## 四、服务部署
https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/face_detection
- PaddleHub Serving可以部署一个在线人脸检测服务。
### 依赖
- ### 第一步：启动PaddleHub Serving
paddlepaddle >= 1.6.2
- 运行启动命令：
- ```shell
$ hub serving start -m pyramidbox_face_detection
```
paddlehub >= 1.6.0
- 这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_face_detection"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
修复numpy数据读取问题
- ```shell
$ hub install pyramidbox_face_detection==1.1.0
```
modules/image/face_detection/pyramidbox_lite_mobile/README.md
浏览文件 @ 13cc2d57
```shell
$ hub install pyramidbox_lite_mobile==1.2.0
```
# pyramidbox_lite_mobile
## 命令行预测
|模型名称|pyramidbox_lite_mobile|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|PyramidBox|
|数据集|WIDER FACE数据集 + 百度自采人脸数据集|
|是否支持Fine-tuning|否|
|模型大小|7.3MB|
|最新更新日期|2021-02-26|
|数据指标|-|
```
hub run pyramidbox_lite_mobile --input_path "/PATH/TO/IMAGE"
```
## API
## 一、模型基本信息
```python
def face_detection(images=None,
paths=None,
data=None,
use_gpu=False,
output_dir='detection_result',
visualization=False,
shrink=0.5,
confs_threshold=0.6)
```
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131602468-351eb3fb-81e3-4294-ac8e-b49a3a0232cb.jpg" width='50%' hspace='10'/>
<br />
</p>
检测输入图片中的所有人脸位置
- ### 模型介绍
**参数**
- PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性。该PaddleHub Module是针对于移动端优化过的模型，适合部署于移动端或者边缘检测等算力受限的设备上，并基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于人脸检测。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 detection\_result；
* shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果。
* confs\_threshold (float): 置信度的阈值。
**返回**
## 二、安装
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* path (str): 原输入图片的路径；
* data (list): 检测结果，list的每一个元素为 dict，各字段为:
* confidence (float): 识别的置信度；
* left (int): 边界框的左上角x坐标；
* top (int): 边界框的左上角y坐标；
* right (int): 边界框的右下角x坐标；
* bottom (int): 边界框的右下角y坐标。
- ### 1、环境依赖
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- paddlepaddle >= 1.6.2
将模型保存到指定路径。
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- ### 2、安装
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- ```shell
$ hub install pyramidbox_lite_mobile
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 代码示例
## 三、模型API预测
```python
import paddlehub as hub
import cv2
- ### 1、命令行预测
face_detector = hub.Module(name="pyramidbox_lite_mobile")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection((paths=['/PATH/TO/IMAGE'])
```
- ```shell
$ hub run pyramidbox_lite_mobile --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
## 服务部署
- ### 2、代码示例
PaddleHub Serving可以部署一个在线人脸检测服务。
- ```python
import paddlehub as hub
import cv2
## 第一步：启动PaddleHub Serving
face_detector = hub.Module(name="pyramidbox_lite_mobile")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
运行启动命令：
```shell
$ hub serving start -m pyramidbox_lite_mobile
```
- ### 3、API
这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- ```python
def face_detection(images=None,
paths=None,
use_gpu=False,
output_dir='detection_result',
visualization=False,
shrink=0.5,
confs_threshold=0.6)
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- 检测输入图片中的所有人脸位置。
## 第二步：发送预测请求
- **参数**
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
- confs\_threshold (float): 置信度的阈值。
```python
import requests
import json
import cv2
import base64
**NOTE:** paths和images两个参数选择其一进行提供数据
- **返回**
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
# 打印预测结果
print(r.json()["results"])
```
- **参数**
### 依赖
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
paddlepaddle >= 1.6.2
paddlehub >= 1.6.0
## 四、服务部署
- PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m pyramidbox_lite_mobile
```
- 这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_mobile"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.2.0
- ```shell
$ hub install pyramidbox_lite_mobile==1.2.0
```
modules/image/face_detection/pyramidbox_lite_mobile_mask/README.md
浏览文件 @ 13cc2d57
```shell
$ hub install pyramidbox_lite_mobile_mask==1.3.0
```
# pyramidbox_lite_mobile_mask
## 命令行预测
|模型名称|pyramidbox_lite_mobile_mask|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|PyramidBox|
|数据集|WIDER FACE数据集 + 百度自采人脸数据集|
|是否支持Fine-tuning|否|
|模型大小|1.2MB|
|最新更新日期|2021-02-26|
|数据指标|-|
```
hub run pyramidbox_lite_mobile_mask --input_path "/PATH/TO/IMAGE"
```
## API
## 一、模型基本信息
```python
def __init__(face_detector_module=None)
```
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131603304-690a2e3b-9f24-42f6-9297-a12ada884191.jpg" width='50%' hspace='10'/>
<br />
</p>
**参数**
- ### 模型介绍
* face\_detector\_module (class): 人脸检测模型，默认为 pyramidbox\_lite\_mobile.
- PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性。该PaddleHub Module是针对于移动端优化过的模型，适合部署于移动端或者边缘检测等算力受限的设备上，并基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于检测人脸是否佩戴口罩。
```python
def face_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='detection_result',
use_multi_scale=False,
shrink=0.5,
confs_threshold=0.6):
```
## 二、安装
识别输入图片中的所有的人脸，并判断有无戴口罩。
- ### 1、环境依赖
**参数**
- paddlepaddle >= 1.6.2
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 detection\_result。
* use\_multi\_scale (bool) : 用于设置是否开启多尺度的人脸检测，开启多尺度人脸检测能够更好的检测到输入图像中不同尺寸的人脸，但是会增加模型计算量，降低预测速度；
* shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；
* confs\_threshold (float): 人脸检测的置信度的阈值。
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**返回**
- ### 2、安装
* res (list\[dict\]): 识别结果的列表，列表元素为 dict, 有以下两个字段：
* path (str): 原图的路径。
* data (list\[dict\]): 识别的边界框列表，有以下字段：
* label (str): 识别标签，为 'NO MASK' 或者 'MASK'；
* confidence (float): 识别的置信度；
* left (int): 边界框的左上角x坐标；
* top (int): 边界框的左上角y坐标；
* right (int): 边界框的右下角x坐标；
* bottom (int): 边界框的右下角y坐标；
- ```shell
$ hub install pyramidbox_lite_mobile_mask
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
```python
def set_face_detector_module(face_detector_module)
```
## 三、模型API预测
设置口罩检测模型中进行人脸检测的底座模型。
- ### 1、命令行预测
**参数**
- ```shell
$ hub run pyramidbox_lite_mobile_mask --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* face\_detector\_module (class): 人脸检测模型
- ### 2、代码示例
```python
def get_face_detector_module()
```
- ```python
import paddlehub as hub
import cv2
获取口罩检测模型中进行人脸检测的底座模型。
mask_detector = hub.Module(name="pyramidbox_lite_mobile_mask")
result = mask_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = mask_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
**返回**
- ### 3、API
* 当前模型使用的人脸检测模型。
- ```python
def __init__(face_detector_module=None)
```
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- **参数**
将模型保存到指定路径。
- face\_detector\_module (class): 人脸检测模型，默认为 pyramidbox\_lite\_mobile。
**参数**
- ```python
def face_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='detection_result',
use_multi_scale=False,
shrink=0.5,
confs_threshold=0.6)
```
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- 识别输入图片中的所有的人脸，并判断有无戴口罩。
## 代码示例
- **参数**
```python
import paddlehub as hub
import cv2
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；<br/>
- use\_multi\_scale (bool) : 用于设置是否开启多尺度的人脸检测，开启多尺度人脸检测能够更好的检测到输入图像中不同尺寸的人脸，但是会增加模型计算量，降低预测速度；<br/>
- shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
- confs\_threshold (float): 置信度的阈值。
mask_detector = hub.Module(name="pyramidbox_lite_mobile_mask")
**NOTE:** paths和images两个参数选择其一进行提供数据
result = mask_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = mask_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
- **返回**
## 服务部署
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- label (str): 识别标签，为 'NO MASK' 或者 'MASK'；
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
PaddleHub Serving可以部署一个在线人脸关键点检测服务。
- ```python
def set_face_detector_module(face_detector_module)
```
- 设置口罩检测模型中进行人脸检测的底座模型。
- **参数**
## 第一步：启动PaddleHub Serving
- face\_detector\_module (class): 人脸检测模型。
运行启动命令：
```shell
$ hub serving start -m pyramidbox_lite_mobile_mask
```
- ```python
def get_face_detector_module()
```
- 获取口罩检测模型中进行人脸检测的底座模型。
- **返回**
这样就完成了一个人脸关键点服务化API的部署，默认端口号为8866。
- 当前模型使用的人脸检测模型
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
```python
import requests
import json
import cv2
import base64
- **参数**
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_mobile_mask"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 四、服务部署
## Paddle Lite部署
- PaddleHub Serving可以部署一个在线口罩检测服务。
1. 通过python执行以下代码，保存模型
- ### 第一步：启动PaddleHub Serving
```python
import paddlehub as hub
pyramidbox_lite_mobile_mask = hub.Module(name="pyramidbox_lite_mobile_mask")
- 运行启动命令：
- ```shell
$ hub serving start -m pyramidbox_lite_mobile_mask
```
# 将模型保存在test_program文件夹之中
pyramidbox_lite_mobile_mask.save_inference_model(dirname="test_program")
```
- 这样就完成了一个口罩检测服务化API的部署，默认端口号为8866。
通过以上命令，可以获得人脸检测和口罩佩戴判断模型，分别存储在pyramidbox\_lite和mask\_detector之中。文件夹中的\_\_model\_\_是模型结构文件，\_\_params\_\_文件是权重文件。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
2. 进行模型转换
- ### 第二步：发送预测请求
从paddlehub下载的是预测模型，可以使用PaddleLite提供的模型优化工具OPT对预测模型进行转换，转换之后进而可以实现在手机等端侧硬件上的部署，具体请请参考[OPT工具](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
3. 模型通过Paddle Lite进行部署
- ```python
import requests
import json
import cv2
import base64
参考[Paddle-Lite口罩检测模型部署教程](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx)
### 依赖
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
paddlepaddle >= 1.6.2
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_mobile_mask"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
paddlehub >= 1.6.0
# 打印预测结果
print(r.json()["results"])
```
## 五、Paddle Lite部署
- ### 通过python执行以下代码，保存模型
- ```python
import paddlehub as hub
pyramidbox_lite_mobile_mask = hub.Module(name="pyramidbox_lite_mobile_mask")
# 将模型保存在test_program文件夹之中
pyramidbox_lite_mobile_mask.save_inference_model(dirname="test_program")
```
通过以上命令，可以获得人脸检测和口罩佩戴判断模型，分别存储在pyramidbox\_lite和mask\_detector之中。文件夹中的\_\_model\_\_是模型结构文件，\_\_params\_\_文件是权重文件。
- ### 进行模型转换
- 从paddlehub下载的是预测模型，可以使用PaddleLite提供的模型优化工具OPT对预测模型进行转换，转换之后进而可以实现在手机等端侧硬件上的部署，具体请请参考[OPT工具](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)
- ### 模型通过Paddle Lite进行部署
- 参考[Paddle-Lite口罩检测模型部署教程](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx)
## 五、更新历史
* 1.0.0
初始发布
* 1.3.0
- ```shell
$ hub install pyramidbox_lite_mobile_mask==1.3.0
```
modules/image/face_detection/pyramidbox_lite_server/README.md
浏览文件 @ 13cc2d57
```shell
$ hub install pyramidbox_lite_server==1.2.0
```
# pyramidbox_lite_server
## 命令行预测
|模型名称|pyramidbox_lite_server|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|PyramidBox|
|数据集|WIDER FACE数据集 + 百度自采人脸数据集|
|是否支持Fine-tuning|否|
|模型大小|8MB|
|最新更新日期|2021-02-26|
|数据指标|-|
```
hub run pyramidbox_lite_server --input_path "/PATH/TO/IMAGE"
```
## API
## 一、模型基本信息
```python
def face_detection(images=None,
paths=None,
data=None,
use_gpu=False,
output_dir='detection_result',
visualization=False,
shrink=0.5,
confs_threshold=0.6)
```
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131602468-351eb3fb-81e3-4294-ac8e-b49a3a0232cb.jpg" width='50%' hspace='10'/>
<br />
</p>
检测输入图片中的所有人脸位置
- ### 模型介绍
**参数**
- PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性。该PaddleHub Module基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于人脸检测。
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 detection\_result；
* shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果。
* confs\_threshold (float): 置信度的阈值。
**返回**
## 二、安装
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为：
* path (str): 原输入图片的路径；
* data (list): 检测结果，list 的每一个元素为 dict，各字段为:
* confidence (float): 识别的置信度；
* left (int): 边界框的左上角x坐标；
* top (int): 边界框的左上角y坐标；
* right (int): 边界框的右下角x坐标；
* bottom (int): 边界框的右下角y坐标。
- ### 1、环境依赖
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- paddlepaddle >= 1.6.2
将模型保存到指定路径。
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**参数**
- ### 2、安装
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- ```shell
$ hub install pyramidbox_lite_server
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
## 代码示例
## 三、模型API预测
```python
import paddlehub as hub
import cv2
- ### 1、命令行预测
face_detector = hub.Module(name="pyramidbox_lite_server")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection((paths=['/PATH/TO/IMAGE'])
```
- ```shell
$ hub run pyramidbox_lite_server --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
## 服务部署
- ### 2、代码示例
PaddleHub Serving可以部署一个在线人脸检测服务。
- ```python
import paddlehub as hub
import cv2
## 第一步：启动PaddleHub Serving
face_detector = hub.Module(name="pyramidbox_lite_server")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
运行启动命令：
```shell
$ hub serving start -m pyramidbox_lite_server
```
- ### 3、API
这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- ```python
def face_detection(images=None,
paths=None,
use_gpu=False,
output_dir='detection_result',
visualization=False,
shrink=0.5,
confs_threshold=0.6)
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- 检测输入图片中的所有人脸位置。
## 第二步：发送预测请求
- **参数**
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
- confs\_threshold (float): 置信度的阈值。
```python
import requests
import json
import cv2
import base64
**NOTE:** paths和images两个参数选择其一进行提供数据
- **返回**
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
# 打印预测结果
print(r.json()["results"])
```
- **参数**
### 依赖
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
paddlepaddle >= 1.6.2
paddlehub >= 1.6.0
## 四、服务部署
- PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m pyramidbox_lite_server
```
- 这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_server"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.2.0
修复numpy数据读取问题
- ```shell
$ hub install pyramidbox_lite_server==1.2.0
```
modules/image/face_detection/pyramidbox_lite_server_mask/README.md
浏览文件 @ 13cc2d57
```shell
$ hub install pyramidbox_lite_server_mask==1.3.0
```
# pyramidbox_lite_server_mask
## 命令行预测
|模型名称|pyramidbox_lite_server_mask|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|PyramidBox|
|数据集|WIDER FACE数据集 + 百度自采人脸数据集|
|是否支持Fine-tuning|否|
|模型大小|1.2MB|
|最新更新日期|2021-02-26|
|数据指标|-|
```
hub run pyramidbox_lite_server_mask --input_path "/PATH/TO/IMAGE"
```
## API
## 一、模型基本信息
```python
def __init__(face_detector_module=None)
```
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131603304-690a2e3b-9f24-42f6-9297-a12ada884191.jpg" width='50%' hspace='10'/>
<br />
</p>
**参数**
- ### 模型介绍
* face\_detector\_module (class): 人脸检测模型，默认为 pyramidbox\_lite\_server.
- PyramidBox-Lite是基于2018年百度发表于计算机视觉顶级会议ECCV 2018的论文PyramidBox而研发的轻量级模型，模型基于主干网络FaceBoxes，对于光照、口罩遮挡、表情变化、尺度变化等常见问题具有很强的鲁棒性。该PaddleHub Module基于WIDER FACE数据集和百度自采人脸数据集进行训练，支持预测，可用于检测人脸是否佩戴口罩。
```python
def face_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='detection_result',
use_multi_scale=False,
shrink=0.5,
confs_threshold=0.6):
```
## 二、安装
识别输入图片中的所有的人脸，并判断有无戴口罩。
- ### 1、环境依赖
**参数**
- paddlepaddle >= 1.6.2
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，默认设为 detection\_result。
* use\_multi\_scale (bool) : 用于设置是否开启多尺度的人脸检测，开启多尺度人脸检测能够更好的检测到输入图像中不同尺寸的人脸，但是会增加模型计算量，降低预测速度；
* shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；
* confs\_threshold (float): 人脸检测的置信度的阈值。
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
**返回**
- ### 2、安装
* res (list\[dict\]): 识别结果的列表，列表元素为 dict, 有以下两个字段：
* path (str): 原图的路径。
* data (list\[dict\]): 识别的边界框列表，有以下字段：
* label (str): 识别标签，为 'NO MASK' 或者 'MASK'；
* confidence (float): 识别的置信度；
* left (int): 边界框的左上角x坐标；
* top (int): 边界框的左上角y坐标；
* right (int): 边界框的右下角x坐标；
* bottom (int): 边界框的右下角y坐标；
- ```shell
$ hub install pyramidbox_lite_server_mask
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
```python
def set_face_detector_module(face_detector_module)
```
## 三、模型API预测
设置口罩检测模型中进行人脸检测的底座模型。
- ### 1、命令行预测
**参数**
- ```shell
$ hub run pyramidbox_lite_server_mask --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* face\_detector\_module (class): 人脸检测模型
- ### 2、代码示例
```python
def get_face_detector_module()
```
- ```python
import paddlehub as hub
import cv2
获取口罩检测模型中进行人脸检测的底座模型。
mask_detector = hub.Module(name="pyramidbox_lite_server_mask")
result = mask_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = mask_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
**返回**
- ### 3、API
* 当前模型使用的人脸检测模型。
- ```python
def __init__(face_detector_module=None)
```
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- **参数**
将模型保存到指定路径。
- face\_detector\_module (class): 人脸检测模型，默认为 pyramidbox\_lite\_server。
**参数**
- ```python
def face_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir='detection_result',
use_multi_scale=False,
shrink=0.5,
confs_threshold=0.6)
```
* dirname: 存在模型的目录名称
* model\_filename: 模型文件名称，默认为\_\_model\_\_
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- 识别输入图片中的所有的人脸，并判断有无戴口罩。
## 代码示例
- **参数**
```python
import paddlehub as hub
import cv2
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- output\_dir (str): 图片的保存路径，默认设为 detection\_result；<br/>
- use\_multi\_scale (bool) : 用于设置是否开启多尺度的人脸检测，开启多尺度人脸检测能够更好的检测到输入图像中不同尺寸的人脸，但是会增加模型计算量，降低预测速度；<br/>
- shrink (float): 用于设置图片的缩放比例，该值越大，则对于输入图片中的小尺寸人脸有更好的检测效果（模型计算成本越高），反之则对于大尺寸人脸有更好的检测效果；<br/>
- confs\_threshold (float): 置信度的阈值。
mask_detector = hub.Module(name="pyramidbox_lite_server_mask")
**NOTE:** paths和images两个参数选择其一进行提供数据
result = mask_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = mask_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
- **返回**
## 服务部署
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- label (str): 识别标签，为 'NO MASK' 或者 'MASK'；
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
PaddleHub Serving可以部署一个在线人脸关键点检测服务。
- ```python
def set_face_detector_module(face_detector_module)
```
- 设置口罩检测模型中进行人脸检测的底座模型。
- **参数**
## 第一步：启动PaddleHub Serving
- face\_detector\_module (class): 人脸检测模型。
运行启动命令：
```shell
$ hub serving start -m pyramidbox_lite_server_mask
```
- ```python
def get_face_detector_module()
```
- 获取口罩检测模型中进行人脸检测的底座模型。
- **返回**
这样就完成了一个人脸关键点服务化API的部署，默认端口号为8866。
- 当前模型使用的人脸检测模型
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
```python
import requests
import json
import cv2
import base64
- **参数**
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_server_mask"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 四、服务部署
## Paddle Lite部署
- PaddleHub Serving可以部署一个在线口罩检测服务。
1. 通过python执行以下代码，保存模型
- ### 第一步：启动PaddleHub Serving
```python
import paddlehub as hub
pyramidbox_lite_server_mask = hub.Module(name="pyramidbox_lite_server_mask")
- 运行启动命令：
- ```shell
$ hub serving start -m pyramidbox_lite_server_mask
```
# 将模型保存在test_program文件夹之中
pyramidbox_lite_server_mask.save_inference_model(dirname="test_program")
```
- 这样就完成了一个口罩检测服务化API的部署，默认端口号为8866。
通过以上命令，可以获得人脸检测和口罩佩戴判断模型，分别存储在pyramidbox\_lite和mask\_detector之中。文件夹中的\_\_model\_\_是模型结构文件，\_\_params\_\_文件是权重文件。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
2. 进行模型转换
- ### 第二步：发送预测请求
从paddlehub下载的是预测模型，可以使用PaddleLite提供的模型优化工具OPT对预测模型进行转换，转换之后进而可以实现在手机等端侧硬件上的部署，具体请请参考[OPT工具](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
3. 模型通过Paddle Lite进行部署
- ```python
import requests
import json
import cv2
import base64
参考[Paddle-Lite口罩检测模型部署教程](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx)
### 依赖
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
paddlepaddle >= 1.6.2
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/pyramidbox_lite_server_mask"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
paddlehub >= 1.6.0
# 打印预测结果
print(r.json()["results"])
```
## 五、Paddle Lite部署
- ### 通过python执行以下代码，保存模型
- ```python
import paddlehub as hub
pyramidbox_lite_server_mask = hub.Module(name="pyramidbox_lite_server_mask")
# 将模型保存在test_program文件夹之中
pyramidbox_lite_server_mask.save_inference_model(dirname="test_program")
```
通过以上命令，可以获得人脸检测和口罩佩戴判断模型，分别存储在pyramidbox\_lite和mask\_detector之中。文件夹中的\_\_model\_\_是模型结构文件，\_\_params\_\_文件是权重文件。
- ### 进行模型转换
- 从paddlehub下载的是预测模型，可以使用PaddleLite提供的模型优化工具OPT对预测模型进行转换，转换之后进而可以实现在手机等端侧硬件上的部署，具体请请参考[OPT工具](https://paddle-lite.readthedocs.io/zh/latest/user_guides/model_optimize_tool.html)
- ### 模型通过Paddle Lite进行部署
- 参考[Paddle-Lite口罩检测模型部署教程](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx)
## 五、更新历史
* 1.0.0
初始发布
* 1.3.1
- ```shell
$ hub install pyramidbox_lite_server_mask==1.3.1
```
modules/image/face_detection/pyramidbox_lite_server_mask/data_feed.py
浏览文件 @ 13cc2d57
......@@ -43,7 +43,8 @@ def bbox_vote(det):
det_accu[:, 0:4] = det_accu[:, 0:4] * np.tile(det_accu[:, -1:], (1, 4))
max_score = np.max(det_accu[:, 4])
det_accu_sum = np.zeros((1, 5))
det_accu_sum[:, 0:4] = np.sum(det_accu[:, 0:4], axis=0) / np.sum(det_accu[:, -1:])
det_accu_sum[:, 0:4] = np.sum(
det_accu[:, 0:4], axis=0) / np.sum(det_accu[:, -1:])
det_accu_sum[:, 4] = max_score
try:
dets = np.row_stack((dets, det_accu_sum))
......@@ -53,26 +54,38 @@ def bbox_vote(det):
return dets
def crop(image, pts, shift=0, scale=1.5, rotate=0, res_width=128, res_height=128):
def crop(image,
pts,
shift=0,
scale=1.5,
rotate=0,
res_width=128,
res_height=128):
res = (res_width, res_height)
idx1 = 0
idx2 = 1
# angle
alpha = 0
if pts[idx2, 0] != -1 and pts[idx2, 1] != -1 and pts[idx1, 0] != -1 and pts[idx1, 1] != -1:
alpha = math.atan2(pts[idx2, 1] - pts[idx1, 1], pts[idx2, 0] - pts[idx1, 0]) * 180 / math.pi
if pts[idx2, 0] != -1 and pts[idx2, 1] != -1 and pts[idx1, 0] != -1 and pts[
idx1, 1] != -1:
alpha = math.atan2(pts[idx2, 1] - pts[idx1, 1],
pts[idx2, 0] - pts[idx1, 0]) * 180 / math.pi
pts[pts == -1] = np.inf
coord_min = np.min(pts, 0)
pts[pts == np.inf] = -1
coord_max = np.max(pts, 0)
# coordinates of center point
c = np.array([coord_max[0] - (coord_max[0] - coord_min[0]) / 2,
coord_max[1] - (coord_max[1] - coord_min[1]) / 2]) # center
max_wh = max((coord_max[0] - coord_min[0]) / 2, (coord_max[1] - coord_min[1]) / 2)
c = np.array([
coord_max[0] - (coord_max[0] - coord_min[0]) / 2,
coord_max[1] - (coord_max[1] - coord_min[1]) / 2
]) # center
max_wh = max((coord_max[0] - coord_min[0]) / 2,
(coord_max[1] - coord_min[1]) / 2)
# Shift the center point, rot add eyes angle
c = c + shift * max_wh
rotate = rotate + alpha
M = cv2.getRotationMatrix2D((c[0], c[1]), rotate, res[0] / (2 * max_wh * scale))
M = cv2.getRotationMatrix2D((c[0], c[1]), rotate,
res[0] / (2 * max_wh * scale))
M[0, 2] = M[0, 2] - (c[0] - res[0] / 2.0)
M[1, 2] = M[1, 2] - (c[1] - res[0] / 2.0)
image_out = cv2.warpAffine(image, M, res)
......@@ -84,24 +97,27 @@ def color_normalize(image, mean, std=None):
image = np.repeat(image, axis=2)
h, w, c = image.shape
image = np.transpose(image, (2, 0, 1))
image = np.subtract(image.reshape(c, -1), mean[:, np.newaxis]).reshape(-1, h, w)
image = np.subtract(image.reshape(c, -1), mean[:, np.newaxis]).reshape(
-1, h, w)
image = np.transpose(image, (1, 2, 0))
return image
def process_image(org_im, face):
pts = np.array([
face['left'], face['top'], face['right'], face['top'], face['left'], face['bottom'], face['right'],
face['bottom']
face['left'], face['top'], face['right'], face['top'], face['left'],
face['bottom'], face['right'], face['bottom']
]).reshape(4, 2).astype(np.float32)
image_in, M = crop(org_im, pts)
image_in = image_in / 256.0
image_in = color_normalize(image_in, mean=np.array([0.5, 0.5, 0.5]))
image_in = image_in.astype(np.float32).transpose([2, 0, 1]).reshape(-1, 3, 128, 128)
image_in = image_in.astype(np.float32).transpose([2, 0, 1]).reshape(
-1, 3, 128, 128)
return image_in
def reader(face_detector, shrink, confs_threshold, images, paths, use_gpu, use_multi_scale):
def reader(face_detector, shrink, confs_threshold, images, paths, use_gpu,
use_multi_scale):
"""
Preprocess to yield image.
......@@ -126,7 +142,8 @@ def reader(face_detector, shrink, confs_threshold, images, paths, use_gpu, use_m
assert type(paths) is list, "paths should be a list."
for im_path in paths:
each = OrderedDict()
assert os.path.isfile(im_path), "The {} isn't a valid file path.".format(im_path)
assert os.path.isfile(
im_path), "The {} isn't a valid file path.".format(im_path)
im = cv2.imread(im_path)
each['org_im'] = im
each['org_im_path'] = im_path
......@@ -136,7 +153,8 @@ def reader(face_detector, shrink, confs_threshold, images, paths, use_gpu, use_m
for im in images:
each = OrderedDict()
each['org_im'] = im
each['org_im_path'] = 'ndarray_time={}'.format(round(time.time(), 6) * 1e6)
each['org_im_path'] = 'ndarray_time={}'.format(
round(time.time(), 6) * 1e6)
component.append(each)
for element in component:
......@@ -153,19 +171,30 @@ def reader(face_detector, shrink, confs_threshold, images, paths, use_gpu, use_m
_s = list()
for _face in _detect_res[0]['data']:
_face_list = [_face['left'], _face['top'], _face['right'], _face['bottom'], _face['confidence']]
_face_list = [
_face['left'], _face['top'], _face['right'],
_face['bottom'], _face['confidence']
]
_s.append(_face_list)
if _s:
scale_res.append(np.array(_s))
scale_res = np.row_stack(scale_res)
scale_res = bbox_vote(scale_res)
keep_index = np.where(scale_res[:, 4] >= confs_threshold)[0]
scale_res = scale_res[keep_index, :]
for data in scale_res:
face = {'left': data[0], 'top': data[1], 'right': data[2], 'bottom': data[3], 'confidence': data[4]}
detect_faces.append(face)
if scale_res:
scale_res = np.row_stack(scale_res)
scale_res = bbox_vote(scale_res)
keep_index = np.where(scale_res[:, 4] >= confs_threshold)[0]
scale_res = scale_res[keep_index, :]
for data in scale_res:
face = {
'left': data[0],
'top': data[1],
'right': data[2],
'bottom': data[3],
'confidence': data[4]
}
detect_faces.append(face)
else:
detect_faces = []
else:
_detect_res = face_detector.face_detection(
images=[element['org_im']],
......
modules/image/face_detection/pyramidbox_lite_server_mask/module.py
浏览文件 @ 13cc2d57
......@@ -23,14 +23,15 @@ from pyramidbox_lite_server_mask.processor import postprocess, base64_to_cv2
author_email="",
summary=
"PyramidBox-Lite-Server-Mask is a high-performance face detection model used to detect whether people wear masks.",
version="1.3.0")
version="1.3.1")
class PyramidBoxLiteServerMask(hub.Module):
def _initialize(self, face_detector_module=None):
"""
Args:
face_detector_module (class): module to detect face.
"""
self.default_pretrained_model_path = os.path.join(self.directory, "pyramidbox_lite_server_mask_model")
self.default_pretrained_model_path = os.path.join(
self.directory, "pyramidbox_lite_server_mask_model")
if face_detector_module is None:
self.face_detector = hub.Module(name='pyramidbox_lite_server')
else:
......@@ -56,7 +57,8 @@ class PyramidBoxLiteServerMask(hub.Module):
if use_gpu:
gpu_config = AnalysisConfig(self.default_pretrained_model_path)
gpu_config.disable_glog_info()
gpu_config.enable_use_gpu(memory_pool_init_size_mb=1000, device_id=0)
gpu_config.enable_use_gpu(
memory_pool_init_size_mb=1000, device_id=0)
self.gpu_predictor = create_paddle_predictor(gpu_config)
def set_face_detector_module(self, face_detector_module):
......@@ -105,7 +107,7 @@ class PyramidBoxLiteServerMask(hub.Module):
int(_places[0])
except:
raise RuntimeError(
"Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
"Attempt to use GPU for prediction, but environment variable CUDA_VISIBLE_DEVICES was not set correctly."
)
# compatibility with older versions
......@@ -121,13 +123,16 @@ class PyramidBoxLiteServerMask(hub.Module):
# get all data
all_element = list()
for yield_data in reader(self.face_detector, shrink, confs_threshold, images, paths, use_gpu, use_multi_scale):
for yield_data in reader(self.face_detector, shrink, confs_threshold,
images, paths, use_gpu, use_multi_scale):
all_element.append(yield_data)
image_list = list()
element_image_num = list()
for i in range(len(all_element)):
element_image = [handled['image'] for handled in all_element[i]['preprocessed']]
element_image = [
handled['image'] for handled in all_element[i]['preprocessed']
]
element_image_num.append(len(element_image))
image_list.extend(element_image)
......@@ -146,7 +151,9 @@ class PyramidBoxLiteServerMask(hub.Module):
image_arr = np.squeeze(np.array(batch_data), axis=1)
image_tensor = PaddleTensor(image_arr.copy())
data_out = self.gpu_predictor.run([image_tensor]) if use_gpu else self.cpu_predictor.run([image_tensor])
data_out = self.gpu_predictor.run([
image_tensor
]) if use_gpu else self.cpu_predictor.run([image_tensor])
# len(data_out) == 1
# data_out[0].as_ndarray().shape == (-1, 2)
data_out = data_out[0].as_ndarray()
......@@ -156,7 +163,9 @@ class PyramidBoxLiteServerMask(hub.Module):
# postprocess one by one
res = list()
for i in range(len(all_element)):
detect_faces_list = [handled['face'] for handled in all_element[i]['preprocessed']]
detect_faces_list = [
handled['face'] for handled in all_element[i]['preprocessed']
]
interval_left = sum(element_image_num[0:i])
interval_right = interval_left + element_image_num[i]
out = postprocess(
......@@ -169,16 +178,31 @@ class PyramidBoxLiteServerMask(hub.Module):
res.append(out)
return res
def save_inference_model(self, dirname, model_filename=None, params_filename=None, combined=True):
def save_inference_model(self,
dirname,
model_filename=None,
params_filename=None,
combined=True):
classifier_dir = os.path.join(dirname, 'mask_detector')
detector_dir = os.path.join(dirname, 'pyramidbox_lite')
self._save_classifier_model(classifier_dir, model_filename, params_filename, combined)
self._save_detector_model(detector_dir, model_filename, params_filename, combined)
self._save_classifier_model(classifier_dir, model_filename,
params_filename, combined)
self._save_detector_model(detector_dir, model_filename, params_filename,
combined)
def _save_detector_model(self, dirname, model_filename=None, params_filename=None, combined=True):
self.face_detector.save_inference_model(dirname, model_filename, params_filename, combined)
def _save_detector_model(self,
dirname,
model_filename=None,
params_filename=None,
combined=True):
self.face_detector.save_inference_model(dirname, model_filename,
params_filename, combined)
def _save_classifier_model(self, dirname, model_filename=None, params_filename=None, combined=True):
def _save_classifier_model(self,
dirname,
model_filename=None,
params_filename=None,
combined=True):
if combined:
model_filename = "__model__" if not model_filename else model_filename
params_filename = "__params__" if not params_filename else params_filename
......@@ -216,9 +240,12 @@ class PyramidBoxLiteServerMask(hub.Module):
prog='hub run {}'.format(self.name),
usage='%(prog)s',
add_help=True)
self.arg_input_group = self.parser.add_argument_group(title="Input options", description="Input data. Required")
self.arg_input_group = self.parser.add_argument_group(
title="Input options", description="Input data. Required")
self.arg_config_group = self.parser.add_argument_group(
title="Config options", description="Run configuration for controlling module behavior, not required.")
title="Config options",
description=
"Run configuration for controlling module behavior, not required.")
self.add_module_config_arg()
self.add_module_input_arg()
args = self.parser.parse_args(argvs)
......@@ -236,21 +263,36 @@ class PyramidBoxLiteServerMask(hub.Module):
Add the command config options.
"""
self.arg_config_group.add_argument(
'--use_gpu', type=ast.literal_eval, default=False, help="whether use GPU or not")
'--use_gpu',
type=ast.literal_eval,
default=False,
help="whether use GPU or not")
self.arg_config_group.add_argument(
'--output_dir', type=str, default='detection_result', help="The directory to save output images.")
'--output_dir',
type=str,
default='detection_result',
help="The directory to save output images.")
self.arg_config_group.add_argument(
'--visualization', type=ast.literal_eval, default=False, help="whether to save output as images.")
'--visualization',
type=ast.literal_eval,
default=False,
help="whether to save output as images.")
def add_module_input_arg(self):
"""
Add the command input options.
"""
self.arg_input_group.add_argument('--input_path', type=str, help="path to image.")
self.arg_input_group.add_argument(
'--input_path', type=str, help="path to image.")
self.arg_input_group.add_argument(
'--shrink',
type=ast.literal_eval,
default=0.5,
help="resize the image to `shrink * original_shape` before feeding into network.")
help=
"resize the image to `shrink * original_shape` before feeding into network."
)
self.arg_input_group.add_argument(
'--confs_threshold', type=ast.literal_eval, default=0.6, help="confidence threshold.")
'--confs_threshold',
type=ast.literal_eval,
default=0.6,
help="confidence threshold.")
modules/image/face_detection/pyramidbox_lite_server_mask/processor.py
浏览文件 @ 13cc2d57
......@@ -57,7 +57,8 @@ def get_save_image_name(org_im, org_im_path, output_dir):
# save image path
save_im_path = os.path.join(output_dir, im_prefix + ext)
if os.path.exists(save_im_path):
save_im_path = os.path.join(output_dir, im_prefix + 'time={}'.format(int(time.time())) + ext)
save_im_path = os.path.join(
output_dir, im_prefix + 'time={}'.format(int(time.time())) + ext)
return save_im_path
......@@ -68,13 +69,19 @@ def draw_bounding_box_on_image(save_im_path, output_data):
for bbox in output_data:
# draw bouding box
if bbox['label'] == "MASK":
draw.line([(bbox['left'], bbox['top']), (bbox['left'], bbox['bottom']), (bbox['right'], bbox['bottom']),
(bbox['right'], bbox['top']), (bbox['left'], bbox['top'])],
draw.line([(bbox['left'], bbox['top']),
(bbox['left'], bbox['bottom']),
(bbox['right'], bbox['bottom']),
(bbox['right'], bbox['top']),
(bbox['left'], bbox['top'])],
width=2,
fill='green')
else:
draw.line([(bbox['left'], bbox['top']), (bbox['left'], bbox['bottom']), (bbox['right'], bbox['bottom']),
(bbox['right'], bbox['top']), (bbox['left'], bbox['top'])],
draw.line([(bbox['left'], bbox['top']),
(bbox['left'], bbox['bottom']),
(bbox['right'], bbox['bottom']),
(bbox['right'], bbox['top']),
(bbox['left'], bbox['top'])],
width=2,
fill='red')
# draw label
......@@ -88,13 +95,16 @@ def draw_bounding_box_on_image(save_im_path, output_data):
text_fill = (0)
draw.rectangle(
xy=(bbox['left'], bbox['top'] - (textsize_height + 5), bbox['left'] + textsize_width + 10, bbox['top'] - 3),
xy=(bbox['left'], bbox['top'] - (textsize_height + 5),
bbox['left'] + textsize_width + 10, bbox['top'] - 3),
fill=box_fill)
draw.text(xy=(bbox['left'], bbox['top'] - 15), text=text, fill=text_fill)
draw.text(
xy=(bbox['left'], bbox['top'] - 15), text=text, fill=text_fill)
image.save(save_im_path)
def postprocess(confidence_out, org_im, org_im_path, detected_faces, output_dir, visualization):
def postprocess(confidence_out, org_im, org_im_path, detected_faces, output_dir,
visualization):
"""
Postprocess output of network. one element at a time.
......
modules/image/face_detection/ultra_light_fast_generic_face_detector_1mb_320/README.md
浏览文件 @ 13cc2d57
## 命令行预测
# ultra_light_fast_generic_face_detector_1mb_320
```
hub run ultra_light_fast_generic_face_detector_1mb_320 --input_path "/PATH/TO/IMAGE"
```
|模型名称|ultra_light_fast_generic_face_detector_1mb_320|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|Ultra-Light-Fast-Generic-Face-Detector-1MB|
|数据集|WIDER FACE数据集|
|是否支持Fine-tuning|否|
|模型大小|2.6MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## API
```python
def face_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir=None,
confs_threshold=0.5):
```
## 一、模型基本信息
检测输入图片中的所有人脸位置
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131604811-bce29c3f-66f7-45cb-a388-d739368bfeb9.jpg" width='50%' hspace='10'/>
<br />
</p>
**参数**
- ### 模型介绍
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，当为 None 时，默认设为face\_detector\_320\_predict\_output；
* confs\_threshold (float): 置信度的阈值。
- Ultra-Light-Fast-Generic-Face-Detector-1MB是针对边缘计算设备或低算力设备(如用ARM推理)设计的实时超轻量级通用人脸检测模型，可以在低算力设备中如用ARM进行实时的通用场景的人脸检测推理。该PaddleHub Module的预训练数据集为WIDER FACE数据集，可支持预测，在预测时会将图片输入缩放为320 * 240。
**返回**
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 path, save\_path, data，其中：
* path 字段为原输入图片的路径（仅当使用paths输入时存在）；
* save\_path 字段为可视化图片的保存路径（仅当visualization=True时存在）；
* data 字段为检测结果，类型为list，list的每一个元素为dict，其中'left', 'right', 'top', 'bottom' 为人脸识别框，'confidence' 为此识别框置信度。
## 二、安装
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- ### 1、环境依赖
将模型保存到指定路径。
- paddlepaddle >= 1.6.2
**参数**
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
* dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- ### 2、安装
## 代码示例
- ```shell
$ hub install ultra_light_fast_generic_face_detector_1mb_320
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
```python
import paddlehub as hub
import cv2
## 三、模型API预测
face_detector = hub.Module(name="ultra_light_fast_generic_face_detector_1mb_320")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection((paths=['/PATH/TO/IMAGE'])
```
- ### 1、命令行预测
## 服务部署
- ```shell
$ hub run ultra_light_fast_generic_face_detector_1mb_320 --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 2、代码示例
## 第一步：启动PaddleHub Serving
- ```python
import paddlehub as hub
import cv2
运行启动命令：
```shell
$ hub serving start -m ultra_light_fast_generic_face_detector_1mb_320
```
face_detector = hub.Module(name="ultra_light_fast_generic_face_detector_1mb_320")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- ### 3、API
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ```python
def face_detection(images=None,
paths=None,
batch\_size=1,
use_gpu=False,
output_dir='face_detector_640_predict_output',
visualization=False,
confs_threshold=0.5)
```
## 第二步：发送预测请求
- 检测输入图片中的所有人脸位置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **参数**
```python
import requests
import json
import cv2
import base64
import paddlehub as hub
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- output\_dir (str): 图片的保存路径，默认设为 face\_detector\_640\_predict\_output；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- confs\_threshold (float): 置信度的阈值。
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
**NOTE:** paths和images两个参数选择其一进行提供数据
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ultra_light_fast_generic_face_detector_1mb_320"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- **返回**
# 打印预测结果
print(r.json()["results"])
```
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
- save\_path 字段为可视化图片的保存路径（仅当visualization=True时存在）
### 查看代码
https://github.com/Linzaer/Ultra-Light-Fast-Generic-Face-Detector-1MB
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
### 贡献者
- **参数**
[Jason](https://github.com/jiangjiajun)、[Channingss](https://github.com/Channingss)
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
### 依赖
paddlepaddle >= 1.6.2
## 四、服务部署
paddlehub >= 1.6.0
- PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m ultra_light_fast_generic_face_detector_1mb_320
```
- 这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ultra_light_fast_generic_face_detector_1mb_320"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.2
- ```shell
$ hub install ultra_light_fast_generic_face_detector_1mb_320==1.1.2
```
modules/image/face_detection/ultra_light_fast_generic_face_detector_1mb_640/README.md
浏览文件 @ 13cc2d57
## 命令行预测
# ultra_light_fast_generic_face_detector_1mb_640
```
hub run ultra_light_fast_generic_face_detector_1mb_640 --input_path "/PATH/TO/IMAGE"
```
|模型名称|ultra_light_fast_generic_face_detector_1mb_640|
| :--- | :---: |
|类别|图像 - 人脸检测|
|网络|Ultra-Light-Fast-Generic-Face-Detector-1MB|
|数据集|WIDER FACE数据集|
|是否支持Fine-tuning|否|
|模型大小|2.9MB|
|最新更新日期|2021-02-26|
|数据指标|-|
## API
```python
def face_detection(images=None,
paths=None,
batch_size=1,
use_gpu=False,
visualization=False,
output_dir=None,
confs_threshold=0.5):
```
## 一、模型基本信息
检测输入图片中的所有人脸位置
- ### 应用效果展示
- 样例结果示例：
<p align="center">
<img src="https://user-images.githubusercontent.com/22424850/131604811-bce29c3f-66f7-45cb-a388-d739368bfeb9.jpg" width='50%' hspace='10'/>
<br />
</p>
**参数**
- ### 模型介绍
* images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU；
* visualization (bool): 是否将识别结果保存为图片文件；
* output\_dir (str): 图片的保存路径，当为 None 时，默认设为face\_detector\_640\_predict\_output；
* confs\_threshold (float): 置信度的阈值。
- Ultra-Light-Fast-Generic-Face-Detector-1MB是针对边缘计算设备或低算力设备(如用ARM推理)设计的实时超轻量级通用人脸检测模型，可以在低算力设备中如用ARM进行实时的通用场景的人脸检测推理。该PaddleHub Module的预训练数据集为WIDER FACE数据集，可支持预测，在预测时会将图片输入缩放为640 * 480。
**返回**
* res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，关键字有 path, save\_path, data，其中：
* path 字段为原输入图片的路径（仅当使用paths输入时存在）；
* save\_path 字段为可视化图片的保存路径（仅当visualization=True时存在）；
* data 字段为检测结果，类型为list，list的每一个元素为dict，其中'left', 'right', 'top', 'bottom' 为人脸识别框，'confidence' 为此识别框置信度。
## 二、安装
```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- ### 1、环境依赖
将模型保存到指定路径。
- paddlepaddle >= 1.6.2
**参数**
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
* dirname: 存在模型的目录名称
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
- ### 2、安装
## 预测代码示例
- ```shell
$ hub install ultra_light_fast_generic_face_detector_1mb_640
```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
| [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
```python
import paddlehub as hub
import cv2
## 三、模型API预测
face_detector = hub.Module(name="ultra_light_fast_generic_face_detector_1mb_640")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection((paths=['/PATH/TO/IMAGE'])
```
- ### 1、命令行预测
## 服务部署
- ```shell
$ hub run ultra_light_fast_generic_face_detector_1mb_640 --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现人脸检测模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 2、代码示例
## 第一步：启动PaddleHub Serving
- ```python
import paddlehub as hub
import cv2
运行启动命令：
```shell
$ hub serving start -m ultra_light_fast_generic_face_detector_1mb_640
```
face_detector = hub.Module(name="ultra_light_fast_generic_face_detector_1mb_640")
result = face_detector.face_detection(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = face_detector.face_detection(paths=['/PATH/TO/IMAGE'])
```
这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- ### 3、API
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ```python
def face_detection(images=None,
paths=None,
batch\_size=1,
use_gpu=False,
output_dir='face_detector_640_predict_output',
visualization=False,
confs_threshold=0.5)
```
## 第二步：发送预测请求
- 检测输入图片中的所有人脸位置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- **参数**
```python
import requests
import json
import cv2
import base64
import paddlehub as hub
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]，BGR格式；<br/>
- paths (list\[str\]): 图片的路径；<br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；<br/>
- output\_dir (str): 图片的保存路径，默认设为 face\_detector\_640\_predict\_output；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/>
- confs\_threshold (float): 置信度的阈值。
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
**NOTE:** paths和images两个参数选择其一进行提供数据
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ultra_light_fast_generic_face_detector_1mb_640"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
- **返回**
# 打印预测结果
print(r.json()["results"])
```
- res (list\[dict\]): 识别结果的列表，列表中每一个元素为 dict，各字段为:
- path (str): 原输入图片的路径
- data (list): 检测结果，list的每一个元素为 dict，各字段为:
- confidence (float): 识别的置信度
- left (int): 边界框的左上角x坐标
- top (int): 边界框的左上角y坐标
- right (int): 边界框的右下角x坐标
- bottom (int): 边界框的右下角y坐标
- save\_path 字段为可视化图片的保存路径（仅当visualization=True时存在）
### 查看代码
https://github.com/Linzaer/Ultra-Light-Fast-Generic-Face-Detector-1MB
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- 将模型保存到指定路径。
### 贡献者
- **参数**
[Jason](https://github.com/jiangjiajun)、[Channingss](https://github.com/Channingss)
- dirname: 存在模型的目录名称； <br/>
- model\_filename: 模型文件名称，默认为\_\_model\_\_； <br/>
- params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)；<br/>
- combined: 是否将参数保存到统一的一个文件中。
### 依赖
paddlepaddle >= 1.6.2
## 四、服务部署
paddlehub >= 1.6.0
- PaddleHub Serving可以部署一个在线人脸检测服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m ultra_light_fast_generic_face_detector_1mb_640
```
- 这样就完成了一个人脸检测服务化API的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/ultra_light_fast_generic_face_detector_1mb_640"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.2
- ```shell
$ hub install ultra_light_fast_generic_face_detector_1mb_640==1.1.2
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或