+ 
+
+
-
+
-## PaddleDetection Python Interface
+## PaddleDetection Python Interface
```python
fastdeploy.vision.detection.PPYOLOE(model_file, params_file, config_file, runtime_option=None, model_format=ModelFormat.PADDLE)
@@ -52,7 +56,7 @@ PaddleDetection model loading and initialization, among which model_file and par
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path
> * **config_file**(str): Inference configuration yaml file path
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default. (use the default configuration)
diff --git a/examples/vision/detection/yolov5/cpp/README.md b/examples/vision/detection/yolov5/cpp/README.md
index 1b5e9ad86..74f182088 100755
--- a/examples/vision/detection/yolov5/cpp/README.md
+++ b/examples/vision/detection/yolov5/cpp/README.md
@@ -12,12 +12,12 @@ Taking the CPU inference on Linux as an example, the compilation test can be com
```bash
mkdir build
cd build
-# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz
tar xvf fastdeploy-linux-x64-x.x.x.tgz
cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x
make -j
-# Download the official converted yolov5 Paddle model files and test images
+# Download the official converted yolov5 Paddle model files and test images
wget https://bj.bcebos.com/paddlehub/fastdeploy/yolov5s_infer.tar
tar -xvf yolov5s_infer.tar
wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/000000014439.jpg
@@ -31,11 +31,13 @@ wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/0000000
./infer_paddle_demo yolov5s_infer 000000014439.jpg 2
# KunlunXin XPU inference
./infer_paddle_demo yolov5s_infer 000000014439.jpg 3
+# Huawei Ascend Inference
+./infer_paddle_demo yolov5s_infer 000000014439.jpg 4
```
The above steps apply to the inference of Paddle models. If you want to conduct the inference of ONNX models, follow these steps:
```bash
-# 1. Download the official converted yolov5 ONNX model files and test images
+# 1. Download the official converted yolov5 ONNX model files and test images
wget https://bj.bcebos.com/paddlehub/fastdeploy/yolov5s.onnx
wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/000000014439.jpg
@@ -53,7 +55,7 @@ The visualized result after running is as follows
The above command works for Linux or MacOS. For SDK use-pattern in Windows, refer to:
- [How to use FastDeploy C++ SDK in Windows](../../../../../docs/cn/faq/use_sdk_on_windows.md)
-## YOLOv5 C++ Interface
+## YOLOv5 C++ Interface
### YOLOv5 Class
@@ -69,7 +71,7 @@ YOLOv5 model loading and initialization, among which model_file is the exported
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path. Merely passing an empty string when the model is in ONNX format
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
> * **model_format**(ModelFormat): Model format. ONNX format by default
diff --git a/examples/vision/detection/yolov5/python/README.md b/examples/vision/detection/yolov5/python/README.md
index 0e815dd09..23b6665c7 100755
--- a/examples/vision/detection/yolov5/python/README.md
+++ b/examples/vision/detection/yolov5/python/README.md
@@ -22,17 +22,19 @@ wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/0000000
python infer.py --model yolov5s_infer --image 000000014439.jpg --device cpu
# GPU inference
python infer.py --model yolov5s_infer --image 000000014439.jpg --device gpu
-# TensorRT inference on GPU
+# TensorRT inference on GPU
python infer.py --model yolov5s_infer --image 000000014439.jpg --device gpu --use_trt True
# KunlunXin XPU inference
python infer.py --model yolov5s_infer --image 000000014439.jpg --device kunlunxin
+# Huawei Ascend Inference
+python infer.py --model yolov5s_infer --image 000000014439.jpg --device ascend
```
The visualized result after running is as follows
-## YOLOv5 Python Interface
+## YOLOv5 Python Interface
```python
fastdeploy.vision.detection.YOLOv5(model_file, params_file=None, runtime_option=None, model_format=ModelFormat.ONNX)
@@ -42,7 +44,7 @@ YOLOv5 model loading and initialization, among which model_file is the exported
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path. No need to set when the model is in ONNX format
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
> * **model_format**(ModelFormat): Model format. ONNX format by default
diff --git a/examples/vision/detection/yolov6/python/README.md b/examples/vision/detection/yolov6/python/README.md
index 789df9747..04bc9f345 100755
--- a/examples/vision/detection/yolov6/python/README.md
+++ b/examples/vision/detection/yolov6/python/README.md
@@ -23,6 +23,9 @@ python infer_paddle_model.py --model yolov6s_infer --image 000000014439.jpg --d
python infer_paddle_model.py --model yolov6s_infer --image 000000014439.jpg --device gpu
# KunlunXin XPU inference
python infer_paddle_model.py --model yolov6s_infer --image 000000014439.jpg --device kunlunxin
+# Huawei Ascend Inference
+python infer_paddle_model.py --model yolov6s_infer --image 000000014439.jpg --device ascend
+
```
If you want to verify the inference of ONNX models, refer to the following command:
```bash
@@ -34,7 +37,7 @@ wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/0000000
python infer.py --model yolov6s.onnx --image 000000014439.jpg --device cpu
# GPU inference
python infer.py --model yolov6s.onnx --image 000000014439.jpg --device gpu
-# TensorRT inference on GPU
+# TensorRT inference on GPU
python infer.py --model yolov6s.onnx --image 000000014439.jpg --device gpu --use_trt True
```
@@ -42,7 +45,7 @@ The visualized result after running is as follows
-## YOLOv6 Python Interface
+## YOLOv6 Python Interface
```python
fastdeploy.vision.detection.YOLOv6(model_file, params_file=None, runtime_option=None, model_format=ModelFormat.ONNX)
@@ -52,7 +55,7 @@ YOLOv6 model loading and initialization, among which model_file is the exported
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path. No need to set when the model is in ONNX format
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
> * **model_format**(ModelFormat): Model format. ONNX format by default
diff --git a/examples/vision/detection/yolov7/cpp/README.md b/examples/vision/detection/yolov7/cpp/README.md
index e36875e0c..a3abd6d19 100755
--- a/examples/vision/detection/yolov7/cpp/README.md
+++ b/examples/vision/detection/yolov7/cpp/README.md
@@ -1,7 +1,7 @@
English | [简体中文](README_CN.md)
# YOLOv7 C++ Deployment Example
-This directory provides examples that `infer.cc` fast finishes the deployment of YOLOv7 on CPU/GPU and GPU accelerated by TensorRT.
+This directory provides examples that `infer.cc` fast finishes the deployment of YOLOv7 on CPU/GPU and GPU accelerated by TensorRT.
Before deployment, two steps require confirmation
@@ -13,7 +13,7 @@ Taking the CPU inference on Linux as an example, the compilation test can be com
```bash
mkdir build
cd build
-# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz
tar xvf fastdeploy-linux-x64-x.x.x.tgz
cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x
@@ -29,10 +29,12 @@ wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/0000000
./infer_paddle_model_demo yolov7_infer 000000014439.jpg 1
# KunlunXin XPU inference
./infer_paddle_model_demo yolov7_infer 000000014439.jpg 2
+# Huawei Ascend inference
+./infer_paddle_model_demo yolov7_infer 000000014439.jpg 3
```
If you want to verify the inference of ONNX models, refer to the following command:
```bash
-# Download the official converted yolov7 ONNX model files and test images
+# Download the official converted yolov7 ONNX model files and test images
wget https://bj.bcebos.com/paddlehub/fastdeploy/yolov7.onnx
wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/000000014439.jpg
@@ -52,7 +54,7 @@ The visualized result after running is as follows
The above command works for Linux or MacOS. For SDK use-pattern in Windows, refer to:
- [How to use FastDeploy C++ SDK in Windows](../../../../../docs/en/faq/use_sdk_on_windows.md)
-## YOLOv7 C++ Interface
+## YOLOv7 C++ Interface
### YOLOv7 Class
@@ -68,7 +70,7 @@ YOLOv7 model loading and initialization, among which model_file is the exported
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path. Merely passing an empty string when the model is in ONNX format
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
> * **model_format**(ModelFormat): Model format. ONNX format by default
@@ -86,7 +88,7 @@ YOLOv7 model loading and initialization, among which model_file is the exported
> **Parameter**
>
> > * **im**: Input images in HWC or BGR format
-> > * **result**: Detection results, including detection box and confidence of each box. Refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for DetectionResult
+> > * **result**: Detection results, including detection box and confidence of each box. Refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for DetectionResult
> > * **conf_threshold**: Filtering threshold of detection box confidence
> > * **nms_iou_threshold**: iou threshold during NMS processing
diff --git a/examples/vision/detection/yolov8/cpp/README.md b/examples/vision/detection/yolov8/cpp/README.md
new file mode 100644
index 000000000..ca9462b0c
--- /dev/null
+++ b/examples/vision/detection/yolov8/cpp/README.md
@@ -0,0 +1,90 @@
+English | [简体中文](README_CN.md)
+# YOLOv8 C++ Deployment Example
+
+This directory provides the example that `infer.cc` fast finishes the deployment of YOLOv8 on CPU/GPU and GPU through TensorRT.
+
+Two steps before deployment
+
+- 1. Software and hardware should meet the requirements. Please refer to [FastDeploy Environment Requirements](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+- 2. Download the precompiled deployment library and samples code based on your development environment. Refer to [FastDeploy Precompiled Library](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+
+Taking the CPU inference on Linux as an example, FastDeploy version 1.0.3 or above (x.x.x>=1.0.3) is required to support this model.
+
+```bash
+mkdir build
+cd build
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz
+tar xvf fastdeploy-linux-x64-x.x.x.tgz
+cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x
+make -j
+
+# 1. Download the official converted YOLOv8 ONNX model files and test images
+wget https://bj.bcebos.com/paddlehub/fastdeploy/yolov8s.onnx
+wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/000000014439.jpg
+
+# CPU inference
+./infer_demo yolov8s.onnx 000000014439.jpg 0
+# GPU inference
+./infer_demo yolov8s.onnx 000000014439.jpg 1
+# TensorRT inference on GPU
+./infer_demo yolov8s.onnx 000000014439.jpg 2
+```
+The visualized result is as follows
+
+
+
+he above command works for Linux or MacOS. For SDK in Windows, refer to:
+- [How to use FastDeploy C++ SDK in Windows](../../../../../docs/cn/faq/use_sdk_on_windows.md)
+
+If you use Huawei Ascend NPU deployment, refer to the following document to initialize the deployment environment:
+- [How to use Huawei Ascend NPU deployment](../../../../../docs/cn/faq/use_sdk_on_ascend.md)
+
+## YOLOv8 C++ Interface
+
+### YOLOv8
+
+```c++
+fastdeploy::vision::detection::YOLOv8(
+ const string& model_file,
+ const string& params_file = "",
+ const RuntimeOption& runtime_option = RuntimeOption(),
+ const ModelFormat& model_format = ModelFormat::ONNX)
+```
+
+YOLOv8 model loading and initialization, among which model_file is the exported ONNX model format
+
+**Parameter**
+
+> * **model_file**(str): Model file path
+> * **params_file**(str): Parameter file path. Merely passing an empty string when the model is in ONNX format
+> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
+> * **model_format**(ModelFormat): Model format. ONNX format by default
+
+#### Predict function
+
+> ```c++
+> YOLOv8::Predict(cv::Mat* im, DetectionResult* result)
+> ```
+>
+> Model prediction interface. Input images and output detection results
+>
+> **Parameter**
+>
+> > * **im**: Input images in HWC or BGR format
+> > * **result**: Detection results, including detection box and confidence of each box. Refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for DetectionResult.
+
+### Class Member Variable
+#### Pre-processing Parameter
+Users can modify the following preprocessing parameters based on actual needs to change the final inference and deployment results
+
+> > * **size**(vector<int>): This parameter changes the resize used during preprocessing, containing two integer elements for [width, height] with default value [640, 640]
+> > * **padding_value**(vector<float>): This parameter is used to change the padding value of images during resize, containing three floating-point elements that represent the value of three channels. Default value [114, 114, 114]
+> > * **is_no_pad**(bool): Specify whether to resize the image through padding. `is_no_pad=ture` represents no paddling. Default `is_no_pad=false`
+> > * **is_mini_pad**(bool): This parameter sets the width and height of the image after resize to the value nearest to the `size` member variable and to the point where the padded pixel size is divisible by the `stride` member variable. Default `is_mini_pad=false`
+> > * **stride**(int): Used with the `stris_mini_pad` member variable. Default `stride=32`
+
+- [Model Description](../../)
+- [Python Deployment](../python)
+- [Vision Model Prediction Results](../../../../../docs/api/vision_results/)
+- [How to switch the backend engine](../../../../../docs/cn/faq/how_to_change_backend.md)
diff --git a/examples/vision/detection/yolov8/cpp/README_CN.md b/examples/vision/detection/yolov8/cpp/README_CN.md
index d1d87ccc5..0545df665 100644
--- a/examples/vision/detection/yolov8/cpp/README_CN.md
+++ b/examples/vision/detection/yolov8/cpp/README_CN.md
@@ -81,7 +81,7 @@ YOLOv8模型加载和初始化，其中model_file为导出的ONNX模型格式。
> > * **size**(vector<int>): 通过此参数修改预处理过程中resize的大小，包含两个整型元素，表示[width, height], 默认值为[640, 640]
> > * **padding_value**(vector<float>): 通过此参数可以修改图片在resize时候做填充(padding)的值, 包含三个浮点型元素, 分别表示三个通道的值, 默认值为[114, 114, 114]
> > * **is_no_pad**(bool): 通过此参数让图片是否通过填充的方式进行resize, `is_no_pad=ture` 表示不使用填充的方式，默认值为`is_no_pad=false`
-> > * **is_mini_pad**(bool): 通过此参数可以将resize之后图像的宽高这是为最接近`size`成员变量的值, 并且满足填充的像素大小是可以被`stride`成员变量整除的。默认值为`is_mini_pad=false`
+> > * **is_mini_pad**(bool): 通过此参数可以将resize之后图像的宽高设置为最接近`size`成员变量的值, 并且满足填充的像素大小是可以被`stride`成员变量整除的。默认值为`is_mini_pad=false`
> > * **stride**(int): 配合`stris_mini_pad`成员变量使用, 默认值为`stride=32`
- [模型介绍](../../)
diff --git a/examples/vision/detection/yolov8/python/README.md b/examples/vision/detection/yolov8/python/README.md
new file mode 100644
index 000000000..8922147aa
--- /dev/null
+++ b/examples/vision/detection/yolov8/python/README.md
@@ -0,0 +1,78 @@
+English | [简体中文](README_CN.md)
+# YOLOv8 Python Deployment Example
+
+Two steps before deployment
+
+- 1. Software and hardware should meet the requirements. Please refer to [FastDeploy Environment Requirements](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+- 2. Install FastDeploy Python whl. Refer to [FastDeploy Python Installation](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+
+This directory provides the example that `infer.py` fast finishes the deployment of YOLOv8 on CPU/GPU and GPU through TensorRT. The script is as follows
+
+```bash
+# Download the example code for deployment
+git clone https://github.com/PaddlePaddle/FastDeploy.git
+cd examples/vision/detection/yolov8/python/
+
+# Download yolov8 model files and test images
+wget https://bj.bcebos.com/paddlehub/fastdeploy/yolov8.onnx
+wget https://gitee.com/paddlepaddle/PaddleDetection/raw/release/2.4/demo/000000014439.jpg
+
+# CPU inference
+python infer.py --model yolov8.onnx --image 000000014439.jpg --device cpu
+# GPU inference
+python infer.py --model yolov8.onnx --image 000000014439.jpg --device gpu
+# TensorRT inference on GPU
+python infer.py --model yolov8.onnx --image 000000014439.jpg --device gpu --use_trt True
+```
+
+The visualized result is as follows
+
+
+
+## YOLOv8 Python Interface
+
+```python
+fastdeploy.vision.detection.YOLOv8(model_file, params_file=None, runtime_option=None, model_format=ModelFormat.ONNX)
+```
+
+YOLOv8 model loading and initialization, among which model_file is the exported ONNX model format
+
+**Parameter**
+
+> * **model_file**(str): Model file path
+> * **params_file**(str): Parameter file path. No need to set when the model is in ONNX format
+> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
+> * **model_format**(ModelFormat): Model format. ONNX format by default
+
+### predict function
+
+> ```python
+> YOLOv8.predict(image_data)
+> ```
+>
+> Model prediction interface. Input images and output detection results
+>
+> **Parameter**
+>
+> > * **image_data**(np.ndarray): Input data in HWC or BGR format
+
+> **Return**
+>
+> > Return the `fastdeploy.vision.DetectionResult`structure, refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for its description
+
+### Class Member Property
+#### Pre-processing Parameter
+Users can modify the following preprocessing parameters based on actual needs to change the final inference and deployment results
+
+> > * **size**(list[int]): This parameter changes the resize used during preprocessing, containing two integer elements for [width, height] with default value [640, 640]
+> > * **padding_value**(list[float]): This parameter is used to change the padding value of images during resize, containing three floating-point elements that represent the value of three channels. Default value [114, 114, 114]
+> > * **is_no_pad**(bool): Specify whether to resize the image through padding. `is_no_pad=True` represents no paddling. Default `is_no_pad=False`
+> > * **is_mini_pad**(bool): This parameter sets the width and height of the image after resize to the value nearest to the `size` member variable and to the point where the padded pixel size is divisible by the `stride` member variable. Default `is_mini_pad=False`
+> > * **stride**(int): Used with the `stris_mini_padide` member variable. Default `stride=32`
+
+## Other Documents
+
+- [YOLOv8 Model Description](..)
+- [YOLOv8 C++ Deployment](../cpp)
+- [Model Prediction Results](../../../../../docs/api/vision_results/)
+- [How to switch the backend engine](../../../../../docs/cn/faq/how_to_change_backend.md)
diff --git a/examples/vision/detection/yolov8/python/README_CN.md b/examples/vision/detection/yolov8/python/README_CN.md
index ae19ec727..8b2877372 100644
--- a/examples/vision/detection/yolov8/python/README_CN.md
+++ b/examples/vision/detection/yolov8/python/README_CN.md
@@ -50,7 +50,7 @@ YOLOv8模型加载和初始化，其中model_file为导出的ONNX模型格式
> YOLOv8.predict(image_data)
> ```
>
-> 模型预测结口，输入图像直接输出检测结果。
+> 模型预测接口，输入图像直接输出检测结果。
>
> **参数**
>
diff --git a/examples/vision/facedet/blazeface/README.md b/examples/vision/facedet/blazeface/README.md
new file mode 100644
index 000000000..98c430412
--- /dev/null
+++ b/examples/vision/facedet/blazeface/README.md
@@ -0,0 +1,34 @@
+English | [简体中文](README_CN.md)
+# BlazeFace Ready-to-deploy Model
+
+- BlazeFace deployment model implementation comes from [BlazeFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection),and [Pre-training model based on WiderFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection)
+ - （1）Provided in [Official library
+](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/tools) *.params, could deploy after operation [export_model.py](#Export PADDLE model);
+ - （2）Developers can train BlazeFace model based on their own data according to [export_model. py](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/tools/export_model.py)After exporting the model, complete the deployment。
+
+## Export PADDLE model
+
+Visit [BlazeFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection) Github library, download and install according to the instructions, download the `. yml` and `. params` model parameters, and use` export_ Model. py `gets the` pad `model file`. yml,. pdiparams,. pdmodel `.
+
+
+* Download BlazeFace model parameter file
+
+|Network structure | input size | number of pictures/GPU | learning rate strategy | Easy/Media/Hard Set | prediction delay (SD855) | model size (MB) | download | configuration file|
+|:------------:|:--------:|:----:|:-------:|:-------:|:---------:|:----------:|:---------:|:--------:|
+| BlazeFace | 640 | 8 | 1000e | 0.885 / 0.855 / 0.731 | - | 0.472 |[Download link](https://paddledet.bj.bcebos.com/models/blazeface_1000e.pdparams) | [Config file](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection/blazeface_1000e.yml) |
+| BlazeFace-FPN-SSH | 640 | 8 | 1000e | 0.907 / 0.883 / 0.793 | - | 0.479 |[Download link](https://paddledet.bj.bcebos.com/models/blazeface_fpn_ssh_1000e.pdparams) | [Config file](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection/blazeface_fpn_ssh_1000e.yml) |
+
+* Export paddle-format file
+ ```bash
+ python tools/export_model.py -c configs/face_detection/blazeface_1000e.yml -o weights=blazeface_1000e.pdparams --export_serving_model=True
+ ```
+
+## Detailed Deployment Tutorials
+
+- [Python Deployment](python)
+- [C++ Deployment](cpp)
+
+
+## Release Note
+
+- This tutorial and related code are written based on [BlazeFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection)
diff --git a/examples/vision/facedet/blazeface/README_CN.md b/examples/vision/facedet/blazeface/README_CN.md
new file mode 100644
index 000000000..f3957c0ca
--- /dev/null
+++ b/examples/vision/facedet/blazeface/README_CN.md
@@ -0,0 +1,31 @@
+# BlazeFace准备部署模型
+
+- BlazeFace部署模型实现来自[BlazeFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection),和[基于WiderFace的预训练模型](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection)
+ - （1）[官方库](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/tools)中提供的*.params,通过[export_model.py](#导出PADDLE模型)操作后，可进行部署；
+ - （2）开发者基于自己数据训练的BlazeFace模型，可按照[export_model.py](https://github.com/PaddlePaddle/PaddleDetection/blob/release/2.5/tools/export_model.py)导出模型后，完成部署。
+
+## 导出PADDLE模型
+
+访问[BlazeFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection)github库，按照指引下载安装，下载`.yml`和`.params` 模型参数，利用 `export_model.py` 得到`paddle`模型文件`.yml, .pdiparams, .pdmodel`。
+
+* 下载BlazeFace模型参数文件
+
+| 网络结构 | 输入尺寸 | 图片个数/GPU | 学习率策略 | Easy/Medium/Hard Set | 预测时延（SD855）| 模型大小(MB) | 下载 | 配置文件 |
+|:------------:|:--------:|:----:|:-------:|:-------:|:---------:|:----------:|:---------:|:--------:|
+| BlazeFace | 640 | 8 | 1000e | 0.885 / 0.855 / 0.731 | - | 0.472 |[下载链接](https://paddledet.bj.bcebos.com/models/blazeface_1000e.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection/blazeface_1000e.yml) |
+| BlazeFace-FPN-SSH | 640 | 8 | 1000e | 0.907 / 0.883 / 0.793 | - | 0.479 |[下载链接](https://paddledet.bj.bcebos.com/models/blazeface_fpn_ssh_1000e.pdparams) | [配置文件](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection/blazeface_fpn_ssh_1000e.yml) |
+
+* 导出paddle格式文件
+ ```bash
+ python tools/export_model.py -c configs/face_detection/blazeface_1000e.yml -o weights=blazeface_1000e.pdparams --export_serving_model=True
+ ```
+
+## 详细部署文档
+
+- [Python部署](python)
+- [C++部署](cpp)
+
+
+## 版本说明
+
+- 本版本文档和代码基于[BlazeFace](https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.5/configs/face_detection) 编写
diff --git a/examples/vision/facedet/blazeface/cpp/CMakeLists.txt b/examples/vision/facedet/blazeface/cpp/CMakeLists.txt
new file mode 100644
index 000000000..4ec242a44
--- /dev/null
+++ b/examples/vision/facedet/blazeface/cpp/CMakeLists.txt
@@ -0,0 +1,14 @@
+PROJECT(infer_demo C CXX)
+CMAKE_MINIMUM_REQUIRED (VERSION 3.10)
+
+# Specifies the path to the fastdeploy library after you have downloaded it
+option(FASTDEPLOY_INSTALL_DIR "Path of downloaded fastdeploy sdk.")
+
+include(../../../../../FastDeploy.cmake)
+
+# Add the FastDeploy dependency header
+include_directories(${FASTDEPLOY_INCS})
+
+add_executable(infer_demo ${PROJECT_SOURCE_DIR}/infer.cc)
+# Add the FastDeploy library dependency
+target_link_libraries(infer_demo ${FASTDEPLOY_LIBS})
diff --git a/examples/vision/facedet/blazeface/cpp/README.md b/examples/vision/facedet/blazeface/cpp/README.md
new file mode 100644
index 000000000..dac9fc443
--- /dev/null
+++ b/examples/vision/facedet/blazeface/cpp/README.md
@@ -0,0 +1,78 @@
+English | [简体中文](README_CN.md)
+# BlazeFace C++ Deployment Example
+
+This directory provides examples that `infer.cc` fast finishes the deployment of BlazeFace on CPU/GPU。
+
+Before deployment, two steps require confirmation
+
+- 1. Software and hardware should meet the requirements. Please refer to [FastDeploy Environment Requirements](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+- 2. Download the precompiled deployment library and samples code according to your development environment. Refer to [FastDeploy Precompiled Library](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+
+Taking the CPU inference on Linux as an example, the compilation test can be completed by executing the following command in this directory.
+
+```bash
+mkdir build
+cd build
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz # x.x.x >= 1.0.4
+tar xvf fastdeploy-linux-x64-x.x.x.tgz # x.x.x >= 1.0.4
+cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x # x.x.x >= 1.0.4
+make -j
+
+#Download the official converted YOLOv7Face model files and test images
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/blzeface-1000e.tgz
+
+#Use blazeface-1000e model
+# CPU inference
+./infer_demo blazeface-1000e/ test_lite_face_detector_3.jpg 0
+# GPU Inference
+./infer_demo blazeface-1000e/ test_lite_face_detector_3.jpg 1
+```
+
+The visualized result after running is as follows
+
+
+
+The above command works for Linux or MacOS. For SDK use-pattern in Windows, refer to:
+- [How to use FastDeploy C++ SDK in Windows](../../../../../docs/cn/faq/use_sdk_on_windows.md)
+
+## BlazeFace C++ Interface
+
+### BlazeFace Class
+
+```c++
+fastdeploy::vision::facedet::BlazeFace(
+ const string& model_file,
+ const string& params_file = "",
+ const string& config_file = "",
+ const RuntimeOption& runtime_option = RuntimeOption(),
+ const ModelFormat& model_format = ModelFormat::PADDLE)
+```
+
+BlazeFace model loading and initialization, among which model_file is the exported PADDLE model format
+
+**Parameter**
+
+> * **model_file**(str): Model file path
+> * **params_file**(str): Parameter file path. Only passing an empty string when the model is in PADDLE format
+> * **config_file**(str): Config file path. Only passing an empty string when the model is in PADDLE format
+> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
+> * **model_format**(ModelFormat): Model format. PADDLE format by default
+
+#### Predict Function
+
+> ```c++
+> BlazeFace::Predict(cv::Mat& im, FaceDetectionResult* result)
+> ```
+>
+> Model prediction interface. Input images and output detection results.
+>
+> **Parameter**
+>
+> > * **im**: Input images in HWC or BGR format
+> > * **result**: Detection results, including detection box and confidence of each box. Refer to [Vision Model Prediction Result](../../../../../docs/api/vision_results/) for FaceDetectionResult
+
+- [Model Description](../../)
+- [Python Deployment](../python)
+- [Vision Model Prediction Results](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/blazeface/cpp/README_CN.md b/examples/vision/facedet/blazeface/cpp/README_CN.md
new file mode 100644
index 000000000..12b67b6e5
--- /dev/null
+++ b/examples/vision/facedet/blazeface/cpp/README_CN.md
@@ -0,0 +1,77 @@
+[English](README.md) | 简体中文
+# BlazeFace C++部署示例
+
+本目录下提供`infer.cc`快速完成BlazeFace在CPU/GPU部署的示例。
+
+在部署前，需确认以下两个步骤
+
+- 1. 软硬件环境满足要求，参考[FastDeploy环境要求](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+- 2. 根据开发环境，下载预编译部署库和samples代码，参考[FastDeploy预编译库](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+
+以Linux上CPU推理为例，在本目录执行如下命令即可完成编译测试
+
+```bash
+mkdir build
+cd build
+# 下载FastDeploy预编译库，用户可在上文提到的`FastDeploy预编译库`中自行选择合适的版本使用
+wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz # x.x.x >= 1.0.4
+tar xvf fastdeploy-linux-x64-x.x.x.tgz # x.x.x >= 1.0.4
+cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x # x.x.x >= 1.0.4
+make -j
+
+#下载官方转换好的BlazeFace模型文件和测试图片
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/blzeface-1000e.tgz
+
+#使用blazeface-1000e模型
+# CPU推理
+./infer_demo blazeface-1000e/ test_lite_face_detector_3.jpg 0
+# GPU推理
+./infer_demo blazeface-1000e/ test_lite_face_detector_3.jpg 1
+
+运行完成可视化结果如下图所示
+
+
+
+以上命令只适用于Linux或MacOS, Windows下SDK的使用方式请参考:
+- [如何在Windows中使用FastDeploy C++ SDK](../../../../../docs/cn/faq/use_sdk_on_windows.md)
+
+## BlazeFace C++接口
+
+### BlazeFace类
+
+```c++
+fastdeploy::vision::facedet::BlazeFace(
+ const string& model_file,
+ const string& params_file = "",
+ const string& config_file = "",
+ const RuntimeOption& runtime_option = RuntimeOption(),
+ const ModelFormat& model_format = ModelFormat::PADDLE)
+```
+
+BlazeFace模型加载和初始化，其中model_file为导出的PADDLE模型格式。
+
+**参数**
+
+> * **model_file**(str): 模型文件路径
+> * **params_file**(str): 参数文件路径，当模型格式为ONNX时，此参数传入空字符串即可
+> * **config_file**(str): 配置文件路径，当模型格式为ONNX时，此参数传入空字符串即可
+> * **runtime_option**(RuntimeOption): 后端推理配置，默认为None，即采用默认配置
+> * **model_format**(ModelFormat): 模型格式，默认为PADDLE格式
+
+#### Predict函数
+
+> ```c++
+> BlazeFace::Predict(cv::Mat& im, FaceDetectionResult* result)
+> ```
+>
+> 模型预测接口，输入图像直接输出检测结果。
+>
+> **参数**
+>
+> > * **im**: 输入图像，注意需为HWC，BGR格式
+> > * **result**: 检测结果，包括检测框，各个框的置信度, FaceDetectionResult说明参考[视觉模型预测结果](../../../../../docs/api/vision_results/)
+
+- [模型介绍](../../)
+- [Python部署](../python)
+- [视觉模型预测结果](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/blazeface/cpp/infer.cc b/examples/vision/facedet/blazeface/cpp/infer.cc
new file mode 100644
index 000000000..c4304f45f
--- /dev/null
+++ b/examples/vision/facedet/blazeface/cpp/infer.cc
@@ -0,0 +1,94 @@
+// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fastdeploy/vision.h"
+
+#ifdef WIN32
+const char sep = '\\';
+#else
+const char sep = '/';
+#endif
+
+void CpuInfer(const std::string& model_dir, const std::string& image_file) {
+ auto model_file = model_dir + sep + "model.pdmodel";
+ auto params_file = model_dir + sep + "model.pdiparams";
+ auto config_file = model_dir + sep + "infer_cfg.yml";
+ auto option = fastdeploy::RuntimeOption();
+ option.UseCpu();
+ auto model = fastdeploy::vision::facedet::BlazeFace(
+ model_file, params_file, config_file, option);
+ if (!model.Initialized()) {
+ std::cerr << "Failed to initialize." << std::endl;
+ return;
+ }
+
+ auto im = cv::imread(image_file);
+
+ fastdeploy::vision::FaceDetectionResult res;
+ if (!model.Predict(im, &res)) {
+ std::cerr << "Failed to predict." << std::endl;
+ return;
+ }
+ std::cout << res.Str() << std::endl;
+
+ auto vis_im = fastdeploy::vision::VisFaceDetection(im, res);
+ cv::imwrite("vis_result.jpg", vis_im);
+ std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
+}
+
+void GpuInfer(const std::string& model_dir, const std::string& image_file) {
+ auto model_file = model_dir + sep + "model.pdmodel";
+ auto params_file = model_dir + sep + "model.pdiparams";
+ auto config_file = model_dir + sep + "infer_cfg.yml";
+ auto option = fastdeploy::RuntimeOption();
+ option.UseGpu();
+ auto model = fastdeploy::vision::facedet::BlazeFace(
+ model_file, params_file, config_file, option);
+ if (!model.Initialized()) {
+ std::cerr << "Failed to initialize." << std::endl;
+ return;
+ }
+
+ auto im = cv::imread(image_file);
+
+ fastdeploy::vision::FaceDetectionResult res;
+ if (!model.Predict(im, &res)) {
+ std::cerr << "Failed to predict." << std::endl;
+ return;
+ }
+ std::cout << res.Str() << std::endl;
+
+ auto vis_im = fastdeploy::vision::VisFaceDetection(im, res);
+ cv::imwrite("vis_result.jpg", vis_im);
+ std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
+}
+
+int main(int argc, char* argv[]) {
+ if (argc < 4) {
+ std::cout << "Usage: infer_demo path/to/model path/to/image run_option, "
+ "e.g ./infer_model yolov5s-face.onnx ./test.jpeg 0"
+ << std::endl;
+ std::cout << "The data type of run_option is int, 0: run with cpu; 1: run "
+ "with gpu; 2: run with gpu and use tensorrt backend."
+ << std::endl;
+ return -1;
+ }
+
+ if (std::atoi(argv[3]) == 0) {
+ CpuInfer(argv[1], argv[2]);
+ } else if (std::atoi(argv[3]) == 1) {
+ GpuInfer(argv[1], argv[2]);
+ }
+ return 0;
+}
diff --git a/examples/vision/facedet/blazeface/python/README.md b/examples/vision/facedet/blazeface/python/README.md
new file mode 100644
index 000000000..b645317cd
--- /dev/null
+++ b/examples/vision/facedet/blazeface/python/README.md
@@ -0,0 +1,68 @@
+English | [简体中文](README_CN.md)
+# BlazeFace Python Deployment Example
+
+Before deployment, two steps require confirmation
+
+- 1. Software and hardware should meet the requirements. Please refer to [FastDeploy Environment Requirements](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+- 2. Install FastDeploy Python whl package. Refer to [FastDeploy Python Installation](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+
+This directory provides examples that `infer.py` fast finishes the deployment of BlazeFace on CPU/GPU.
+
+```bash
+# Download the example code for deployment
+git clone https://github.com/PaddlePaddle/FastDeploy.git
+cd examples/vision/facedet/blazeface/python/
+
+# Download BlazeFace model files and test images
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/blazeface-1000e.tgz
+
+# Use blazeface-1000e model
+# CPU Inference
+python infer.py --model blazeface-1000e/ --image test_lite_face_detector_3.jpg --device cpu
+# GPU Inference
+python infer.py --model blazeface-1000e/ --image test_lite_face_detector_3.jpg --device gpu
+```
+
+The visualized result after running is as follows
+
+
+
+## BlazeFace Python Interface
+
+```python
+fastdeploy.vision.facedet.BlzaeFace(model_file, params_file=None, runtime_option=None, config_file=None, model_format=ModelFormat.PADDLE)
+```
+
+BlazeFace model loading and initialization, among which model_file is the exported PADDLE model format
+
+**Parameter**
+
+> * **model_file**(str): Model file path
+> * **params_file**(str): Parameter file path. No need to set when the model is in PADDLE format
+> * **config_file**(str): config file path. No need to set when the model is in PADDLE format
+> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
+> * **model_format**(ModelFormat): Model format. PADDLE format by default
+
+### predict function
+
+> ```python
+> BlazeFace.predict(input_image)
+> ```
+> Through let BlazeFace.postprocessor.conf_threshold = 0.2，to modify conf_threshold
+>
+> Model prediction interface. Input images and output detection results.
+>
+> **Parameter**
+>
+> > * **input_image**(np.ndarray): Input image in HWC or BGR format
+
+> **Return**
+>
+> > Return`fastdeploy.vision.FaceDetectionResult` structure. Refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for its description.
+
+## Other Documents
+
+- [BlazeFace Model Description](..)
+- [BlazeFace C++ Deployment](../cpp)
+- [Model Prediction Results](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/blazeface/python/README_CN.md b/examples/vision/facedet/blazeface/python/README_CN.md
new file mode 100644
index 000000000..3bbc620e2
--- /dev/null
+++ b/examples/vision/facedet/blazeface/python/README_CN.md
@@ -0,0 +1,68 @@
+[English](README.md) | 简体中文
+# BlazeFace Python部署示例
+
+在部署前，需确认以下两个步骤
+
+- 1. 软硬件环境满足要求，参考[FastDeploy环境要求](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+- 2. FastDeploy Python whl包安装，参考[FastDeploy Python安装](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+
+本目录下提供`infer.py`快速完成BlazeFace在CPU/GPU部署的示例。执行如下脚本即可完成
+
+```bash
+#下载部署示例代码
+git clone https://github.com/PaddlePaddle/FastDeploy.git
+cd examples/vision/facedet/blazeface/python/
+
+#下载BlazeFace模型文件和测试图片
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/blazeface-1000e.tgz
+
+#使用blazeface-1000e模型
+# CPU推理
+python infer.py --model blazeface-1000e/ --image test_lite_face_detector_3.jpg --device cpu
+# GPU推理
+python infer.py --model blazeface-1000e/ --image test_lite_face_detector_3.jpg --device gpu
+```
+
+运行完成可视化结果如下图所示
+
+
+
+## BlazeFace Python接口
+
+```python
+fastdeploy.vision.facedet.BlzaeFace(model_file, params_file=None, runtime_option=None, config_file=None, model_format=ModelFormat.PADDLE)
+```
+
+BlazeFace模型加载和初始化
+
+**参数**
+
+> * **model_file**(str): 模型文件路径
+> * **params_file**(str): 参数文件路径，当模型格式为ONNX格式时，此参数无需设定
+> * **config_file**(str): config文件路径，当模型格式为ONNX格式时，此参数无需设定
+> * **runtime_option**(RuntimeOption): 后端推理配置，默认为None，即采用默认配置
+> * **model_format**(ModelFormat): 模型格式，默认为PADDLE
+
+### predict函数
+
+> ```python
+> BlazeFace.predict(input_image)
+> ```
+> 通过BlazeFace.postprocessor.conf_threshold = 0.2，来修改conf_threshold
+>
+> 模型预测结口，输入图像直接输出检测结果。
+>
+> **参数**
+>
+> > * **input_image**(np.ndarray): 输入数据，注意需为HWC，BGR格式
+
+> **返回**
+>
+> > 返回`fastdeploy.vision.FaceDetectionResult`结构体，结构体说明参考文档[视觉模型预测结果](../../../../../docs/api/vision_results/)
+
+## 其它文档
+
+- [BlazeFace 模型介绍](..)
+- [BlazeFace C++部署](../cpp)
+- [模型预测结果说明](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/blazeface/python/infer.py b/examples/vision/facedet/blazeface/python/infer.py
new file mode 100644
index 000000000..b9904f9c0
--- /dev/null
+++ b/examples/vision/facedet/blazeface/python/infer.py
@@ -0,0 +1,58 @@
+import fastdeploy as fd
+import cv2
+import os
+
+
+def parse_arguments():
+ import argparse
+ import ast
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "--model", required=True, help="Path of blazeface model dir.")
+ parser.add_argument(
+ "--image", required=True, help="Path of test image file.")
+ parser.add_argument(
+ "--device",
+ type=str,
+ default='cpu',
+ help="Type of inference device, support 'cpu' or 'gpu'.")
+ parser.add_argument(
+ "--use_trt",
+ type=ast.literal_eval,
+ default=False,
+ help="Wether to use tensorrt.")
+ return parser.parse_args()
+
+
+def build_option(args):
+ option = fd.RuntimeOption()
+
+ if args.device.lower() == "gpu":
+ option.use_gpu()
+
+ if args.use_trt:
+ option.use_trt_backend()
+ option.set_trt_input_shape("images", [1, 3, 640, 640])
+ return option
+
+
+args = parse_arguments()
+
+model_dir = args.model
+
+model_file = os.path.join(model_dir, "model.pdmodel")
+params_file = os.path.join(model_dir, "model.pdiparams")
+config_file = os.path.join(model_dir, "infer_cfg.yml")
+
+# Configure runtime and load the model
+runtime_option = build_option(args)
+model = fd.vision.facedet.BlazeFace(model_file, params_file, config_file, runtime_option=runtime_option)
+
+# Predict image detection results
+im = cv2.imread(args.image)
+result = model.predict(im)
+print(result)
+# Visualization of prediction Results
+vis_im = fd.vision.vis_face_detection(im, result)
+cv2.imwrite("visualized_result.jpg", vis_im)
+print("Visualized result save in ./visualized_result.jpg")
diff --git a/examples/vision/facedet/centerface/README.md b/examples/vision/facedet/centerface/README.md
new file mode 100644
index 000000000..722709671
--- /dev/null
+++ b/examples/vision/facedet/centerface/README.md
@@ -0,0 +1,25 @@
+English | [简体中文](README_CN.md)
+
+# CenterFace Ready-to-deploy Model
+
+- The deployment of the CenterFace model is based on [CenterFace](https://github.com/Star-Clouds/CenterFace.git) and [Pre-trained Model Based on WIDER FACE](https://github.com/Star-Clouds/CenterFace.git)
+ - （1）The *.onnx provided by [Official Repository](https://github.com/Star-Clouds/CenterFace.git) can be deployed directly；
+ - （2）The CenterFace train code is not open source and users cannot train it.
+
+
+## Download Pre-trained ONNX Model
+
+For developers' testing, models exported by CenterFace are provided below. Developers can download them directly. (The accuracy in the following table is derived from the source official repository on WIDER FACE test set)
+| Model | Size | Accuracy(Easy Set,Medium Set,Hard Set) | Note |
+|:---------------------------------------------------------------- |:----- |:----- |:---- |
+| [CenterFace](https://bj.bcebos.com/paddlehub/fastdeploy/CenterFace.onnx) | 7.2MB | 93.2%,92.1%,87.3% | This model file is sourced from [CenterFace](https://github.com/Star-Clouds/CenterFace.git)，MIT license |
+
+
+## Detailed Deployment Documents
+
+- [Python Deployment](python)
+- [C++ Deployment](cpp)
+
+## Release Note
+
+- Document and code are based on [CenterFace](https://github.com/Star-Clouds/CenterFace.git)
\ No newline at end of file
diff --git a/examples/vision/facedet/centerface/README_CN.md b/examples/vision/facedet/centerface/README_CN.md
new file mode 100644
index 000000000..34c996fdb
--- /dev/null
+++ b/examples/vision/facedet/centerface/README_CN.md
@@ -0,0 +1,24 @@
+[English](README.md) | 简体中文
+# CenterFace准备部署模型
+
+- CenterFace部署模型实现来自[CenterFace](https://github.com/Star-Clouds/CenterFace.git),和[基于WIDER FACE的预训练模型](https://github.com/Star-Clouds/CenterFace.git)
+ - （1）[官方库](https://github.com/Star-Clouds/CenterFace.git)提供的*.onnx可直接进行部署；
+ - （2）由于CenterFace未开放训练源代码，开发者无法基于自己的数据训练CenterFace模型
+
+
+## 下载预训练ONNX模型
+
+为了方便开发者的测试，下面提供了CenterFace导出的模型，开发者可直接下载使用。（下表中模型的精度来源于源官方库在WIDER FACE测试集上的结果）
+| 模型 | 大小 | 精度(Easy Set,Medium Set,Hard Set) | 备注 |
+|:---------------------------------------------------------------- |:----- |:----- |:---- |
+| [CenterFace](https://bj.bcebos.com/paddlehub/fastdeploy/CenterFace.onnx) | 7.2MB | 93.2%,92.1%,87.3% | 此模型文件来源于[CenterFace](https://github.com/Star-Clouds/CenterFace.git)，MIT license |
+
+
+## 详细部署文档
+
+- [Python部署](python)
+- [C++部署](cpp)
+
+## 版本说明
+
+- 本版本文档和代码基于[CenterFace](https://github.com/Star-Clouds/CenterFace.git) 编写
\ No newline at end of file
diff --git a/examples/vision/facedet/centerface/cpp/CMakeLists.txt b/examples/vision/facedet/centerface/cpp/CMakeLists.txt
new file mode 100644
index 000000000..9ba668762
--- /dev/null
+++ b/examples/vision/facedet/centerface/cpp/CMakeLists.txt
@@ -0,0 +1,14 @@
+PROJECT(infer_demo C CXX)
+CMAKE_MINIMUM_REQUIRED (VERSION 3.10)
+
+# Specifies the path to the fastdeploy library after you have downloaded it
+option(FASTDEPLOY_INSTALL_DIR "Path of downloaded fastdeploy sdk.")
+
+include(${FASTDEPLOY_INSTALL_DIR}/FastDeploy.cmake)
+
+# Include the FastDeploy dependency header file
+include_directories(${FASTDEPLOY_INCS})
+
+add_executable(infer_demo ${PROJECT_SOURCE_DIR}/infer.cc)
+# Add the FastDeploy library dependency
+target_link_libraries(infer_demo ${FASTDEPLOY_LIBS})
diff --git a/examples/vision/facedet/centerface/cpp/README.md b/examples/vision/facedet/centerface/cpp/README.md
new file mode 100644
index 000000000..7c94c573a
--- /dev/null
+++ b/examples/vision/facedet/centerface/cpp/README.md
@@ -0,0 +1,78 @@
+English | [简体中文](README_CN.md)
+# CenterFace C++ Deployment Example
+
+This directory provides examples that `infer.cc` fast finishes the deployment of CenterFace on CPU/GPU and GPU accelerated by TensorRT.
+
+Before deployment, two steps require confirmation
+
+- 1. Software and hardware should meet the requirements. Please refer to [FastDeploy Environment Requirements](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+- 2. Download the precompiled deployment library and samples code according to your development environment. Refer to [FastDeploy Precompiled Library](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+
+Taking the CPU inference on Linux as an example, the compilation test can be completed by executing the following command in this directory.
+
+```bash
+mkdir build
+cd build
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz # x.x.x > 1.0.4
+tar xvf fastdeploy-linux-x64-x.x.x.tgz # x.x.x > 1.0.4
+cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x # x.x.x > 1.0.4
+make -j
+
+# Download the official converted CenterFace model files and test images
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/CenterFace.onnx
+
+# Use CenterFace.onnx model
+# CPU inference
+./infer_demo CenterFace.onnx test_lite_face_detector_3.jpg 0
+# GPU inference
+./infer_demo CenterFace.onnx test_lite_face_detector_3.jpg 1
+# TensorRT inference on GPU
+./infer_demo CenterFace.onnx test_lite_face_detector_3.jpg 2
+```
+
+The visualized result after running is as follows
+
+
+
+The above command works for Linux or MacOS. For SDK use-pattern in Windows, refer to:
+- [How to use FastDeploy C++ SDK in Windows](../../../../../docs/cn/faq/use_sdk_on_windows.md)
+
+## CenterFace C++ Interface
+
+### CenterFace Class
+
+```c++
+fastdeploy::vision::facedet::CenterFace(
+ const string& model_file,
+ const string& params_file = "",
+ const RuntimeOption& runtime_option = RuntimeOption(),
+ const ModelFormat& model_format = ModelFormat::ONNX)
+```
+
+CenterFace model loading and initialization, among which model_file is the exported ONNX model format
+
+**Parameter**
+
+> * **model_file**(str): Model file path
+> * **params_file**(str): Parameter file path. Only passing an empty string when the model is in ONNX format
+> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
+> * **model_format**(ModelFormat): Model format. ONNX format by default
+
+#### Predict Function
+
+> ```c++
+> CenterFace::Predict(cv::Mat* im, FaceDetectionResult* result)
+> ```
+>
+> Model prediction interface. Input images and output detection results.
+>
+> **Parameter**
+>
+> > * **im**: Input images in HWC or BGR format
+> > * **result**: Detection results, including detection box and confidence of each box. Refer to [Vision Model Prediction Result](../../../../../docs/api/vision_results/) for FaceDetectionResult
+
+- [Model Description](../../)
+- [Python Deployment](../python)
+- [Vision Model Prediction Results](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/centerface/cpp/README_CN.md b/examples/vision/facedet/centerface/cpp/README_CN.md
new file mode 100644
index 000000000..b9443271e
--- /dev/null
+++ b/examples/vision/facedet/centerface/cpp/README_CN.md
@@ -0,0 +1,77 @@
+# CenterFace C++部署示例
+
+本目录下提供`infer.cc`快速完成CenterFace在CPU/GPU，以及GPU上通过TensorRT加速部署的示例。
+
+在部署前，需确认以下两个步骤
+
+- 1. 软硬件环境满足要求，参考[FastDeploy环境要求](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+- 2. 根据开发环境，下载预编译部署库和samples代码，参考[FastDeploy预编译库](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+
+以Linux上CPU推理为例，在本目录执行如下命令即可完成编译测试
+
+```bash
+mkdir build
+cd build
+# 下载FastDeploy预编译库，用户可在上文提到的`FastDeploy预编译库`中自行选择合适的版本使用
+wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz # x.x.x > 1.0.4
+tar xvf fastdeploy-linux-x64-x.x.x.tgz # x.x.x > 1.0.4
+cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x # x.x.x > 1.0.4
+make -j
+
+#下载官方转换好的CenterFace模型文件和测试图片
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/CenterFace.onnx
+
+#使用CenterFace.onnx模型
+# CPU推理
+./infer_demo CenterFace.onnx test_lite_face_detector_3.jpg 0
+# GPU推理
+./infer_demo CenterFace.onnx test_lite_face_detector_3.jpg 1
+# GPU上TensorRT推理
+./infer_demo CenterFace.onnx test_lite_face_detector_3.jpg 2
+```
+
+运行完成可视化结果如下图所示
+
+
+
+以上命令只适用于Linux或MacOS, Windows下SDK的使用方式请参考:
+- [如何在Windows中使用FastDeploy C++ SDK](../../../../../docs/cn/faq/use_sdk_on_windows.md)
+
+## CenterFace C++接口
+
+### CenterFace类
+
+```c++
+fastdeploy::vision::facedet::CenterFace(
+ const string& model_file,
+ const string& params_file = "",
+ const RuntimeOption& runtime_option = RuntimeOption(),
+ const ModelFormat& model_format = ModelFormat::ONNX)
+```
+
+CenterFace模型加载和初始化，其中model_file为导出的ONNX模型格式。
+
+**参数**
+
+> * **model_file**(str): 模型文件路径
+> * **params_file**(str): 参数文件路径，当模型格式为ONNX时，此参数传入空字符串即可
+> * **runtime_option**(RuntimeOption): 后端推理配置，默认为None，即采用默认配置
+> * **model_format**(ModelFormat): 模型格式，默认为ONNX格式
+
+#### Predict函数
+
+> ```c++
+> CenterFace::Predict(cv::Mat* im, FaceDetectionResult* result)
+> ```
+>
+> 模型预测接口，输入图像直接输出检测结果。
+>
+> **参数**
+>
+> > * **im**: 输入图像，注意需为HWC，BGR格式
+> > * **result**: 检测结果，包括检测框，各个框的置信度, FaceDetectionResult说明参考[视觉模型预测结果](../../../../../docs/api/vision_results/)
+
+- [模型介绍](../../)
+- [Python部署](../python)
+- [视觉模型预测结果](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/centerface/cpp/infer.cc b/examples/vision/facedet/centerface/cpp/infer.cc
new file mode 100644
index 000000000..1f4af8433
--- /dev/null
+++ b/examples/vision/facedet/centerface/cpp/infer.cc
@@ -0,0 +1,105 @@
+// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "fastdeploy/vision.h"
+
+void CpuInfer(const std::string& model_file, const std::string& image_file) {
+ auto model = fastdeploy::vision::facedet::CenterFace(model_file);
+ if (!model.Initialized()) {
+ std::cerr << "Failed to initialize." << std::endl;
+ return;
+ }
+
+ auto im = cv::imread(image_file);
+
+ fastdeploy::vision::FaceDetectionResult res;
+ if (!model.Predict(im, &res)) {
+ std::cerr << "Failed to predict." << std::endl;
+ return;
+ }
+ std::cout << res.Str() << std::endl;
+
+ auto vis_im = fastdeploy::vision::VisFaceDetection(im, res);
+ cv::imwrite("vis_result.jpg", vis_im);
+ std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
+}
+
+void GpuInfer(const std::string& model_file, const std::string& image_file) {
+ auto option = fastdeploy::RuntimeOption();
+ option.UseGpu();
+ auto model = fastdeploy::vision::facedet::CenterFace(model_file, "", option);
+ if (!model.Initialized()) {
+ std::cerr << "Failed to initialize." << std::endl;
+ return;
+ }
+
+ auto im = cv::imread(image_file);
+
+ fastdeploy::vision::FaceDetectionResult res;
+ if (!model.Predict(im, &res)) {
+ std::cerr << "Failed to predict." << std::endl;
+ return;
+ }
+ std::cout << res.Str() << std::endl;
+
+ auto vis_im = fastdeploy::vision::VisFaceDetection(im, res);
+ cv::imwrite("vis_result.jpg", vis_im);
+ std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
+}
+
+void TrtInfer(const std::string& model_file, const std::string& image_file) {
+ auto option = fastdeploy::RuntimeOption();
+ option.UseGpu();
+ option.UseTrtBackend();
+ option.SetTrtInputShape("images", {1, 3, 640, 640});
+ auto model = fastdeploy::vision::facedet::CenterFace(model_file, "", option);
+ if (!model.Initialized()) {
+ std::cerr << "Failed to initialize." << std::endl;
+ return;
+ }
+
+ auto im = cv::imread(image_file);
+
+ fastdeploy::vision::FaceDetectionResult res;
+ if (!model.Predict(im, &res)) {
+ std::cerr << "Failed to predict." << std::endl;
+ return;
+ }
+ std::cout << res.Str() << std::endl;
+
+ auto vis_im = fastdeploy::vision::VisFaceDetection(im, res);
+ cv::imwrite("vis_result.jpg", vis_im);
+ std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
+}
+
+int main(int argc, char* argv[]) {
+ if (argc < 4) {
+ std::cout << "Usage: infer_demo path/to/model path/to/image run_option, "
+ "e.g ./infer_model yolov5s-face.onnx ./test.jpeg 0"
+ << std::endl;
+ std::cout << "The data type of run_option is int, 0: run with cpu; 1: run "
+ "with gpu; 2: run with gpu and use tensorrt backend."
+ << std::endl;
+ return -1;
+ }
+
+ if (std::atoi(argv[3]) == 0) {
+ CpuInfer(argv[1], argv[2]);
+ } else if (std::atoi(argv[3]) == 1) {
+ GpuInfer(argv[1], argv[2]);
+ } else if (std::atoi(argv[3]) == 2) {
+ TrtInfer(argv[1], argv[2]);
+ }
+ return 0;
+}
diff --git a/examples/vision/facedet/centerface/python/README.md b/examples/vision/facedet/centerface/python/README.md
new file mode 100644
index 000000000..7f7ecf97b
--- /dev/null
+++ b/examples/vision/facedet/centerface/python/README.md
@@ -0,0 +1,75 @@
+English | [简体中文](README_CN.md)
+# CenterFace Python Deployment Example
+
+Before deployment, two steps require confirmation
+
+- 1. Software and hardware should meet the requirements. Please refer to [FastDeploy Environment Requirements](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+- 2. Install FastDeploy Python whl package. Refer to [FastDeploy Python Installation](../../../../../docs/en/build_and_install/download_prebuilt_libraries.md)
+
+This directory provides examples that `infer.py` fast finishes the deployment of CenterFace on CPU/GPU and GPU accelerated by TensorRT. The script is as follows
+
+```bash
+# Download the example code for deployment
+git clone https://github.com/PaddlePaddle/FastDeploy.git
+cd examples/vision/facedet/CenterFace/python/
+
+# Download CenterFace model files and test images
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/CenterFace.onnx
+
+# Use CenterFace.onnx model
+# CPU inference
+python infer.py --model CenterFace.onnx --image test_lite_face_detector_3.jpg --device cpu
+# GPU inference
+python infer.py --model CenterFace.onnx --image test_lite_face_detector_3.jpg --device gpu
+# TensorRT inference on GPU
+python infer.py --model CenterFace.onnx --image test_lite_face_detector_3.jpg --device gpu --use_trt True
+```
+
+The visualized result after running is as follows
+
+
+
+## CenterFace Python Interface
+
+```python
+fastdeploy.vision.facedet.CenterFace(model_file, params_file=None, runtime_option=None, model_format=ModelFormat.ONNX)
+```
+
+CenterFace model loading and initialization, among which model_file is the exported ONNX model format
+
+**Parameter**
+
+> * **model_file**(str): Model file path
+> * **params_file**(str): Parameter file path. No need to set when the model is in ONNX format
+> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
+> * **model_format**(ModelFormat): Model format. ONNX format by default
+
+### predict function
+
+> ```python
+> CenterFace.predict(image_data)
+> ```
+>
+> Model prediction interface. Input images and output detection results.
+>
+> **Parameter**
+>
+> > * **image_data**(np.ndarray): Input data in HWC or BGR format
+
+
+> **Return**
+>
+> > Return `fastdeploy.vision.FaceDetectionResult` structure. Refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for its description.
+
+### Class Member Property
+#### Pre-processing Parameter
+Users can modify the following pre-processing parameters to their needs, which affects the final inference and deployment results
+
+> > * **size**(list[int]): This parameter changes the size of the resize used during preprocessing, containing two integer elements for [width, height] with default value [640, 640]
+
+## Other Documents
+
+- [CenterFace Model Description](..)
+- [CenterFace C++ Deployment](../cpp)
+- [Model Prediction Results](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/centerface/python/README_CN.md b/examples/vision/facedet/centerface/python/README_CN.md
new file mode 100644
index 000000000..6fb7f3909
--- /dev/null
+++ b/examples/vision/facedet/centerface/python/README_CN.md
@@ -0,0 +1,74 @@
+[English](README.md) | 简体中文
+# CenterFace Python部署示例
+
+在部署前，需确认以下两个步骤
+
+- 1. 软硬件环境满足要求，参考[FastDeploy环境要求](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+- 2. FastDeploy Python whl包安装，参考[FastDeploy Python安装](../../../../../docs/cn/build_and_install/download_prebuilt_libraries.md)
+
+本目录下提供`infer.py`快速完成CenterFace在CPU/GPU，以及GPU上通过TensorRT加速部署的示例。执行如下脚本即可完成
+
+```bash
+#下载部署示例代码
+git clone https://github.com/PaddlePaddle/FastDeploy.git
+cd examples/vision/facedet/CenterFace/python/
+
+#下载CenterFace模型文件和测试图片
+wget https://raw.githubusercontent.com/DefTruth/lite.ai.toolkit/main/examples/lite/resources/test_lite_face_detector_3.jpg
+wget https://bj.bcebos.com/paddlehub/fastdeploy/CenterFace.onnx
+
+#使用CenterFace.onnx模型
+# CPU推理
+python infer.py --model CenterFace.onnx --image test_lite_face_detector_3.jpg --device cpu
+# GPU推理
+python infer.py --model CenterFace.onnx --image test_lite_face_detector_3.jpg --device gpu
+# GPU上使用TensorRT推理
+python infer.py --model CenterFace.onnx --image test_lite_face_detector_3.jpg --device gpu --use_trt True
+```
+
+运行完成可视化结果如下图所示
+
+
+
+## CenterFace Python接口
+
+```python
+fastdeploy.vision.facedet.CenterFace(model_file, params_file=None, runtime_option=None, model_format=ModelFormat.ONNX)
+```
+
+CenterFace模型加载和初始化，其中model_file为导出的ONNX模型格式
+
+**参数**
+
+> * **model_file**(str): 模型文件路径
+> * **params_file**(str): 参数文件路径，当模型格式为ONNX格式时，此参数无需设定
+> * **runtime_option**(RuntimeOption): 后端推理配置，默认为None，即采用默认配置
+> * **model_format**(ModelFormat): 模型格式，默认为ONNX
+
+### predict函数
+
+> ```python
+> CenterFace.predict(image_data)
+> ```
+>
+> 模型预测结口，输入图像直接输出检测结果。
+>
+> **参数**
+>
+> > * **image_data**(np.ndarray): 输入数据，注意需为HWC，BGR格式
+
+> **返回**
+>
+> > 返回`fastdeploy.vision.FaceDetectionResult`结构体，结构体说明参考文档[视觉模型预测结果](../../../../../docs/api/vision_results/)
+
+### 类成员属性
+#### 预处理参数
+用户可按照自己的实际需求，修改下列预处理参数，从而影响最终的推理和部署效果
+
+> > * **size**(list[int]): 通过此参数修改预处理过程中resize的大小，包含两个整型元素，表示[width, height], 默认值为[640, 640]
+
+## 其它文档
+
+- [CenterFace 模型介绍](..)
+- [CenterFace C++部署](../cpp)
+- [模型预测结果说明](../../../../../docs/api/vision_results/)
diff --git a/examples/vision/facedet/centerface/python/infer.py b/examples/vision/facedet/centerface/python/infer.py
new file mode 100644
index 000000000..39eeaf39e
--- /dev/null
+++ b/examples/vision/facedet/centerface/python/infer.py
@@ -0,0 +1,51 @@
+import fastdeploy as fd
+import cv2
+
+
+def parse_arguments():
+ import argparse
+ import ast
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "--model", required=True, help="Path of CenterFace onnx model.")
+ parser.add_argument(
+ "--image", required=True, help="Path of test image file.")
+ parser.add_argument(
+ "--device",
+ type=str,
+ default='cpu',
+ help="Type of inference device, support 'cpu' or 'gpu'.")
+ parser.add_argument(
+ "--use_trt",
+ type=ast.literal_eval,
+ default=False,
+ help="Wether to use tensorrt.")
+ return parser.parse_args()
+
+
+def build_option(args):
+ option = fd.RuntimeOption()
+
+ if args.device.lower() == "gpu":
+ option.use_gpu()
+
+ if args.use_trt:
+ option.use_trt_backend()
+ option.set_trt_input_shape("images", [1, 3, 640, 640])
+ return option
+
+
+args = parse_arguments()
+
+# Configure runtime and load the model
+runtime_option = build_option(args)
+model = fd.vision.facedet.CenterFace(args.model, runtime_option=runtime_option)
+
+# Predict image detection results
+im = cv2.imread(args.image)
+result = model.predict(im)
+print(result)
+# Visualization of prediction Results
+vis_im = fd.vision.vis_face_detection(im, result)
+cv2.imwrite("visualized_result.jpg", vis_im)
+print("Visualized result save in ./visualized_result.jpg")
diff --git a/examples/vision/faceid/insightface/rknpu2/cpp/README.md b/examples/vision/faceid/insightface/rknpu2/cpp/README.md
index 0c09d4fbe..b2d1fe460 100644
--- a/examples/vision/faceid/insightface/rknpu2/cpp/README.md
+++ b/examples/vision/faceid/insightface/rknpu2/cpp/README.md
@@ -1,19 +1,19 @@
-[English](README.md) | 简体中文
-# InsightFace C++部署示例
+English | [简体中文](README_CN.md)
+# InsightFace C++ Deployment Example
-FastDeploy支持在RKNPU上部署包括ArcFace\CosFace\VPL\Partial_FC在内的InsightFace系列模型。
+FastDeploy supports the deployment of InsightFace models like ArcFace\CosFace\VPL\Partial_FC on RKNPU.
-本目录下提供`infer_arcface.cc`快速完成InsighFace模型包括ArcFace在CPU/RKNPU加速部署的示例。
+This directoty provides the example that `infer_arcface.cc` fast finishes the deployment of InsighFace models like ArcFace on CPU/RKNPU.
-在部署前，需确认以下两个步骤:
+Two steps before deployment:
-1. 软硬件环境满足要求
-2. 根据开发环境，下载预编译部署库或者从头编译FastDeploy仓库
+1. Software and hardware should meet the requirements.
+2. Download the precompiled deployment library or deploy FastDeploy repository from scratch according to your development environment.
-以上步骤请参考[RK2代NPU部署库编译](../../../../../../docs/cn/build_and_install/rknpu2.md)实现
+Refer to [RK2 generation NPU deployment library compilation](../../../../../../docs/cn/build_and_install/rknpu2.md) for the above steps
-在本目录执行如下命令即可完成编译测试
+The compilation can be completed by executing the following command in this directory.
```bash
mkdir build
@@ -24,18 +24,18 @@ tar xvf fastdeploy-linux-x64-x.x.x.tgz
cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x
make -j
-# 下载官方转换好的ArcFace模型文件和测试图片
+# Download the official converted ArcFace model files and test images
wget https://bj.bcebos.com/paddlehub/fastdeploy/ms1mv3_arcface_r18.onnx
wget https://bj.bcebos.com/paddlehub/fastdeploy/rknpu2/face_demo.zip
unzip face_demo.zip
-# CPU推理
+# CPU inference
./infer_arcface_demo ms1mv3_arcface_r100.onnx face_0.jpg face_1.jpg face_2.jpg 0
-# RKNPU推理
+# RKNPU inference
./infer_arcface_demo ms1mv3_arcface_r100.onnx face_0.jpg face_1.jpg face_2.jpg 1
```
-运行完成可视化结果如下图所示
+The visualized result is as follows
@@ -43,12 +43,12 @@ unzip face_demo.zip
+
+
+
+
+
+
-## PPOCRv2 C++ Interface
+## PPOCRv2 C++ Interface
### PPOCRv2 Class
@@ -98,7 +98,7 @@ The initialization of PPOCRv2, consisting of detection and recognition models (N
> > * **result**: OCR prediction results, including the position of the detection box from the detection model, the classification of the direction from the classification model, and the recognition result from the recognition model. Refer to [Vision Model Prediction Results](../../../../../docs/api/vision_results/) for OCRResult
-## DBDetector C++ Interface
+## DBDetector C++ Interface
### DBDetector Class
@@ -112,7 +112,7 @@ DBDetector model loading and initialization. The model is in paddle format.
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path. Merely passing an empty string when the model is in ONNX format
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
> * **model_format**(ModelFormat): Model format. Paddle format by default
@@ -139,7 +139,7 @@ Users can modify the following pre-processing parameters to their needs, which a
> > * **max_side_len**(int): The long side’s maximum size of the oriented view before detection. The long side will be resized to this size when exceeding the value. And the short side will be scaled in equal proportion. Default 960
> > * **det_db_thresh**(double): The binarization threshold of the prediction image from DB models. Default 0.3
-> > * **det_db_box_thresh**(double): The threshold for the output box of DB models, below which the predicted box is discarded. Default 0.6
+> > * **det_db_box_thresh**(double): The threshold for the output box of DB models, below which the predicted box is discarded. Default 0.6
> > * **det_db_unclip_ratio**(double): The expansion ratio of the DB model output box. Default 1.5
> > * **det_db_score_mode**(string): The way to calculate the average score of the text box in DB post-processing. Default slow, which is identical to the calculation of the polygon area’s average score
> > * **use_dilation**(bool): Whether to expand the feature map from the detection. Default False
diff --git a/examples/vision/ocr/PP-OCRv2/cpp/infer_static_shape.cc b/examples/vision/ocr/PP-OCRv2/cpp/infer_static_shape.cc
old mode 100755
new mode 100644
index ba5527a2e..7a48ba879
--- a/examples/vision/ocr/PP-OCRv2/cpp/infer_static_shape.cc
+++ b/examples/vision/ocr/PP-OCRv2/cpp/infer_static_shape.cc
@@ -19,7 +19,12 @@ const char sep = '\\';
const char sep = '/';
#endif
-void InitAndInfer(const std::string& det_model_dir, const std::string& cls_model_dir, const std::string& rec_model_dir, const std::string& rec_label_file, const std::string& image_file, const fastdeploy::RuntimeOption& option) {
+void InitAndInfer(const std::string& det_model_dir,
+ const std::string& cls_model_dir,
+ const std::string& rec_model_dir,
+ const std::string& rec_label_file,
+ const std::string& image_file,
+ const fastdeploy::RuntimeOption& option) {
auto det_model_file = det_model_dir + sep + "inference.pdmodel";
auto det_params_file = det_model_dir + sep + "inference.pdiparams";
@@ -33,33 +38,40 @@ void InitAndInfer(const std::string& det_model_dir, const std::string& cls_model
auto cls_option = option;
auto rec_option = option;
- auto det_model = fastdeploy::vision::ocr::DBDetector(det_model_file, det_params_file, det_option);
- auto cls_model = fastdeploy::vision::ocr::Classifier(cls_model_file, cls_params_file, cls_option);
- auto rec_model = fastdeploy::vision::ocr::Recognizer(rec_model_file, rec_params_file, rec_label_file, rec_option);
+ auto det_model = fastdeploy::vision::ocr::DBDetector(
+ det_model_file, det_params_file, det_option);
+ auto cls_model = fastdeploy::vision::ocr::Classifier(
+ cls_model_file, cls_params_file, cls_option);
+ auto rec_model = fastdeploy::vision::ocr::Recognizer(
+ rec_model_file, rec_params_file, rec_label_file, rec_option);
- // Users could enable static shape infer for rec model when deploy PP-OCR on hardware
- // which can not support dynamic shape infer well, like Huawei Ascend series.
+ // Users could enable static shape infer for rec model when deploy PP-OCR on
+ // hardware
+ // which can not support dynamic shape infer well, like Huawei Ascend series.
rec_model.GetPreprocessor().SetStaticShapeInfer(true);
assert(det_model.Initialized());
assert(cls_model.Initialized());
assert(rec_model.Initialized());
- // The classification model is optional, so the PP-OCR can also be connected in series as follows
+ // The classification model is optional, so the PP-OCR can also be connected
+ // in series as follows
// auto ppocr_v2 = fastdeploy::pipeline::PPOCRv2(&det_model, &rec_model);
- auto ppocr_v2 = fastdeploy::pipeline::PPOCRv2(&det_model, &cls_model, &rec_model);
+ auto ppocr_v2 =
+ fastdeploy::pipeline::PPOCRv2(&det_model, &cls_model, &rec_model);
- // When users enable static shape infer for rec model, the batch size of cls and rec model must to be set to 1.
+ // When users enable static shape infer for rec model, the batch size of cls
+ // and rec model must to be set to 1.
ppocr_v2.SetClsBatchSize(1);
- ppocr_v2.SetRecBatchSize(1);
+ ppocr_v2.SetRecBatchSize(1);
- if(!ppocr_v2.Initialized()){
+ if (!ppocr_v2.Initialized()) {
std::cerr << "Failed to initialize PP-OCR." << std::endl;
return;
}
auto im = cv::imread(image_file);
-
+
fastdeploy::vision::OCRResult result;
if (!ppocr_v2.Predict(im, &result)) {
std::cerr << "Failed to predict." << std::endl;
@@ -92,7 +104,7 @@ int main(int argc, char* argv[]) {
int flag = std::atoi(argv[6]);
if (flag == 0) {
- option.UseCpu();
+ option.UseCpu();
} else if (flag == 1) {
option.UseAscend();
}
@@ -102,6 +114,7 @@ int main(int argc, char* argv[]) {
std::string rec_model_dir = argv[3];
std::string rec_label_file = argv[4];
std::string test_image = argv[5];
- InitAndInfer(det_model_dir, cls_model_dir, rec_model_dir, rec_label_file, test_image, option);
+ InitAndInfer(det_model_dir, cls_model_dir, rec_model_dir, rec_label_file,
+ test_image, option);
return 0;
}
diff --git a/examples/vision/ocr/PP-OCRv3/cpp/README.md b/examples/vision/ocr/PP-OCRv3/cpp/README.md
index 79c7af33e..923bda513 100755
--- a/examples/vision/ocr/PP-OCRv3/cpp/README.md
+++ b/examples/vision/ocr/PP-OCRv3/cpp/README.md
@@ -1,7 +1,7 @@
English | [简体中文](README_CN.md)
# PPOCRv3 C++ Deployment Example
-This directory provides examples that `infer.cc` fast finishes the deployment of PPOCRv3 on CPU/GPU and GPU accelerated by TensorRT.
+This directory provides examples that `infer.cc` fast finishes the deployment of PPOCRv3 on CPU/GPU and GPU accelerated by TensorRT.
Two steps before deployment
@@ -13,7 +13,7 @@ Taking the CPU inference on Linux as an example, the compilation test can be com
```
mkdir build
cd build
-# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz
tar xvf fastdeploy-linux-x64-x.x.x.tgz
cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x
@@ -44,6 +44,8 @@ wget https://gitee.com/paddlepaddle/PaddleOCR/raw/release/2.6/ppocr/utils/ppocr_
./infer_demo ./ch_PP-OCRv3_det_infer ./ch_ppocr_mobile_v2.0_cls_infer ./ch_PP-OCRv3_rec_infer ./ppocr_keys_v1.txt ./12.jpg 3
# KunlunXin XPU inference
./infer_demo ./ch_PP-OCRv3_det_infer ./ch_ppocr_mobile_v2.0_cls_infer ./ch_PP-OCRv3_rec_infer ./ppocr_keys_v1.txt ./12.jpg 4
+# Huawei Ascend inference, need to use the infer_static_shape_demo, if the user needs to predict the image continuously, the input image size needs to be prepared as a uniform size.
+./infer_static_shape_demo ./ch_PP-OCRv3_det_infer ./ch_ppocr_mobile_v2.0_cls_infer ./ch_PP-OCRv3_rec_infer ./ppocr_keys_v1.txt ./12.jpg 1
```
The above command works for Linux or MacOS. For SDK in Windows, refer to:
diff --git a/examples/vision/segmentation/paddleseg/cpp/README.md b/examples/vision/segmentation/paddleseg/cpp/README.md
index 4c5be9f6c..572e38078 100755
--- a/examples/vision/segmentation/paddleseg/cpp/README.md
+++ b/examples/vision/segmentation/paddleseg/cpp/README.md
@@ -1,7 +1,7 @@
English | [简体中文](README_CN.md)
# PaddleSeg C++ Deployment Example
-This directory provides examples that `infer.cc` fast finishes the deployment of Unet on CPU/GPU and GPU accelerated by TensorRT.
+This directory provides examples that `infer.cc` fast finishes the deployment of Unet on CPU/GPU and GPU accelerated by TensorRT.
Before deployment, two steps require confirmation
@@ -15,7 +15,7 @@ Taking the inference on Linux as an example, the compilation test can be complet
```bash
mkdir build
cd build
-# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
+# Download the FastDeploy precompiled library. Users can choose your appropriate version in the `FastDeploy Precompiled Library` mentioned above
wget https://bj.bcebos.com/fastdeploy/release/cpp/fastdeploy-linux-x64-x.x.x.tgz
tar xvf fastdeploy-linux-x64-x.x.x.tgz
cmake .. -DFASTDEPLOY_INSTALL_DIR=${PWD}/fastdeploy-linux-x64-x.x.x
@@ -35,6 +35,8 @@ wget https://paddleseg.bj.bcebos.com/dygraph/demo/cityscapes_demo.png
./infer_demo Unet_cityscapes_without_argmax_infer cityscapes_demo.png 2
# kunlunxin XPU inference
./infer_demo Unet_cityscapes_without_argmax_infer cityscapes_demo.png 3
+# Huawei Ascend Inference
+./infer_demo Unet_cityscapes_without_argmax_infer cityscapes_demo.png 4
```
The visualized result after running is as follows
@@ -45,7 +47,7 @@ The visualized result after running is as follows
The above command works for Linux or MacOS. For SDK use-pattern in Windows, refer to:
- [How to use FastDeploy C++ SDK in Windows](../../../../../docs/cn/faq/use_sdk_on_windows.md)
-## PaddleSeg C++ Interface
+## PaddleSeg C++ Interface
### PaddleSeg Class
@@ -62,7 +64,7 @@ PaddleSegModel model loading and initialization, among which model_file is the e
**Parameter**
-> * **model_file**(str): Model file path
+> * **model_file**(str): Model file path
> * **params_file**(str): Parameter file path
> * **config_file**(str): Inference deployment configuration file
> * **runtime_option**(RuntimeOption): Backend inference configuration. None by default, which is the default configuration
diff --git a/fastdeploy/benchmark/benchmark.h b/fastdeploy/benchmark/benchmark.h
new file mode 100755
index 000000000..b7463d3e9
--- /dev/null
+++ b/fastdeploy/benchmark/benchmark.h
@@ -0,0 +1,86 @@
+// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+#include "fastdeploy/core/config.h"
+#include "fastdeploy/utils/utils.h"
+#include "fastdeploy/utils/perf.h"
+#include "fastdeploy/benchmark/option.h"
+#include "fastdeploy/benchmark/results.h"
+
+#ifdef ENABLE_BENCHMARK
+ #define __RUNTIME_PROFILE_LOOP_BEGIN(option, base_loop) \
+ int __p_loop = (base_loop); \
+ const bool __p_enable_profile = option.enable_profile; \
+ const bool __p_include_h2d_d2h = option.include_h2d_d2h; \
+ const int __p_repeats = option.repeats; \
+ const int __p_warmup = option.warmup; \
+ if (__p_enable_profile && (!__p_include_h2d_d2h)) { \
+ __p_loop = (__p_repeats) + (__p_warmup); \
+ FDINFO << option << std::endl; \
+ } \
+ TimeCounter __p_tc; \
+ bool __p_tc_start = false; \
+ for (int __p_i = 0; __p_i < __p_loop; ++__p_i) { \
+ if (__p_i >= (__p_warmup) && (!__p_tc_start)) { \
+ __p_tc.Start(); \
+ __p_tc_start = true; \
+ } \
+
+ #define __RUNTIME_PROFILE_LOOP_END(result) \
+ } \
+ if ((__p_enable_profile && (!__p_include_h2d_d2h))) { \
+ if (__p_tc_start) { \
+ __p_tc.End(); \
+ double __p_tc_duration = __p_tc.Duration(); \
+ result.time_of_runtime = \
+ __p_tc_duration / static_cast