Merge branch 'develop' into release/2.3

.gitignore

@@ -11,3 +11,4 @@ _build/
 build/
 log/
 nohup.out
+.DS_Store

README_ch.md

@@ -53,6 +53,7 @@ PP-ShiTu图像识别快速体验：[点击这里](./docs/zh_CN/quick_start/quick
   - 图像分类快速体验
     - [尝鲜版](./docs/zh_CN/quick_start/quick_start_classification_new_user.md)
     - [进阶版](./docs/zh_CN/quick_start/quick_start_classification_professional.md)
+    - [多标签分类](./docs/zh_CN/quick_start/quick_start_multilabel_classification.md)
 - [PP-ShiTu图像识别系统介绍](#图像识别系统介绍)
     - [主体检测](./docs/zh_CN/image_recognition_pipeline/mainbody_detection.md)
     - [特征提取](./docs/zh_CN/image_recognition_pipeline/feature_extraction.md)
@@ -70,7 +71,7 @@ PP-ShiTu图像识别快速体验：[点击这里](./docs/zh_CN/quick_start/quick
     - [模型导出](./docs/zh_CN/inference_deployment/export_model.md)
     - Python/C++ 预测引擎
       - [基于Python预测引擎预测推理](./docs/zh_CN/inference_deployment/python_deploy.md)
-      - [基于C++预测引擎预测推理](./docs/zh_CN/inference_deployment/cpp_deploy.md)(当前只支持图像分类任务，图像识别更新中)
+      - [基于C++分类预测引擎预测推理](./docs/zh_CN/inference_deployment/cpp_deploy.md)、[基于C++的PP-ShiTu预测引擎预测推理](deploy/cpp_shitu/readme.md)
     - 服务化部署
       - [Paddle Serving服务化部署(推荐)](./docs/zh_CN/inference_deployment/paddle_serving_deploy.md)
       - [Hub serving服务化部署](./docs/zh_CN/inference_deployment/paddle_hub_serving_deploy.md)

README_en.md

@@ -68,7 +68,7 @@ Quick experience of image recognition：[Link](./docs/en/tutorials/quick_start_r
     - [Feature Learning](./docs/en/tutorials/getting_started_retrieval_en.md)
 - Inference Model Prediction
     - [Python Inference](./docs/en/inference.md)
-    - [C++ Inference](./deploy/cpp/readme_en.md)(only support classification for now, recognition coming soon)
+    - [C++ Classfication Inference](./deploy/cpp/readme_en.md)， [C++ PP-ShiTu Inference](deploy/cpp_shitu/readme_en.md)
 - Model Deploy (only support classification for now, recognition coming soon)
     - [Hub Serving Deployment](./deploy/hubserving/readme_en.md)
     - [Mobile Deployment](./deploy/lite/readme_en.md)

__init__.py

@@ -14,3 +14,4 @@
 
 __all__ = ['PaddleClas']
 from .paddleclas import PaddleClas
+from ppcls.arch.backbone import *

benchmark/prepare_data.sh

 #!/bin/bash
 dataset_url=$1
 
+package_check_list=(imageio tqdm Cython pycocotools tb_paddle scipy pandas wget h5py sklearn opencv-python visualdl)
+for package in ${package_check_list[@]}; do
+    if python -c "import ${package}" >/dev/null 2>&1; then
+        echo "${package} have already installed"
+    else
+        echo "${package} NOT FOUND"
+        pip install ${package}
+        echo "${package} installed"
+    fi
+done
+
 cd dataset
 rm -rf ILSVRC2012
 wget -nc ${dataset_url}

benchmark/run_all.sh

@@ -5,20 +5,26 @@
 # pip install ...
 # 2 拷贝该模型需要数据、预训练模型
 # 3 批量运行（如不方便批量，1，2需放到单个模型中）
- 
-model_mode_list=(MobileNetV1 MobileNetV2 MobileNetV3_large_x1_0 EfficientNetB0 ShuffleNetV2_x1_0 DenseNet121 HRNet_W48_C SwinTransformer_tiny_patch4_window7_224 alt_gvt_base)
+log_path=${LOG_PATH_INDEX_DIR:-$(pwd)}  # LOG_PATH_INDEX_DIR 后续QA设置参数
+model_mode_list=(MobileNetV1 MobileNetV2 MobileNetV3_large_x1_0 ShuffleNetV2_x1_0 HRNet_W48_C SwinTransformer_tiny_patch4_window7_224 alt_gvt_base)    # benchmark 监控模型列表
+#model_mode_list=(MobileNetV1 MobileNetV2 MobileNetV3_large_x1_0 EfficientNetB0 ShuffleNetV2_x1_0 DenseNet121 HRNet_W48_C SwinTransformer_tiny_patch4_window7_224 alt_gvt_base)   # 该脚本支持列表
 fp_item_list=(fp32)
-bs_list=(32 64 96 128)
+#bs_list=(32 64 96 128)
 for model_mode in ${model_mode_list[@]}; do
       for fp_item in ${fp_item_list[@]}; do
+          if [ ${model_mode} = MobileNetV3_large_x1_0 ] || [ ${model_mode} = ShuffleNetV2_x1_0 ]; then
+              bs_list=(256)
+          else
+              bs_list=(64)
+          fi
           for bs_item in ${bs_list[@]};do
 	    echo "index is speed, 1gpus, begin, ${model_name}"
 	    run_mode=sp
-	    CUDA_VISIBLE_DEVICES=0 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 10 ${model_mode}     #  (5min)
+	    CUDA_VISIBLE_DEVICES=0 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 1 ${model_mode} | tee ${log_path}/clas_${model_mode}_${run_mode}_bs${bs_item}_${fp_item}_1gpus 2>&1    #  (5min)
 	    sleep 10
             echo "index is speed, 8gpus, run_mode is multi_process, begin, ${model_name}"
             run_mode=mp
-            CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 10 ${model_mode} 
+            CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 bash benchmark/run_benchmark.sh ${run_mode} ${bs_item} ${fp_item} 1 ${model_mode}| tee ${log_path}/clas_${model_mode}_${run_mode}_bs${bs_item}_${fp_item}_8gpus8p 2>&1
             sleep 10
             done
       done

benchmark/run_benchmark.sh

@@ -6,27 +6,37 @@ function _set_params(){
     run_mode=${1:-"sp"}          # 单卡sp|多卡mp
     batch_size=${2:-"64"}
     fp_item=${3:-"fp32"}        # fp32|fp16
-    epochs=${4:-"10"}       # 可选，如果需要修改代码提前中断
-    model_name=${5:-"model_name"}
-    run_log_path="${TRAIN_LOG_DIR:-$(pwd)}/benchmark"  # TRAIN_LOG_DIR 后续QA设置该参数
- 
+    epochs=${4:-"2"}       # 可选，如果需要修改代码提前中断
+    model_item=${5:-"model_item"}
+    run_log_path=${TRAIN_LOG_DIR:-$(pwd)}  # TRAIN_LOG_DIR 后续QA设置该参数
+
+    index=1
+    mission_name="图像分类"           # 模型所属任务名称，具体可参考scripts/config.ini                                （必填）
+    direction_id=0                    # 任务所属方向，0：CV，1：NLP，2：Rec。                                          (必填)
+    skip_steps=8                      # 解析日志，有些模型前几个step耗时长，需要跳过                                  (必填)
+    keyword="ips:"              # 解析日志，筛选出数据所在行的关键字                                            (必填)
+    keyword_loss="loss:"       #选填
+    model_mode=-1                      # 解析日志，具体参考scripts/analysis.py.                                        (必填)
+    ips_unit="images/s"
+    base_batch_size=$batch_size
 #   以下不用修改   
     device=${CUDA_VISIBLE_DEVICES//,/ }
     arr=(${device})
     num_gpu_devices=${#arr[*]}
-    log_file=${run_log_path}/clas_${model_name}_${run_mode}_bs${batch_size}_${fp_item}_${num_gpu_devices}
+    log_file=${run_log_path}/clas_${model_item}_${run_mode}_bs${batch_size}_${fp_item}_${num_gpu_devices}
+    model_name=${model_item}_bs${batch_size}_${fp_item}    # model_item 用于yml匹配，model_name用于入库
 }
 function _train(){
     echo "Train on ${num_gpu_devices} GPUs"
     echo "current CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES, gpus=$num_gpu_devices, batch_size=$batch_size"
 
     if [ ${fp_item} = "fp32" ];then
-        model_config=`find ppcls/configs/ImageNet -name ${model_name}.yaml` 
+        model_config=`find ppcls/configs/ImageNet -name ${model_item}.yaml`
     else
-        model_config=`find ppcls/configs/ImageNet -name ${model_name}_fp16.yaml` 
+        model_config=`find ppcls/configs/ImageNet -name ${model_item}_fp16.yaml`
     fi
 
-    train_cmd="-c ${model_config} -o DataLoader.Train.sampler.batch_size=${batch_size} -o Global.epochs=${epochs}"   
+    train_cmd="-c ${model_config} -o DataLoader.Train.sampler.batch_size=${batch_size} -o Global.epochs=${epochs}  -o Global.eval_during_train=False -o Global.print_batch_step=2"
     case ${run_mode} in
     sp) train_cmd="python -u tools/train.py ${train_cmd}" ;;
     mp)
@@ -36,7 +46,7 @@ function _train(){
     esac
     rm -rf mylog
 # 以下不用修改
-    timeout 15m ${train_cmd} > ${log_file} 2>&1
+    timeout 5m ${train_cmd} > ${log_file} 2>&1
     if [ $? -ne 0 ];then
         echo -e "${model_name}, FAIL"
         export job_fail_flag=1
@@ -51,6 +61,8 @@ function _train(){
         cp mylog/workerlog.0 ${log_file}
     fi
 }
- 
+
+source ${BENCHMARK_ROOT}/scripts/run_model.sh # 在该脚本中会对符合benchmark规范的log使用analysis.py 脚本进行性能数据解析;该脚本在连调时可从benchmark repo中下载https://github.com/PaddlePaddle/benchmark/blob/master/scripts/run_model.sh;如果不联调只想要产出训练log可以注掉本行,提交时需打开
 _set_params $@
-_train
+_run
+#_train

deploy/configs/build_cartoon.yaml

-Global:
-  rec_inference_model_dir: "./models/cartoon_rec_ResNet50_iCartoon_v1.0_infer/"
-  batch_size: 32
-  use_gpu: True
-  enable_mkldnn: True
-  cpu_num_threads: 10
-  enable_benchmark: True
-  use_fp16: False
-  ir_optim: True
-  use_tensorrt: False
-  gpu_mem: 8000
-  enable_profile: False
-
-RecPreProcess:
-  transform_ops:
-    - ResizeImage:
-        resize_short: 256
-    - CropImage:
-        size: 224
-    - NormalizeImage:
-        scale: 0.00392157
-        mean: [0.485, 0.456, 0.406]
-        std: [0.229, 0.224, 0.225]
-        order: ''
-    - ToCHWImage:
-
-RecPostProcess: null
-
-# indexing engine config
-IndexProcess:
-  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
-  index_dir: "./recognition_demo_data_v1.1/gallery_cartoon/index/"
-  image_root: "./recognition_demo_data_v1.1/gallery_cartoon/"
-  data_file:  "./recognition_demo_data_v1.1/gallery_cartoon/data_file.txt"
-  index_operation: "new" # suported: "append", "remove", "new"
-  delimiter: "\t"
-  dist_type: "IP"
-  embedding_size: 2048

deploy/configs/build_drinks.yaml

-Global:
-  rec_inference_model_dir: "./models/general_PPLCNet_x2_5_lite_v1.0_infer"
-  batch_size: 32
-  use_gpu: True
-  enable_mkldnn: False
-  cpu_num_threads: 10
-  enable_benchmark: False
-  use_fp16: False
-  ir_optim: True
-  use_tensorrt: False
-  gpu_mem: 8000
-  enable_profile: False
-
-RecPreProcess:
-  transform_ops:
-    - ResizeImage:
-        size: 224
-    - NormalizeImage:
-        scale: 0.00392157
-        mean: [0.485, 0.456, 0.406]
-        std: [0.229, 0.224, 0.225]
-        order: ''
-    - ToCHWImage:
-
-RecPostProcess: null
-
-# indexing engine config
-IndexProcess:
-  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
-  index_dir: "./drink_dataset/index"
-  image_root: "./drink_dataset"
-  data_file:  "./drink_dataset/drink_label.txt"
-  index_operation: "new" # suported: "append", "remove", "new"
-  delimiter: " "
-  dist_type: "IP"
-  embedding_size: 512

deploy/configs/build_logo.yaml

-Global:
-  rec_inference_model_dir: "./models/logo_rec_ResNet50_Logo3K_v1.0_infer/"
-  batch_size: 32
-  use_gpu: True
-  enable_mkldnn: True
-  cpu_num_threads: 10
-  enable_benchmark: True
-  use_fp16: False
-  ir_optim: True
-  use_tensorrt: False
-  gpu_mem: 8000
-  enable_profile: False
-
-RecPreProcess:
-  transform_ops:
-    - ResizeImage:
-        size: 224
-    - NormalizeImage:
-        scale: 0.00392157
-        mean: [0.485, 0.456, 0.406]
-        std: [0.229, 0.224, 0.225]
-        order: ''
-    - ToCHWImage:
-
-RecPostProcess: null
-
-# indexing engine config
-IndexProcess:
-  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
-  index_dir: "./recognition_demo_data_v1.1/gallery_logo/index/"
-  image_root: "./recognition_demo_data_v1.1/gallery_logo/"
-  data_file:  "./recognition_demo_data_v1.1/gallery_logo/data_file.txt"
-  index_operation: "new" # suported: "append", "remove", "new"
-  delimiter: "\t"
-  dist_type: "IP"
-  embedding_size: 512

deploy/configs/build_product.yaml

-Global:
-  rec_inference_model_dir: "./models/product_ResNet50_vd_aliproduct_v1.0_infer"
-  batch_size: 32
-  use_gpu: True
-  enable_mkldnn: True
-  cpu_num_threads: 10
-  enable_benchmark: True
-  use_fp16: False
-  ir_optim: True
-  use_tensorrt: False
-  gpu_mem: 8000
-  enable_profile: False
-
-RecPreProcess:
-  transform_ops:
-    - ResizeImage:
-        size: 224
-    - NormalizeImage:
-        scale: 0.00392157
-        mean: [0.485, 0.456, 0.406]
-        std: [0.229, 0.224, 0.225]
-        order: ''
-    - ToCHWImage:
-
-RecPostProcess: null
-
-# indexing engine config
-IndexProcess:
-  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
-  index_dir: "./recognition_demo_data_v1.1/gallery_product/index"
-  image_root: "./recognition_demo_data_v1.1/gallery_product/"
-  data_file:  "./recognition_demo_data_v1.1/gallery_product/data_file.txt"
-  index_operation: "new" # suported: "append", "remove", "new"
-  delimiter: "\t"
-  dist_type: "IP"
-  embedding_size: 512

deploy/configs/build_product_binary.yaml

-Global:
-  rec_inference_model_dir: "./models/product_MV3_x1_0_aliproduct_bin_v1.0_infer"
-  batch_size: 32
-  use_gpu: True
-  enable_mkldnn: True
-  cpu_num_threads: 10
-  enable_benchmark: True
-  use_fp16: False
-  ir_optim: True
-  use_tensorrt: False
-  gpu_mem: 8000
-  enable_profile: False
-
-RecPreProcess:
-  transform_ops:
-    - ResizeImage:
-        size: 224
-    - NormalizeImage:
-        scale: 0.00392157
-        mean: [0.485, 0.456, 0.406]
-        std: [0.229, 0.224, 0.225]
-        order: ''
-    - ToCHWImage:
-
-RecPostProcess:
-  main_indicator: Binarize
-  Binarize:
-    method: "round"
-
-# indexing engine config
-IndexProcess:
-  index_method: "Flat"    # supported: HNSW32, Flat
-  index_dir: "./recognition_demo_data_v1.1/gallery_product/index_binary"
-  image_root: "./recognition_demo_data_v1.1/gallery_product/"
-  data_file:  "./recognition_demo_data_v1.1/gallery_product/data_file.txt"
-  index_operation: "new"  # suported: "append", "remove", "new"
-  delimiter: "\t"
-  dist_type: "hamming"
-  embedding_size: 512

deploy/configs/build_vehicle.yaml

-Global:
-  rec_inference_model_dir: "./models/vehicle_cls_ResNet50_CompCars_v1.0_infer/"
-  batch_size: 32
-  use_gpu: True
-  enable_mkldnn: True
-  cpu_num_threads: 10
-  enable_benchmark: True
-  use_fp16: False
-  ir_optim: True
-  use_tensorrt: False
-  gpu_mem: 8000
-  enable_profile: False
-
-RecPreProcess:
-  transform_ops:
-    - ResizeImage:
-        size: 224
-    - NormalizeImage:
-        scale: 0.00392157
-        mean: [0.485, 0.456, 0.406]
-        std: [0.229, 0.224, 0.225]
-        order: ''
-    - ToCHWImage:
-
-RecPostProcess: null
-
-# indexing engine config
-IndexProcess:
-  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
-  index_dir: "./recognition_demo_data_v1.1/gallery_vehicle/index/"
-  image_root: "./recognition_demo_data_v1.1/gallery_vehicle/"
-  data_file:  "./recognition_demo_data_v1.1/gallery_vehicle/data_file.txt"
-  index_operation: "new" # suported: "append", "remove", "new"
-  delimiter: "\t"
-  dist_type: "IP"
-  embedding_size: 512

deploy/configs/inference_cartoon.yaml

@@ -50,7 +50,16 @@ RecPreProcess:
 
 RecPostProcess: null
 
+# indexing engine config
 IndexProcess:
+  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
   index_dir: "./recognition_demo_data_v1.1/gallery_cartoon/index/"
+  image_root: "./recognition_demo_data_v1.1/gallery_cartoon/"
+  data_file:  "./recognition_demo_data_v1.1/gallery_cartoon/data_file.txt"
+  index_operation: "new" # suported: "append", "remove", "new"
+  delimiter: "\t"
+  dist_type: "IP"
+  embedding_size: 2048
+  batch_size: 32
   return_k: 5
-  score_thres: 0.5
+  score_thres: 0.5
\ No newline at end of file

deploy/configs/inference_cls.yaml

@@ -11,6 +11,7 @@ Global:
   use_tensorrt: False
   gpu_mem: 8000
   enable_profile: False
+
 PreProcess:
   transform_ops:
     - ResizeImage:
@@ -24,10 +25,11 @@ PreProcess:
         order: ''
         channel_num: 3
     - ToCHWImage:
+
 PostProcess:
   main_indicator: Topk
   Topk:
     topk: 5
     class_id_map_file: "../ppcls/utils/imagenet1k_label_list.txt"
   SavePreLabel:
-    save_dir: ./pre_label/
+    save_dir: ./pre_label/
\ No newline at end of file

deploy/configs/inference_cls_ch4.yaml

@@ -11,6 +11,7 @@ Global:
   use_tensorrt: False
   gpu_mem: 8000
   enable_profile: False
+
 PreProcess:
   transform_ops:
     - ResizeImage:
@@ -24,10 +25,11 @@ PreProcess:
         order: ''
         channel_num: 4
     - ToCHWImage:
+
 PostProcess:
   main_indicator: Topk
   Topk:
     topk: 5
     class_id_map_file: "../ppcls/utils/imagenet1k_label_list.txt"
   SavePreLabel:
-    save_dir: ./pre_label/
+    save_dir: ./pre_label/
\ No newline at end of file

deploy/configs/inference_multilabel_cls.yaml → deploy/configs/inference_cls_multilabel.yaml

@@ -11,6 +11,7 @@ Global:
   use_tensorrt: False
   gpu_mem: 8000
   enable_profile: False
+
 PreProcess:
   transform_ops:
     - ResizeImage:
@@ -24,10 +25,11 @@ PreProcess:
         order: ''
         channel_num: 3
     - ToCHWImage:
+    
 PostProcess:
   main_indicator: MultiLabelTopk
   MultiLabelTopk:
     topk: 5
     class_id_map_file: None
   SavePreLabel:
-    save_dir: ./pre_label/
+    save_dir: ./pre_label/
\ No newline at end of file

deploy/configs/inference_det.yaml

@@ -30,4 +30,5 @@ DetPreProcess:
         mean: [0.485, 0.456, 0.406]
         std: [0.229, 0.224, 0.225]
     - DetPermute: {}
-DetPostProcess: {}
+    
+DetPostProcess: {}
\ No newline at end of file

deploy/configs/inference_drink.yaml

 Global:
-  infer_imgs: "./recognition_demo_data_v1.2/test_drinks/hongniu_1.jpg"
+  infer_imgs: "./drink_dataset_v1.0/test_images/hongniu_1.jpg"
   det_inference_model_dir: "./models/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer"
   rec_inference_model_dir: "./models/general_PPLCNet_x2_5_lite_v1.0_infer"
   rec_nms_thresold: 0.05
-  
+
   batch_size: 1
   image_shape: [3, 640, 640]
   threshold: 0.2
@@ -11,11 +11,10 @@ Global:
   labe_list:
   - foreground
 
-  # inference engine config
   use_gpu: True
   enable_mkldnn: False
   cpu_num_threads: 10
-  enable_benchmark: True
+  enable_benchmark: False
   use_fp16: False
   ir_optim: True
   use_tensorrt: False
@@ -33,6 +32,7 @@ DetPreProcess:
         mean: [0.485, 0.456, 0.406]
         std: [0.229, 0.224, 0.225]
     - DetPermute: {}
+
 DetPostProcess: {}
 
 RecPreProcess:
@@ -50,6 +50,14 @@ RecPostProcess: null
 
 # indexing engine config
 IndexProcess:
-  index_dir: "./drink_dataset/index"
+  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
+  index_dir: "./drink_dataset_v1.0/gallery"
+  image_root: "./drink_dataset_v1.0/index"
+  data_file:  "./drink_dataset_v1.0/gallery/drink_label.txt"
+  index_operation: "new" # suported: "append", "remove", "new"
+  delimiter: " "
+  dist_type: "IP"
+  embedding_size: 512
+  batch_size: 32
   return_k: 5
-  score_thres: 0.4
+  score_thres: 0.4
\ No newline at end of file

deploy/configs/inference_general.yaml

@@ -3,7 +3,7 @@ Global:
   det_inference_model_dir: "./models/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer"
   rec_inference_model_dir: "./models/general_PPLCNet_x2_5_lite_v1.0_infer"
   rec_nms_thresold: 0.05
-  
+
   batch_size: 1
   image_shape: [3, 640, 640]
   threshold: 0.2
@@ -11,7 +11,6 @@ Global:
   labe_list:
   - foreground
 
-  # inference engine config
   use_gpu: True
   enable_mkldnn: True
   cpu_num_threads: 10
@@ -33,6 +32,7 @@ DetPreProcess:
         mean: [0.485, 0.456, 0.406]
         std: [0.229, 0.224, 0.225]
     - DetPermute: {}
+
 DetPostProcess: {}
 
 RecPreProcess:
@@ -50,6 +50,14 @@ RecPostProcess: null
 
 # indexing engine config
 IndexProcess:
-  index_dir: "./drink_dataset_v1.0/index/"
+  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
+  image_root: "./drink_dataset_v1.0/gallery/"
+  index_dir: "./drink_dataset_v1.0/index"
+  data_file:  "./drink_dataset_v1.0/gallery/drink_label.txt"
+  index_operation: "new" # suported: "append", "remove", "new"
+  delimiter: "\t"
+  dist_type: "IP"
+  embedding_size: 512
+  batch_size: 32
   return_k: 5
-  score_thres: 0.5
+  score_thres: 0.5
\ No newline at end of file

deploy/configs/inference_product_binary.yaml → deploy/configs/inference_general_binary.yaml

 Global:
-  infer_imgs: "./recognition_demo_data_v1.1/test_product/daoxiangcunjinzhubing_6.jpg"
-  det_inference_model_dir: "./models/ppyolov2_r50vd_dcn_mainbody_v1.0_infer"
-  rec_inference_model_dir: "./models/product_MV3_x1_0_aliproduct_bin_v1.0_infer"
+  infer_imgs: "./drink_dataset_v1.0/test_images/001.jpeg"
+  det_inference_model_dir: "./models/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer"
+  rec_inference_model_dir: "./models/general_PPLCNet_x2_5_lite_binary_v1.0_infer"
   rec_nms_thresold: 0.05
   
   batch_size: 1
@@ -11,7 +11,6 @@ Global:
   labe_list:
   - foreground
 
-  # inference engine config
   use_gpu: True
   enable_mkldnn: True
   cpu_num_threads: 10
@@ -49,12 +48,18 @@ RecPreProcess:
 RecPostProcess:
   main_indicator: Binarize
   Binarize:
-    method: "round"
+    method: "sign"
 
 # indexing engine config
 IndexProcess:
-  binary_index: true
-  index_dir: "./recognition_demo_data_v1.1/gallery_product/index_binary"
+  index_method: "Flat"  # supported: HNSW32, Flat
+  image_root: "./drink_dataset_v1.0/gallery/"
+  index_dir: "./drink_dataset_v1.0/index_bin"
+  data_file:  "./drink_dataset_v1.0/gallery/drink_label.txt"
+  index_operation: "new"  # suported: "append", "remove", "new"
+  delimiter: "\t"
+  dist_type: "hamming"
+  embedding_size: 512
+  batch_size: 32
   return_k: 5
-  score_thres: 0
-  
+  hamming_radius: 100

deploy/configs/inference_logo.yaml

@@ -11,7 +11,6 @@ Global:
   labe_list:
   - foreground
 
-  # inference engine config
   use_gpu: True
   enable_mkldnn: True
   cpu_num_threads: 10
@@ -33,6 +32,7 @@ DetPreProcess:
         mean: [0.485, 0.456, 0.406]
         std: [0.229, 0.224, 0.225]
     - DetPermute: {}
+
 DetPostProcess: {}
 
 RecPreProcess:
@@ -50,6 +50,14 @@ RecPostProcess: null
 
 # indexing engine config
 IndexProcess:
+  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
   index_dir: "./recognition_demo_data_v1.1/gallery_logo/index/"
+  image_root: "./recognition_demo_data_v1.1/gallery_logo/"
+  data_file:  "./recognition_demo_data_v1.1/gallery_logo/data_file.txt"
+  index_operation: "new" # suported: "append", "remove", "new"
+  delimiter: "\t"
+  dist_type: "IP"
+  embedding_size: 512
+  batch_size: 32
   return_k: 5
-  score_thres: 0.5
+  score_thres: 0.5
\ No newline at end of file

deploy/configs/inference_product.yaml

@@ -33,6 +33,7 @@ DetPreProcess:
         mean: [0.485, 0.456, 0.406]
         std: [0.229, 0.224, 0.225]
     - DetPermute: {}
+
 DetPostProcess: {}
 
 RecPreProcess:
@@ -50,6 +51,14 @@ RecPostProcess: null
 
 # indexing engine config
 IndexProcess:
+  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
   index_dir: "./recognition_demo_data_v1.1/gallery_product/index"
+  image_root: "./recognition_demo_data_v1.1/gallery_product/"
+  data_file:  "./recognition_demo_data_v1.1/gallery_product/data_file.txt"
+  index_operation: "new" # suported: "append", "remove", "new"
+  delimiter: "\t"
+  dist_type: "IP"
+  embedding_size: 512
+  batch_size: 32
   return_k: 5
-  score_thres: 0.5
+  score_thres: 0.5
\ No newline at end of file

deploy/configs/inference_rec.yaml

@@ -2,13 +2,6 @@ Global:
   infer_imgs: "./images/wangzai.jpg"
   rec_inference_model_dir: "./models/product_ResNet50_vd_aliproduct_v1.0_infer"
   batch_size: 1
-  image_shape: [3, 640, 640]
-  threshold: 0.5
-  max_det_results: 1
-  labe_list:
-  - foreground
-
-  # inference engine config
   use_gpu: False
   enable_mkldnn: True
   cpu_num_threads: 10
@@ -32,4 +25,4 @@ RecPreProcess:
         order: ''
     - ToCHWImage:
 
-RecPostProcess: null
+RecPostProcess: null
\ No newline at end of file

deploy/configs/inference_vehicle.yaml

@@ -11,7 +11,6 @@ Global:
   labe_list:
   - foreground
 
-  # inference engine config
   use_gpu: True
   enable_mkldnn: True
   cpu_num_threads: 10
@@ -36,7 +35,6 @@ DetPreProcess:
 
 DetPostProcess: {}
 
-
 RecPreProcess:
   transform_ops:
     - ResizeImage:
@@ -52,6 +50,14 @@ RecPostProcess: null
 
 # indexing engine config
 IndexProcess:
-    index_dir: "./recognition_demo_data_v1.1/gallery_vehicle/index/"
-    return_k: 5
-    score_thres: 0.5
+  index_method: "HNSW32" # supported: HNSW32, IVF, Flat
+  index_dir: "./recognition_demo_data_v1.1/gallery_vehicle/index/"
+  image_root: "./recognition_demo_data_v1.1/gallery_vehicle/"
+  data_file:  "./recognition_demo_data_v1.1/gallery_vehicle/data_file.txt"
+  index_operation: "new" # suported: "append", "remove", "new"
+  delimiter: "\t"
+  dist_type: "IP"
+  embedding_size: 512
+  batch_size: 32
+  return_k: 5
+  score_thres: 0.5
\ No newline at end of file

deploy/cpp/CMakeLists.txt

@@ -14,6 +14,11 @@ SET(TENSORRT_DIR "" CACHE PATH "Compile demo with TensorRT")
 
 set(DEMO_NAME "clas_system")
 
+include(external-cmake/yaml-cpp.cmake)
+include_directories("${CMAKE_SOURCE_DIR}/")
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/ext/yaml-cpp/src/ext-yaml-cpp/include")
+link_directories("${CMAKE_CURRENT_BINARY_DIR}/ext/yaml-cpp/lib")
+
 macro(safe_set_static_flag)
     foreach(flag_var
         CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
@@ -61,7 +66,7 @@ if (WIN32)
         add_definitions(-DSTATIC_LIB)
     endif()
 else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -o3 -std=c++11")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O3 -std=c++11")
     set(CMAKE_STATIC_LIBRARY_PREFIX "")
 endif()
 message("flags" ${CMAKE_CXX_FLAGS})
@@ -153,7 +158,7 @@ endif(WITH_STATIC_LIB)
 if (NOT WIN32)
     set(DEPS ${DEPS}
         ${MATH_LIB} ${MKLDNN_LIB}
-        glog gflags protobuf z xxhash
+        glog gflags protobuf z xxhash yaml-cpp
         )
     if(EXISTS "${PADDLE_LIB}/third_party/install/snappystream/lib")
         set(DEPS ${DEPS} snappystream)
@@ -164,7 +169,7 @@ if (NOT WIN32)
 else()
     set(DEPS ${DEPS}
         ${MATH_LIB} ${MKLDNN_LIB}
-        glog gflags_static libprotobuf xxhash)
+        glog gflags_static libprotobuf xxhash libyaml-cppmt)
     set(DEPS ${DEPS} libcmt shlwapi)
     if (EXISTS "${PADDLE_LIB}/third_party/install/snappy/lib")
         set(DEPS ${DEPS} snappy)
@@ -204,6 +209,7 @@ include_directories(${FETCHCONTENT_BASE_DIR}/extern_autolog-src)
 
 AUX_SOURCE_DIRECTORY(./src SRCS)
 add_executable(${DEMO_NAME} ${SRCS})
+ADD_DEPENDENCIES(${DEMO_NAME} ext-yaml-cpp)
 
 target_link_libraries(${DEMO_NAME} ${DEPS})
 

deploy/cpp/external-cmake/yaml-cpp.cmake

+
+find_package(Git REQUIRED)
+
+include(ExternalProject)
+
+message("${CMAKE_BUILD_TYPE}")
+
+ExternalProject_Add(
+        ext-yaml-cpp
+        URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip
+        URL_MD5 9542d6de397d1fbd649ed468cb5850e6
+        CMAKE_ARGS
+        -DYAML_CPP_BUILD_TESTS=OFF
+		-DYAML_CPP_BUILD_TOOLS=OFF
+        -DYAML_CPP_INSTALL=OFF
+        -DYAML_CPP_BUILD_CONTRIB=OFF
+		-DMSVC_SHARED_RT=OFF
+		-DBUILD_SHARED_LIBS=OFF
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=${CMAKE_BINARY_DIR}/ext/yaml-cpp/lib
+        -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY=${CMAKE_BINARY_DIR}/ext/yaml-cpp/lib
+        PREFIX "${CMAKE_BINARY_DIR}/ext/yaml-cpp"
+        # Disable install step
+        INSTALL_COMMAND ""
+	    LOG_DOWNLOAD ON
+        LOG_BUILD 1
+)

deploy/cpp/include/cls.h

@@ -28,64 +28,63 @@
 #include <fstream>
 #include <numeric>
 
+#include "include/cls_config.h"
 #include <include/preprocess_op.h>
 
 using namespace paddle_infer;
 
 namespace PaddleClas {
 
-class Classifier {
-public:
-  explicit Classifier(const std::string &model_path,
-                      const std::string &params_path, const bool &use_gpu,
-                      const int &gpu_id, const int &gpu_mem,
-                      const int &cpu_math_library_num_threads,
-                      const bool &use_mkldnn, const bool &use_tensorrt,
-                      const bool &use_fp16, const int &resize_short_size,
-                      const int &crop_size) {
-    this->use_gpu_ = use_gpu;
-    this->gpu_id_ = gpu_id;
-    this->gpu_mem_ = gpu_mem;
-    this->cpu_math_library_num_threads_ = cpu_math_library_num_threads;
-    this->use_mkldnn_ = use_mkldnn;
-    this->use_tensorrt_ = use_tensorrt;
-    this->use_fp16_ = use_fp16;
-
-    this->resize_short_size_ = resize_short_size;
-    this->crop_size_ = crop_size;
-
-    LoadModel(model_path, params_path);
-  }
-
-  // Load Paddle inference model
-  void LoadModel(const std::string &model_path, const std::string &params_path);
-
-  // Run predictor
-  double Run(cv::Mat &img, std::vector<double> *times);
-
-private:
-  std::shared_ptr<Predictor> predictor_;
-
-  bool use_gpu_ = false;
-  int gpu_id_ = 0;
-  int gpu_mem_ = 4000;
-  int cpu_math_library_num_threads_ = 4;
-  bool use_mkldnn_ = false;
-  bool use_tensorrt_ = false;
-  bool use_fp16_ = false;
-
-  std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
-  std::vector<float> scale_ = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
-  bool is_scale_ = true;
-
-  int resize_short_size_ = 256;
-  int crop_size_ = 224;
-
-  // pre-process
-  ResizeImg resize_op_;
-  Normalize normalize_op_;
-  Permute permute_op_;
-  CenterCropImg crop_op_;
-};
+    class Classifier {
+    public:
+        explicit Classifier(const ClsConfig &config) {
+            this->use_gpu_ = config.use_gpu;
+            this->gpu_id_ = config.gpu_id;
+            this->gpu_mem_ = config.gpu_mem;
+            this->cpu_math_library_num_threads_ = config.cpu_threads;
+            this->use_fp16_ = config.use_fp16;
+            this->use_mkldnn_ = config.use_mkldnn;
+            this->use_tensorrt_ = config.use_tensorrt;
+            this->mean_ = config.mean;
+            this->std_ = config.std;
+            this->resize_short_size_ = config.resize_short_size;
+            this->scale_ = config.scale;
+            this->crop_size_ = config.crop_size;
+            this->ir_optim_ = config.ir_optim;
+            LoadModel(config.cls_model_path, config.cls_params_path);
+        }
+
+        // Load Paddle inference model
+        void LoadModel(const std::string &model_path, const std::string &params_path);
+
+        // Run predictor
+        void Run(cv::Mat &img, std::vector<float> &out_data, std::vector<int> &idx,
+                 std::vector<double> &times);
+
+    private:
+        std::shared_ptr <Predictor> predictor_;
+
+        bool use_gpu_ = false;
+        int gpu_id_ = 0;
+        int gpu_mem_ = 4000;
+        int cpu_math_library_num_threads_ = 4;
+        bool use_mkldnn_ = false;
+        bool use_tensorrt_ = false;
+        bool use_fp16_ = false;
+        bool ir_optim_ = true;
+
+        std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
+        std::vector<float> std_ = {0.229f, 0.224f, 0.225f};
+        float scale_ = 0.00392157;
+
+        int resize_short_size_ = 256;
+        int crop_size_ = 224;
+
+        // pre-process
+        ResizeImg resize_op_;
+        Normalize normalize_op_;
+        Permute permute_op_;
+        CenterCropImg crop_op_;
+    };
 
 } // namespace PaddleClas

deploy/cpp/include/cls_config.h

@@ -14,6 +14,14 @@
 
 #pragma once
 
+#ifdef WIN32
+#define OS_PATH_SEP "\\"
+#else
+#define OS_PATH_SEP "/"
+#endif
+
+#include "include/utility.h"
+#include "yaml-cpp/yaml.h"
 #include <iomanip>
 #include <iostream>
 #include <map>
@@ -21,70 +29,105 @@
 #include <string>
 #include <vector>
 
-#include "include/utility.h"
-
 namespace PaddleClas {
 
-class ClsConfig {
-public:
-  explicit ClsConfig(const std::string &config_file) {
-    config_map_ = LoadConfig(config_file);
-
-    this->use_gpu = bool(stoi(config_map_["use_gpu"]));
-
-    this->gpu_id = stoi(config_map_["gpu_id"]);
-
-    this->gpu_mem = stoi(config_map_["gpu_mem"]);
-
-    this->cpu_threads = stoi(config_map_["cpu_threads"]);
-
-    this->use_mkldnn = bool(stoi(config_map_["use_mkldnn"]));
-
-    this->use_tensorrt = bool(stoi(config_map_["use_tensorrt"]));
-    this->use_fp16 = bool(stoi(config_map_["use_fp16"]));
-
-    this->cls_model_path.assign(config_map_["cls_model_path"]);
-
-    this->cls_params_path.assign(config_map_["cls_params_path"]);
-
-    this->resize_short_size = stoi(config_map_["resize_short_size"]);
-
-    this->crop_size = stoi(config_map_["crop_size"]);
-
-    this->benchmark = bool(stoi(config_map_["benchmark"]));
-  }
-
-  bool use_gpu = false;
-
-  int gpu_id = 0;
-
-  int gpu_mem = 4000;
-
-  int cpu_threads = 1;
-
-  bool use_mkldnn = false;
-
-  bool use_tensorrt = false;
-  bool use_fp16 = false;
-  bool benchmark = false;
-
-  std::string cls_model_path;
-
-  std::string cls_params_path;
-
-  int resize_short_size = 256;
-  int crop_size = 224;
-
-  void PrintConfigInfo();
-
-private:
-  // Load configuration
-  std::map<std::string, std::string> LoadConfig(const std::string &config_file);
-
-  std::vector<std::string> split(const std::string &str,
-                                 const std::string &delim);
-
-  std::map<std::string, std::string> config_map_;
-};
-
+    class ClsConfig {
+    public:
+        explicit ClsConfig(const std::string &path) {
+            ReadYamlConfig(path);
+            this->infer_imgs =
+                    this->config_file["Global"]["infer_imgs"].as<std::string>();
+            this->batch_size = this->config_file["Global"]["batch_size"].as<int>();
+            this->use_gpu = this->config_file["Global"]["use_gpu"].as<bool>();
+            if (this->config_file["Global"]["gpu_id"].IsDefined())
+                this->gpu_id = this->config_file["Global"]["gpu_id"].as<int>();
+            else
+                this->gpu_id = 0;
+            this->gpu_mem = this->config_file["Global"]["gpu_mem"].as<int>();
+            this->cpu_threads =
+                    this->config_file["Global"]["cpu_num_threads"].as<int>();
+            this->use_mkldnn = this->config_file["Global"]["enable_mkldnn"].as<bool>();
+            this->use_tensorrt = this->config_file["Global"]["use_tensorrt"].as<bool>();
+            this->use_fp16 = this->config_file["Global"]["use_fp16"].as<bool>();
+            this->enable_benchmark =
+                    this->config_file["Global"]["enable_benchmark"].as<bool>();
+            this->ir_optim = this->config_file["Global"]["ir_optim"].as<bool>();
+            this->enable_profile =
+                    this->config_file["Global"]["enable_profile"].as<bool>();
+            this->cls_model_path =
+                    this->config_file["Global"]["inference_model_dir"].as<std::string>() +
+                    OS_PATH_SEP + "inference.pdmodel";
+            this->cls_params_path =
+                    this->config_file["Global"]["inference_model_dir"].as<std::string>() +
+                    OS_PATH_SEP + "inference.pdiparams";
+            this->resize_short_size =
+                    this->config_file["PreProcess"]["transform_ops"][0]["ResizeImage"]
+                    ["resize_short"]
+                            .as<int>();
+            this->crop_size =
+                    this->config_file["PreProcess"]["transform_ops"][1]["CropImage"]["size"]
+                            .as<int>();
+            this->scale = this->config_file["PreProcess"]["transform_ops"][2]
+            ["NormalizeImage"]["scale"]
+                    .as<float>();
+            this->mean = this->config_file["PreProcess"]["transform_ops"][2]
+                         ["NormalizeImage"]["mean"]
+                                 .as < std::vector < float >> ();
+            this->std = this->config_file["PreProcess"]["transform_ops"][2]
+                        ["NormalizeImage"]["std"]
+                                .as < std::vector < float >> ();
+            if (this->config_file["Global"]["benchmark"].IsDefined())
+                this->benchmark = this->config_file["Global"]["benchmark"].as<bool>();
+            else
+                this->benchmark = false;
+
+            if (this->config_file["PostProcess"]["Topk"]["topk"].IsDefined())
+                this->topk = this->config_file["PostProcess"]["Topk"]["topk"].as<int>();
+            if (this->config_file["PostProcess"]["Topk"]["class_id_map_file"]
+                    .IsDefined())
+                this->class_id_map_path =
+                        this->config_file["PostProcess"]["Topk"]["class_id_map_file"]
+                                .as<std::string>();
+            if (this->config_file["PostProcess"]["SavePreLabel"]["save_dir"]
+                    .IsDefined())
+                this->label_save_dir =
+                        this->config_file["PostProcess"]["SavePreLabel"]["save_dir"]
+                                .as<std::string>();
+            ReadLabelMap();
+        }
+
+        YAML::Node config_file;
+        bool use_gpu = false;
+        int gpu_id = 0;
+        int gpu_mem = 4000;
+        int cpu_threads = 1;
+        bool use_mkldnn = false;
+        bool use_tensorrt = false;
+        bool use_fp16 = false;
+        bool benchmark = false;
+        int batch_size = 1;
+        bool enable_benchmark = false;
+        bool ir_optim = true;
+        bool enable_profile = false;
+
+        std::string cls_model_path;
+        std::string cls_params_path;
+        std::string infer_imgs;
+
+        int resize_short_size = 256;
+        int crop_size = 224;
+        float scale = 0.00392157;
+        std::vector<float> mean = {0.485, 0.456, 0.406};
+        std::vector<float> std = {0.229, 0.224, 0.225};
+        int topk = 5;
+        std::string class_id_map_path;
+        std::map<int, std::string> id_map;
+        std::string label_save_dir;
+
+        void PrintConfigInfo();
+
+        void ReadLabelMap();
+
+        void ReadYamlConfig(const std::string &path);
+    };
 } // namespace PaddleClas

deploy/cpp/include/preprocess_op.h

 // Copyright (c) 2020 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.
+// 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
@@ -31,26 +31,26 @@ using namespace std;
 
 namespace PaddleClas {
 
-class Normalize {
-public:
-  virtual void Run(cv::Mat *im, const std::vector<float> &mean,
-                   const std::vector<float> &scale, const bool is_scale = true);
-};
+    class Normalize {
+    public:
+        virtual void Run(cv::Mat *im, const std::vector<float> &mean,
+                         const std::vector<float> &std, float &scale);
+    };
 
 // RGB -> CHW
-class Permute {
-public:
-  virtual void Run(const cv::Mat *im, float *data);
-};
-
-class CenterCropImg {
-public:
-  virtual void Run(cv::Mat &im, const int crop_size = 224);
-};
-
-class ResizeImg {
-public:
-  virtual void Run(const cv::Mat &img, cv::Mat &resize_img, int max_size_len);
-};
-
-} // namespace PaddleClas
+    class Permute {
+    public:
+        virtual void Run(const cv::Mat *im, float *data);
+    };
+
+    class CenterCropImg {
+    public:
+        virtual void Run(cv::Mat &im, const int crop_size = 224);
+    };
+
+    class ResizeImg {
+    public:
+        virtual void Run(const cv::Mat &img, cv::Mat &resize_img, int max_size_len);
+    };
+
+} // namespace PaddleClas
\ No newline at end of file

deploy/cpp/include/utility.h

@@ -32,15 +32,15 @@
 
 namespace PaddleClas {
 
-class Utility {
-public:
-  static std::vector<std::string> ReadDict(const std::string &path);
-
-  //   template <class ForwardIterator>
-  //   inline static size_t argmax(ForwardIterator first, ForwardIterator last)
-  //   {
-  //     return std::distance(first, std::max_element(first, last));
-  //   }
-};
+    class Utility {
+    public:
+        static std::vector <std::string> ReadDict(const std::string &path);
+
+        //   template <class ForwardIterator>
+        //   inline static size_t argmax(ForwardIterator first, ForwardIterator last)
+        //   {
+        //     return std::distance(first, std::max_element(first, last));
+        //   }
+    };
 
 } // namespace PaddleClas
\ No newline at end of file

deploy/cpp/readme.md

@@ -122,12 +122,11 @@ build/paddle_inference_install_dir/
 
 * [Paddle预测库官网](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/05_inference_deployment/inference/build_and_install_lib_cn.html#id1)上提供了不同cuda版本的Linux预测库，可以在官网查看并选择合适的预测库版本，注意必须选择`develop`版本。
 
-  以`ubuntu14.04_cuda9.0_cudnn7_avx_mkl`的`develop`版本为例，使用下述命令下载并解压：
+  以`2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2`的`develop`版本为例，使用下述命令下载并解压：
 
 
 ```shell
-wget https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda9-cudnn7-avx-mkl/paddle_inference.tgz
-
+wget https://paddle-inference-lib.bj.bcebos.com/2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2/paddle_inference.tgz
 tar -xvf paddle_inference.tgz
 ```
 
@@ -143,10 +142,10 @@ tar -xvf paddle_inference.tgz
 
 ```
 inference/
-|--cls_infer.pdmodel
-|--cls_infer.pdiparams
+|--inference.pdmodel
+|--inference.pdiparams
 ```
-**注意**：上述文件中，`cls_infer.pdmodel`文件存储了模型结构信息，`cls_infer.pdiparams`文件存储了模型参数信息。注意两个文件的路径需要与配置文件`tools/config.txt`中的`cls_model_path`和`cls_params_path`参数对应一致。
+**注意**：上述文件中，`inference.pdmodel`文件存储了模型结构信息，`inference.pdiparams`文件存储了模型参数信息。模型目录可以随意设置，但是模型名字不能修改。
 
 ### 2.2 编译PaddleClas C++预测demo
 
@@ -183,6 +182,7 @@ cmake .. \
     -DCUDA_LIB=${CUDA_LIB_DIR} \
 
 make -j
+cd ..
 ```
 
 上述命令中，
@@ -200,31 +200,26 @@ make -j
 在执行上述命令，编译完成之后，会在当前路径下生成`build`文件夹，其中生成一个名为`clas_system`的可执行文件。
 
 
-### 运行demo
-* 首先修改`tools/config.txt`中对应字段：
-  * use_gpu：是否使用GPU；
-  * gpu_id：使用的GPU卡号；
-  * gpu_mem：显存；
-  * cpu_math_library_num_threads：底层科学计算库所用线程的数量；
-  * use_mkldnn：是否使用MKLDNN加速；
-  * use_tensorrt: 是否使用tensorRT进行加速；
-  * use_fp16：是否使用半精度浮点数进行计算，该选项仅在use_tensorrt为true时有效；
-  * cls_model_path：预测模型结构文件路径；
-  * cls_params_path：预测模型参数文件路径；
-  * resize_short_size：预处理时图像缩放大小；
-  * crop_size：预处理时图像裁剪后的大小。
+### 2.3 运行demo
+#### 2.3.1 设置配置文件
+
+```shell
+cp ../configs/inference_cls.yaml tools/
+```
+
+根据[python预测推理](../../docs/zh_CN/inference_deployment/python_deploy.md)的`图像分类推理`部分修改好`tools`目录下`inference_cls.yaml`文件。`yaml`文件的参数说明详见[python预测推理](../../docs/zh_CN/inference_deployment/python_deploy.md)。
 
-* 然后修改`tools/run.sh`：
-  * `./build/clas_system ./tools/config.txt ./docs/imgs/ILSVRC2012_val_00000666.JPEG`
-  * 上述命令中分别为：编译得到的可执行文件`clas_system`；运行时的配置文件`config.txt`；待预测的图像。
+请根据实际存放文件，修改好`Global.infer_imgs`、`Global.inference_model_dir`、`PostProcess.Topk.topk`、`PostProcess.Topk.class_id_map_file`等参数。
 
-* 最后执行以下命令，完成对一幅图像的分类。
+#### 2.3.2 执行
 
 ```shell
-sh tools/run.sh
+./build/clas_system -c tools/inference_cls.yaml
+# or
+./build/clas_system -config tools/inference_cls.yaml
 ```
 
-* 最终屏幕上会输出结果，如下图所示。
+最终屏幕上会输出结果，如下图所示。
 
 <div align="center">
     <img src="./docs/imgs/cpp_infer_result.png" width="600">

deploy/cpp/src/cls.cpp

@@ -12,102 +12,105 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <algorithm>
 #include <include/cls.h>
+#include <numeric>
 
 namespace PaddleClas {
 
-void Classifier::LoadModel(const std::string &model_path,
-                           const std::string &params_path) {
-  paddle_infer::Config config;
-  config.SetModel(model_path, params_path);
-
-  if (this->use_gpu_) {
-    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
-    if (this->use_tensorrt_) {
-      config.EnableTensorRtEngine(
-          1 << 20, 1, 3,
-          this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
-                          : paddle_infer::Config::Precision::kFloat32,
-          false, false);
+    void Classifier::LoadModel(const std::string &model_path,
+                               const std::string &params_path) {
+        paddle_infer::Config config;
+        config.SetModel(model_path, params_path);
+
+        if (this->use_gpu_) {
+            config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+            if (this->use_tensorrt_) {
+                config.EnableTensorRtEngine(
+                        1 << 20, 1, 3,
+                        this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
+                                        : paddle_infer::Config::Precision::kFloat32,
+                        false, false);
+            }
+        } else {
+            config.DisableGpu();
+            if (this->use_mkldnn_) {
+                config.EnableMKLDNN();
+                // cache 10 different shapes for mkldnn to avoid memory leak
+                config.SetMkldnnCacheCapacity(10);
+            }
+            config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+        }
+
+        config.SwitchUseFeedFetchOps(false);
+        // true for multiple input
+        config.SwitchSpecifyInputNames(true);
+
+        config.SwitchIrOptim(this->ir_optim_);
+
+        config.EnableMemoryOptim();
+        config.DisableGlogInfo();
+
+        this->predictor_ = CreatePredictor(config);
     }
-  } else {
-    config.DisableGpu();
-    if (this->use_mkldnn_) {
-      config.EnableMKLDNN();
-      // cache 10 different shapes for mkldnn to avoid memory leak
-      config.SetMkldnnCacheCapacity(10);
-    }
-    config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
-  }
-
-  config.SwitchUseFeedFetchOps(false);
-  // true for multiple input
-  config.SwitchSpecifyInputNames(true);
-
-  config.SwitchIrOptim(true);
-
-  config.EnableMemoryOptim();
-  config.DisableGlogInfo();
-
-  this->predictor_ = CreatePredictor(config);
-}
-
-double Classifier::Run(cv::Mat &img, std::vector<double> *times) {
-  cv::Mat srcimg;
-  cv::Mat resize_img;
-  img.copyTo(srcimg);
-
-  auto preprocess_start = std::chrono::system_clock::now();
-  this->resize_op_.Run(img, resize_img, this->resize_short_size_);
-
-  this->crop_op_.Run(resize_img, this->crop_size_);
-
-  this->normalize_op_.Run(&resize_img, this->mean_, this->scale_,
-                          this->is_scale_);
-  std::vector<float> input(1 * 3 * resize_img.rows * resize_img.cols, 0.0f);
-  this->permute_op_.Run(&resize_img, input.data());
-
-  auto input_names = this->predictor_->GetInputNames();
-  auto input_t = this->predictor_->GetInputHandle(input_names[0]);
-  input_t->Reshape({1, 3, resize_img.rows, resize_img.cols});
-  auto preprocess_end = std::chrono::system_clock::now();
-
-  auto infer_start = std::chrono::system_clock::now();
-  input_t->CopyFromCpu(input.data());
-  this->predictor_->Run();
-
-  std::vector<float> out_data;
-  auto output_names = this->predictor_->GetOutputNames();
-  auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
-  std::vector<int> output_shape = output_t->shape();
-  int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1,
-                                std::multiplies<int>());
-
-  out_data.resize(out_num);
-  output_t->CopyToCpu(out_data.data());
-  auto infer_end = std::chrono::system_clock::now();
-
-  auto postprocess_start = std::chrono::system_clock::now();
-  int maxPosition =
-      max_element(out_data.begin(), out_data.end()) - out_data.begin();
-  auto postprocess_end = std::chrono::system_clock::now();
-
-  std::chrono::duration<float> preprocess_diff =
-      preprocess_end - preprocess_start;
-  times->push_back(double(preprocess_diff.count() * 1000));
-  std::chrono::duration<float> inference_diff = infer_end - infer_start;
-  double inference_cost_time = double(inference_diff.count() * 1000);
-  times->push_back(inference_cost_time);
-  std::chrono::duration<float> postprocess_diff =
-      postprocess_end - postprocess_start;
-  times->push_back(double(postprocess_diff.count() * 1000));
-
-  std::cout << "result: " << std::endl;
-  std::cout << "\tclass id: " << maxPosition << std::endl;
-  std::cout << std::fixed << std::setprecision(10)
-            << "\tscore: " << double(out_data[maxPosition]) << std::endl;
-
-  return inference_cost_time;
-}
 
+    void Classifier::Run(cv::Mat &img, std::vector<float> &out_data,
+                         std::vector<int> &idx, std::vector<double> &times) {
+        cv::Mat srcimg;
+        cv::Mat resize_img;
+        img.copyTo(srcimg);
+
+        auto preprocess_start = std::chrono::system_clock::now();
+        this->resize_op_.Run(img, resize_img, this->resize_short_size_);
+
+        this->crop_op_.Run(resize_img, this->crop_size_);
+
+        this->normalize_op_.Run(&resize_img, this->mean_, this->std_, this->scale_);
+        std::vector<float> input(1 * 3 * resize_img.rows * resize_img.cols, 0.0f);
+        this->permute_op_.Run(&resize_img, input.data());
+
+        auto input_names = this->predictor_->GetInputNames();
+        auto input_t = this->predictor_->GetInputHandle(input_names[0]);
+        input_t->Reshape({1, 3, resize_img.rows, resize_img.cols});
+        auto preprocess_end = std::chrono::system_clock::now();
+
+        auto infer_start = std::chrono::system_clock::now();
+        input_t->CopyFromCpu(input.data());
+        this->predictor_->Run();
+
+        auto output_names = this->predictor_->GetOutputNames();
+        auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
+        std::vector<int> output_shape = output_t->shape();
+        int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1,
+                                      std::multiplies<int>());
+
+        out_data.resize(out_num);
+        idx.resize(out_num);
+        output_t->CopyToCpu(out_data.data());
+        auto infer_end = std::chrono::system_clock::now();
+
+        auto postprocess_start = std::chrono::system_clock::now();
+        // int maxPosition =
+        //       max_element(out_data.begin(), out_data.end()) - out_data.begin();
+        iota(idx.begin(), idx.end(), 0);
+        stable_sort(idx.begin(), idx.end(), [&out_data](int i1, int i2) {
+            return out_data[i1] > out_data[i2];
+        });
+        auto postprocess_end = std::chrono::system_clock::now();
+
+        std::chrono::duration<float> preprocess_diff =
+                preprocess_end - preprocess_start;
+        times[0] = double(preprocess_diff.count() * 1000);
+        std::chrono::duration<float> inference_diff = infer_end - infer_start;
+        double inference_cost_time = double(inference_diff.count() * 1000);
+        times[1] = inference_cost_time;
+        std::chrono::duration<float> postprocess_diff =
+                postprocess_end - postprocess_start;
+        times[2] = double(postprocess_diff.count() * 1000);
+
+        /* std::cout << "result: " << std::endl; */
+        /* std::cout << "\tclass id: " << maxPosition << std::endl; */
+        /* std::cout << std::fixed << std::setprecision(10) */
+        /* << "\tscore: " << double(out_data[maxPosition]) << std::endl; */
+    }
 } // namespace PaddleClas

deploy/cpp/src/cls_config.cpp

@@ -13,52 +13,40 @@
 // limitations under the License.
 
 #include <include/cls_config.h>
+#include <ostream>
 
 namespace PaddleClas {
 
-std::vector<std::string> ClsConfig::split(const std::string &str,
-                                          const std::string &delim) {
-  std::vector<std::string> res;
-  if ("" == str)
-    return res;
-  char *strs = new char[str.length() + 1];
-  std::strcpy(strs, str.c_str());
-
-  char *d = new char[delim.length() + 1];
-  std::strcpy(d, delim.c_str());
-
-  char *p = std::strtok(strs, d);
-  while (p) {
-    std::string s = p;
-    res.push_back(s);
-    p = std::strtok(NULL, d);
-  }
-
-  return res;
-}
+    void ClsConfig::PrintConfigInfo() {
+        std::cout << "=======Paddle Class inference config======" << std::endl;
+        std::cout << this->config_file << std::endl;
+        std::cout << "=======End of Paddle Class inference config======" << std::endl;
+    }
 
-std::map<std::string, std::string>
-ClsConfig::LoadConfig(const std::string &config_path) {
-  auto config = Utility::ReadDict(config_path);
+    void ClsConfig::ReadYamlConfig(const std::string &path) {
 
-  std::map<std::string, std::string> dict;
-  for (int i = 0; i < config.size(); i++) {
-    // pass for empty line or comment
-    if (config[i].size() <= 1 || config[i][0] == '#') {
-      continue;
+        try {
+            this->config_file = YAML::LoadFile(path);
+        } catch (YAML::BadFile &e) {
+            std::cout << "Something wrong in yaml file, please check yaml file"
+                      << std::endl;
+            exit(1);
+        }
     }
-    std::vector<std::string> res = split(config[i], " ");
-    dict[res[0]] = res[1];
-  }
-  return dict;
-}
-
-void ClsConfig::PrintConfigInfo() {
-  std::cout << "=======Paddle Class inference config======" << std::endl;
-  for (auto iter = config_map_.begin(); iter != config_map_.end(); iter++) {
-    std::cout << iter->first << " : " << iter->second << std::endl;
-  }
-  std::cout << "=======End of Paddle Class inference config======" << std::endl;
-}
 
-} // namespace PaddleClas
+    void ClsConfig::ReadLabelMap() {
\ No newline at end of file
+        if (this->class_id_map_path.empty()) {
+            std::cout << "The Class Label file dose not input" << std::endl;
+            return;
+        }
+        std::ifstream in(this->class_id_map_path);
+        std::string line;
+        if (in) {
+            while (getline(in, line)) {
+                int split_flag = line.find_first_of(" ");
+                this->id_map[std::stoi(line.substr(0, split_flag))] =
+                        line.substr(split_flag + 1, line.size());
+            }
+        }
+    }
+}; // namespace PaddleClas

deploy/cpp/src/main.cpp

@@ -22,11 +22,13 @@
 #include <ostream>
 #include <vector>
 
+#include <algorithm>
 #include <cstring>
 #include <fstream>
 #include <numeric>
 
 #include <auto_log/autolog.h>
+#include <gflags/gflags.h>
 #include <include/cls.h>
 #include <include/cls_config.h>
 
@@ -34,74 +36,102 @@ using namespace std;
 using namespace cv;
 using namespace PaddleClas;
 
-int main(int argc, char **argv) {
-  if (argc < 3) {
-    std::cerr << "[ERROR] usage: " << argv[0]
-              << " configure_filepath image_path\n";
-    exit(1);
-  }
-
-  ClsConfig config(argv[1]);
-
-  config.PrintConfigInfo();
-
-  std::string path(argv[2]);
+DEFINE_string(config,
+"", "Path of yaml file");
+DEFINE_string(c,
+"", "Path of yaml file");
 
-  std::vector<std::string> img_files_list;
-  if (cv::utils::fs::isDirectory(path)) {
-    std::vector<cv::String> filenames;
-    cv::glob(path, filenames);
-    for (auto f : filenames) {
-      img_files_list.push_back(f);
+int main(int argc, char **argv) {
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    std::string yaml_path = "";
+    if (FLAGS_config == "" && FLAGS_c == "") {
+        std::cerr << "[ERROR] usage: " << std::endl
+                  << argv[0] << " -c $yaml_path" << std::endl
+                  << "or:" << std::endl
+                  << argv[0] << " -config $yaml_path" << std::endl;
+        exit(1);
+    } else if (FLAGS_config != "") {
+        yaml_path = FLAGS_config;
+    } else {
+        yaml_path = FLAGS_c;
     }
-  } else {
-    img_files_list.push_back(path);
-  }
-
-  std::cout << "img_file_list length: " << img_files_list.size() << std::endl;
-
-  Classifier classifier(config.cls_model_path, config.cls_params_path,
-                        config.use_gpu, config.gpu_id, config.gpu_mem,
-                        config.cpu_threads, config.use_mkldnn,
-                        config.use_tensorrt, config.use_fp16,
-                        config.resize_short_size, config.crop_size);
-
-  double elapsed_time = 0.0;
-  std::vector<double> cls_times;
-  int warmup_iter = img_files_list.size() > 5 ? 5 : 0;
-  for (int idx = 0; idx < img_files_list.size(); ++idx) {
-    std::string img_path = img_files_list[idx];
-    cv::Mat srcimg = cv::imread(img_path, cv::IMREAD_COLOR);
-    if (!srcimg.data) {
-      std::cerr << "[ERROR] image read failed! image path: " << img_path
-                << "\n";
-      exit(-1);
+    ClsConfig config(yaml_path);
+    config.PrintConfigInfo();
+
+    std::string path(config.infer_imgs);
+
+    std::vector <std::string> img_files_list;
+    if (cv::utils::fs::isDirectory(path)) {
+        std::vector <cv::String> filenames;
+        cv::glob(path, filenames);
+        for (auto f : filenames) {
+            img_files_list.push_back(f);
+        }
+    } else {
+        img_files_list.push_back(path);
     }
 
-    cv::cvtColor(srcimg, srcimg, cv::COLOR_BGR2RGB);
-
-    double run_time = classifier.Run(srcimg, &cls_times);
-    if (idx >= warmup_iter) {
-      elapsed_time += run_time;
-      std::cout << "Current image path: " << img_path << std::endl;
-      std::cout << "Current time cost: " << run_time << " s, "
-                << "average time cost in all: "
-                << elapsed_time / (idx + 1 - warmup_iter) << " s." << std::endl;
-    } else {
-      std::cout << "Current time cost: " << run_time << " s." << std::endl;
+    std::cout << "img_file_list length: " << img_files_list.size() << std::endl;
+
+    Classifier classifier(config);
+
+    std::vector<double> cls_times = {0, 0, 0};
+    std::vector<double> cls_times_total = {0, 0, 0};
+    double infer_time;
+    std::vector<float> out_data;
+    std::vector<int> result_index;
+    int warmup_iter = 5;
+    bool label_output_equal_flag = true;
+    for (int idx = 0; idx < img_files_list.size(); ++idx) {
+        std::string img_path = img_files_list[idx];
+        cv::Mat srcimg = cv::imread(img_path, cv::IMREAD_COLOR);
+        if (!srcimg.data) {
+            std::cerr << "[ERROR] image read failed! image path: " << img_path
+                      << "\n";
+            exit(-1);
+        }
+
+        cv::cvtColor(srcimg, srcimg, cv::COLOR_BGR2RGB);
+        classifier.Run(srcimg, out_data, result_index, cls_times);
+        if (label_output_equal_flag and out_data.size() != config.id_map.size()) {
+            std::cout << "Warning: the label size is not equal to output size!"
+                      << std::endl;
+            label_output_equal_flag = false;
+        }
+
+        int max_len = std::min(config.topk, int(out_data.size()));
+        std::cout << "Current image path: " << img_path << std::endl;
+        infer_time = cls_times[0] + cls_times[1] + cls_times[2];
+        std::cout << "Current total inferen time cost: " << infer_time << " ms."
+                  << std::endl;
+        for (int i = 0; i < max_len; ++i) {
+            printf("\tTop%d: class_id: %d, score: %.4f, ", i + 1, result_index[i],
+                   out_data[result_index[i]]);
+            if (label_output_equal_flag)
+                printf("label: %s\n", config.id_map[result_index[i]].c_str());
+        }
+        if (idx >= warmup_iter) {
+            for (int i = 0; i < cls_times.size(); ++i)
+                cls_times_total[i] += cls_times[i];
+        }
     }
-  }
+    if (img_files_list.size() > warmup_iter) {
 
-  std::string presion = "fp32";
+        infer_time = cls_times_total[0] + cls_times_total[1] + cls_times_total[2];
+        std::cout << "average time cost in all: "
+                  << infer_time / (img_files_list.size() - warmup_iter) << " ms."
+                  << std::endl;
+    }
 
-  if (config.use_fp16)
-    presion = "fp16";
-  if (config.benchmark) {
-    AutoLogger autolog("Classification", config.use_gpu, config.use_tensorrt,
-                       config.use_mkldnn, config.cpu_threads, 1,
-                       "1, 3, 224, 224", presion, cls_times,
-                       img_files_list.size());
-    autolog.report();
-  }
-  return 0;
+    std::string presion = "fp32";
+    if (config.use_fp16)
+        presion = "fp16";
+    if (config.benchmark) {
+        AutoLogger autolog("Classification", config.use_gpu, config.use_tensorrt,
+                           config.use_mkldnn, config.cpu_threads, 1,
+                           "1, 3, 224, 224", presion, cls_times_total,
+                           img_files_list.size());
+        autolog.report();
+    }
+    return 0;
 }

deploy/cpp/src/preprocess_op.cpp

@@ -32,59 +32,57 @@
 
 namespace PaddleClas {
 
-void Permute::Run(const cv::Mat *im, float *data) {
-  int rh = im->rows;
-  int rw = im->cols;
-  int rc = im->channels();
-  for (int i = 0; i < rc; ++i) {
-    cv::extractChannel(*im, cv::Mat(rh, rw, CV_32FC1, data + i * rh * rw), i);
-  }
-}
+    void Permute::Run(const cv::Mat *im, float *data) {
+        int rh = im->rows;
+        int rw = im->cols;
+        int rc = im->channels();
+        for (int i = 0; i < rc; ++i) {
+            cv::extractChannel(*im, cv::Mat(rh, rw, CV_32FC1, data + i * rh * rw), i);
+        }
+    }
 
-void Normalize::Run(cv::Mat *im, const std::vector<float> &mean,
-                    const std::vector<float> &scale, const bool is_scale) {
-  double e = 1.0;
-  if (is_scale) {
-    e /= 255.0;
-  }
-  (*im).convertTo(*im, CV_32FC3, e);
-  for (int h = 0; h < im->rows; h++) {
-    for (int w = 0; w < im->cols; w++) {
-      im->at<cv::Vec3f>(h, w)[0] =
-          (im->at<cv::Vec3f>(h, w)[0] - mean[0]) * scale[0];
-      im->at<cv::Vec3f>(h, w)[1] =
-          (im->at<cv::Vec3f>(h, w)[1] - mean[1]) * scale[1];
-      im->at<cv::Vec3f>(h, w)[2] =
-          (im->at<cv::Vec3f>(h, w)[2] - mean[2]) * scale[2];
+    void Normalize::Run(cv::Mat *im, const std::vector<float> &mean,
+                        const std::vector<float> &std, float &scale) {
+        if (scale) {
+            (*im).convertTo(*im, CV_32FC3, scale);
+        }
+        for (int h = 0; h < im->rows; h++) {
+            for (int w = 0; w < im->cols; w++) {
+                im->at<cv::Vec3f>(h, w)[0] =
+                        (im->at<cv::Vec3f>(h, w)[0] - mean[0]) / std[0];
+                im->at<cv::Vec3f>(h, w)[1] =
+                        (im->at<cv::Vec3f>(h, w)[1] - mean[1]) / std[1];
+                im->at<cv::Vec3f>(h, w)[2] =
+                        (im->at<cv::Vec3f>(h, w)[2] - mean[2]) / std[2];
+            }
+        }
     }
-  }
-}
 
-void CenterCropImg::Run(cv::Mat &img, const int crop_size) {
-  int resize_w = img.cols;
-  int resize_h = img.rows;
-  int w_start = int((resize_w - crop_size) / 2);
-  int h_start = int((resize_h - crop_size) / 2);
-  cv::Rect rect(w_start, h_start, crop_size, crop_size);
-  img = img(rect);
-}
+    void CenterCropImg::Run(cv::Mat &img, const int crop_size) {
+        int resize_w = img.cols;
+        int resize_h = img.rows;
+        int w_start = int((resize_w - crop_size) / 2);
+        int h_start = int((resize_h - crop_size) / 2);
+        cv::Rect rect(w_start, h_start, crop_size, crop_size);
+        img = img(rect);
+    }
 
-void ResizeImg::Run(const cv::Mat &img, cv::Mat &resize_img,
-                    int resize_short_size) {
-  int w = img.cols;
-  int h = img.rows;
+    void ResizeImg::Run(const cv::Mat &img, cv::Mat &resize_img,
+                        int resize_short_size) {
+        int w = img.cols;
+        int h = img.rows;
 
-  float ratio = 1.f;
-  if (h < w) {
-    ratio = float(resize_short_size) / float(h);
-  } else {
-    ratio = float(resize_short_size) / float(w);
-  }
+        float ratio = 1.f;
+        if (h < w) {
+            ratio = float(resize_short_size) / float(h);
+        } else {
+            ratio = float(resize_short_size) / float(w);
+        }
 
-  int resize_h = round(float(h) * ratio);
-  int resize_w = round(float(w) * ratio);
+        int resize_h = round(float(h) * ratio);
+        int resize_w = round(float(w) * ratio);
 
-  cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
-}
+        cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
+    }
 
-} // namespace PaddleClas
+} // namespace PaddleClas
\ No newline at end of file

deploy/cpp/src/utility.cpp

@@ -20,20 +20,20 @@
 
 namespace PaddleClas {
 
-std::vector<std::string> Utility::ReadDict(const std::string &path) {
-  std::ifstream in(path);
-  std::string line;
-  std::vector<std::string> m_vec;
-  if (in) {
-    while (getline(in, line)) {
-      m_vec.push_back(line);
+    std::vector <std::string> Utility::ReadDict(const std::string &path) {
+        std::ifstream in(path);
+        std::string line;
+        std::vector <std::string> m_vec;
+        if (in) {
+            while (getline(in, line)) {
+                m_vec.push_back(line);
+            }
+        } else {
+            std::cout << "no such label file: " << path << ", exit the program..."
+                      << std::endl;
+            exit(1);
+        }
+        return m_vec;
     }
-  } else {
-    std::cout << "no such label file: " << path << ", exit the program..."
-              << std::endl;
-    exit(1);
-  }
-  return m_vec;
-}
 
 } // namespace PaddleClas
\ No newline at end of file

deploy/cpp/tools/build.sh

-OPENCV_DIR=/work/project/project/cpp_infer/opencv-3.4.7/opencv3
-LIB_DIR=/work/project/project/cpp_infer/paddle_inference/
+OPENCV_DIR=/work/project/project/test/opencv-3.4.7/opencv3
+LIB_DIR=/work/project/project/test/paddle_inference/
 CUDA_LIB_DIR=/usr/local/cuda/lib64
 CUDNN_LIB_DIR=/usr/lib/x86_64-linux-gnu/
 
@@ -18,3 +18,4 @@ cmake .. \
     -DCUDA_LIB=${CUDA_LIB_DIR} \
 
 make -j
+cd ..

deploy/cpp/tools/config.txt

-# model load config
-use_gpu  0
-gpu_id  0
-gpu_mem  4000
-cpu_threads  10
-use_mkldnn 1
-use_tensorrt 0
-use_fp16 0
-
-# cls config
-cls_model_path  /PaddleClas/inference/cls_infer.pdmodel
-cls_params_path /PaddleClas/inference/cls_infer.pdiparams
-resize_short_size 256
-crop_size 224
-
-# for log env info
-benchmark 0

deploy/cpp/tools/run.sh

-./build/clas_system ./tools/config.txt ./docs/imgs/ILSVRC2012_val_00000666.JPEG

deploy/cpp_shitu/CMakeLists.txt

+project(pp_shitu CXX C)
+cmake_minimum_required(VERSION 3.14)
+
+option(WITH_MKL        "Compile demo with MKL/OpenBlas support, default use MKL."       ON)
+option(WITH_GPU        "Compile demo with GPU/CPU, default use CPU."                    OFF)
+option(WITH_STATIC_LIB "Compile demo with static/shared library, default use static."   ON)
+option(WITH_TENSORRT "Compile demo with TensorRT."   OFF)
+option(FAISS_WITH_MKL "Faiss Compile demo with MKL."   OFF)
+
+SET(PADDLE_LIB "" CACHE PATH "Location of libraries")
+SET(OPENCV_DIR "" CACHE PATH "Location of libraries")
+SET(CUDA_LIB "" CACHE PATH "Location of libraries")
+SET(CUDNN_LIB "" CACHE PATH "Location of libraries")
+SET(TENSORRT_DIR "" CACHE PATH "Compile demo with TensorRT")
+SET(FAISS_DIR "" CACHE PATH "Location of libraries")
+
+set(DEMO_NAME "pp_shitu")
+
+if (FAISS_WITH_MKL)
+   SET(BLAS_NAME "mklml_intel")
+else()
+   SET(BLAS_NAME "openblas")
+endif()
+
+include(external-cmake/yaml-cpp.cmake)
+include_directories("${CMAKE_SOURCE_DIR}/")
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/ext/yaml-cpp/src/ext-yaml-cpp/include")
+link_directories("${CMAKE_CURRENT_BINARY_DIR}/ext/yaml-cpp/lib")
+
+macro(safe_set_static_flag)
+    foreach(flag_var
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      if(${flag_var} MATCHES "/MD")
+        string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+      endif(${flag_var} MATCHES "/MD")
+    endforeach(flag_var)
+endmacro()
+
+
+if (WITH_MKL)
+    ADD_DEFINITIONS(-DUSE_MKL)
+endif()
+
+if(NOT DEFINED FAISS_DIR)
+  message(FATAL_ERROR "please set FAISS_DIR with -DFAISS_DIR=/path/faiss")
+endif()
+
+if(NOT DEFINED PADDLE_LIB)
+  message(FATAL_ERROR "please set PADDLE_LIB with -DPADDLE_LIB=/path/paddle/lib")
+endif()
+
+if(NOT DEFINED OPENCV_DIR)
+    message(FATAL_ERROR "please set OPENCV_DIR with -DOPENCV_DIR=/path/opencv")
+endif()
+
+if (WIN32)
+  include_directories("${FAISS_DIR}/include")
+  link_directories("${FAISS_DIR}/lib")
+  find_package(faiss REQUIRED PATHS ${FAISS_DIR}/share/faiss/ NO_DEFAULT_PATH)
+else()
+  find_package(faiss REQUIRED PATHS ${FAISS_DIR}/share/faiss NO_DEFAULT_PATH)
+  include_directories("${FAISS_DIR}/include")
+  link_directories("${FAISS_DIR}/lib")
+endif()
+
+if (WIN32)
+  include_directories("${PADDLE_LIB}/paddle/fluid/inference")
+  include_directories("${PADDLE_LIB}/paddle/include")
+  link_directories("${PADDLE_LIB}/paddle/fluid/inference")
+  find_package(OpenCV REQUIRED PATHS ${OPENCV_DIR}/build/ NO_DEFAULT_PATH)
+
+else ()
+  find_package(OpenCV REQUIRED PATHS ${OPENCV_DIR}/share/OpenCV NO_DEFAULT_PATH)
+  include_directories("${PADDLE_LIB}/paddle/include")
+  link_directories("${PADDLE_LIB}/paddle/lib")
+endif ()
+include_directories(${OpenCV_INCLUDE_DIRS})
+
+if (WIN32)
+    add_definitions("/DGOOGLE_GLOG_DLL_DECL=")
+    set(CMAKE_C_FLAGS_DEBUG   "${CMAKE_C_FLAGS_DEBUG} /bigobj /MTd")
+    set(CMAKE_C_FLAGS_RELEASE  "${CMAKE_C_FLAGS_RELEASE} /bigobj /MT")
+    set(CMAKE_CXX_FLAGS_DEBUG  "${CMAKE_CXX_FLAGS_DEBUG} /bigobj /MTd")
+    set(CMAKE_CXX_FLAGS_RELEASE   "${CMAKE_CXX_FLAGS_RELEASE} /bigobj /MT")
+    if (WITH_STATIC_LIB)
+        safe_set_static_flag()
+        add_definitions(-DSTATIC_LIB)
+    endif()
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O3 -std=c++11")
+    set(CMAKE_STATIC_LIBRARY_PREFIX "")
+endif()
+message("flags" ${CMAKE_CXX_FLAGS})
+
+
+if (WITH_GPU)
+    if (NOT DEFINED CUDA_LIB OR ${CUDA_LIB} STREQUAL "")
+        message(FATAL_ERROR "please set CUDA_LIB with -DCUDA_LIB=/path/cuda-8.0/lib64")
+    endif()
+    if (NOT WIN32)
+        if (NOT DEFINED CUDNN_LIB)
+            message(FATAL_ERROR "please set CUDNN_LIB with -DCUDNN_LIB=/path/cudnn_v7.4/cuda/lib64")
+        endif()
+    endif(NOT WIN32)
+endif()
+
+include_directories("${PADDLE_LIB}/third_party/install/protobuf/include")
+include_directories("${PADDLE_LIB}/third_party/install/glog/include")
+include_directories("${PADDLE_LIB}/third_party/install/gflags/include")
+include_directories("${PADDLE_LIB}/third_party/install/xxhash/include")
+include_directories("${PADDLE_LIB}/third_party/install/zlib/include")
+include_directories("${PADDLE_LIB}/third_party/boost")
+include_directories("${PADDLE_LIB}/third_party/eigen3")
+
+include_directories("${CMAKE_SOURCE_DIR}/")
+
+if (NOT WIN32)
+  if (WITH_TENSORRT AND WITH_GPU)
+     include_directories("${TENSORRT_DIR}/include")
+     link_directories("${TENSORRT_DIR}/lib")
+  endif()
+endif(NOT WIN32)
+
+link_directories("${PADDLE_LIB}/third_party/install/zlib/lib")
+
+link_directories("${PADDLE_LIB}/third_party/install/protobuf/lib")
+link_directories("${PADDLE_LIB}/third_party/install/glog/lib")
+link_directories("${PADDLE_LIB}/third_party/install/gflags/lib")
+link_directories("${PADDLE_LIB}/third_party/install/xxhash/lib")
+link_directories("${PADDLE_LIB}/paddle/lib")
+
+
+if(WITH_MKL)
+  include_directories("${PADDLE_LIB}/third_party/install/mklml/include")
+  if (WIN32)
+    set(MATH_LIB ${PADDLE_LIB}/third_party/install/mklml/lib/mklml.lib
+            ${PADDLE_LIB}/third_party/install/mklml/lib/libiomp5md.lib)
+  else ()
+    set(MATH_LIB ${PADDLE_LIB}/third_party/install/mklml/lib/libmklml_intel${CMAKE_SHARED_LIBRARY_SUFFIX}
+            ${PADDLE_LIB}/third_party/install/mklml/lib/libiomp5${CMAKE_SHARED_LIBRARY_SUFFIX})
+    execute_process(COMMAND cp -r ${PADDLE_LIB}/third_party/install/mklml/lib/libmklml_intel${CMAKE_SHARED_LIBRARY_SUFFIX} /usr/lib)
+  endif ()
+  set(MKLDNN_PATH "${PADDLE_LIB}/third_party/install/mkldnn")
+  if(EXISTS ${MKLDNN_PATH})
+    include_directories("${MKLDNN_PATH}/include")
+    if (WIN32)
+      set(MKLDNN_LIB ${MKLDNN_PATH}/lib/mkldnn.lib)
+    else ()
+      set(MKLDNN_LIB ${MKLDNN_PATH}/lib/libmkldnn.so.0)
+    endif ()
+  endif()
+else()
+  if (WIN32)
+    set(MATH_LIB ${PADDLE_LIB}/third_party/install/openblas/lib/openblas${CMAKE_STATIC_LIBRARY_SUFFIX})
+  else ()
+    set(MATH_LIB ${PADDLE_LIB}/third_party/install/openblas/lib/libopenblas${CMAKE_STATIC_LIBRARY_SUFFIX})
+  endif ()
+endif()
+
+# Note: libpaddle_inference_api.so/a must put before libpaddle_fluid.so/a
+if(WITH_STATIC_LIB)
+  if(WIN32)
+    set(DEPS
+        ${PADDLE_LIB}/paddle/lib/paddle_inference${CMAKE_STATIC_LIBRARY_SUFFIX})
+  else()
+    set(DEPS
+        ${PADDLE_LIB}/paddle/lib/libpaddle_inference${CMAKE_STATIC_LIBRARY_SUFFIX})
+  endif()
+else()
+  if(WIN32)
+    set(DEPS
+        ${PADDLE_LIB}/paddle/lib/paddle_inference${CMAKE_SHARED_LIBRARY_SUFFIX})
+  else()
+    set(DEPS
+        ${PADDLE_LIB}/paddle/lib/libpaddle_inference${CMAKE_SHARED_LIBRARY_SUFFIX})
+  endif()
+endif(WITH_STATIC_LIB)
+
+if (NOT WIN32)
+    set(DEPS ${DEPS}
+        ${MATH_LIB} ${MKLDNN_LIB}
+        glog gflags protobuf z xxhash yaml-cpp
+        )
+    if(EXISTS "${PADDLE_LIB}/third_party/install/snappystream/lib")
+        set(DEPS ${DEPS} snappystream)
+    endif()
+    if (EXISTS "${PADDLE_LIB}/third_party/install/snappy/lib")
+        set(DEPS ${DEPS} snappy)
+    endif()
+else()
+    set(DEPS ${DEPS}
+        ${MATH_LIB} ${MKLDNN_LIB}
+        glog gflags_static libprotobuf xxhash libyaml-cppmt)
+    set(DEPS ${DEPS} libcmt shlwapi)
+    if (EXISTS "${PADDLE_LIB}/third_party/install/snappy/lib")
+        set(DEPS ${DEPS} snappy)
+    endif()
+    if(EXISTS "${PADDLE_LIB}/third_party/install/snappystream/lib")
+        set(DEPS ${DEPS} snappystream)
+    endif()
+endif(NOT WIN32)
+
+
+if(WITH_GPU)
+  if(NOT WIN32)
+    if (WITH_TENSORRT)
+      set(DEPS ${DEPS} ${TENSORRT_DIR}/lib/libnvinfer${CMAKE_SHARED_LIBRARY_SUFFIX})
+      set(DEPS ${DEPS} ${TENSORRT_DIR}/lib/libnvinfer_plugin${CMAKE_SHARED_LIBRARY_SUFFIX})
+    endif()
+    set(DEPS ${DEPS} ${CUDA_LIB}/libcudart${CMAKE_SHARED_LIBRARY_SUFFIX})
+    set(DEPS ${DEPS} ${CUDNN_LIB}/libcudnn${CMAKE_SHARED_LIBRARY_SUFFIX})
+  else()
+    set(DEPS ${DEPS} ${CUDA_LIB}/cudart${CMAKE_STATIC_LIBRARY_SUFFIX} )
+    set(DEPS ${DEPS} ${CUDA_LIB}/cublas${CMAKE_STATIC_LIBRARY_SUFFIX} )
+    set(DEPS ${DEPS} ${CUDNN_LIB}/cudnn${CMAKE_STATIC_LIBRARY_SUFFIX})
+  endif()
+endif()
+
+
+if (NOT WIN32)
+    set(EXTERNAL_LIB "-ldl -lrt -lgomp -lz -lm -lpthread")
+    set(DEPS ${DEPS} ${EXTERNAL_LIB})
+endif()
+
+set(DEPS ${DEPS} ${OpenCV_LIBS})
+
+include(FetchContent)
+include(external-cmake/auto-log.cmake)
+include_directories(${FETCHCONTENT_BASE_DIR}/extern_autolog-src)
+
+
+AUX_SOURCE_DIRECTORY(./src SRCS)
+add_executable(${DEMO_NAME} ${SRCS})
+ADD_DEPENDENCIES(${DEMO_NAME} ext-yaml-cpp)
+target_link_libraries(${DEMO_NAME} ${DEPS})
+target_link_libraries(${DEMO_NAME} ${FAISS_DIR}/lib/libfaiss${CMAKE_STATIC_LIBRARY_SUFFIX})
+target_link_libraries(${DEMO_NAME} ${BLAS_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
+
+if (WIN32 AND WITH_MKL)
+    add_custom_command(TARGET ${DEMO_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PADDLE_LIB}/third_party/install/mklml/lib/mklml.dll ./mklml.dll
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PADDLE_LIB}/third_party/install/mklml/lib/libiomp5md.dll ./libiomp5md.dll
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PADDLE_LIB}/third_party/install/mkldnn/lib/mkldnn.dll ./mkldnn.dll
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PADDLE_LIB}/third_party/install/mklml/lib/mklml.dll ./release/mklml.dll
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PADDLE_LIB}/third_party/install/mklml/lib/libiomp5md.dll ./release/libiomp5md.dll
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PADDLE_LIB}/third_party/install/mkldnn/lib/mkldnn.dll ./release/mkldnn.dll
+    )
+endif()

deploy/cpp_shitu/external-cmake/auto-log.cmake

+find_package(Git REQUIRED)
+include(FetchContent)
+
+set(FETCHCONTENT_BASE_DIR "${CMAKE_CURRENT_BINARY_DIR}/third-party")
+
+FetchContent_Declare(
+  extern_Autolog
+  PREFIX autolog
+  GIT_REPOSITORY https://github.com/LDOUBLEV/AutoLog.git
+  GIT_TAG        main
+)
+FetchContent_MakeAvailable(extern_Autolog)

deploy/cpp_shitu/external-cmake/yaml-cpp.cmake

+
+find_package(Git REQUIRED)
+
+include(ExternalProject)
+
+message("${CMAKE_BUILD_TYPE}")
+
+ExternalProject_Add(
+        ext-yaml-cpp
+        URL https://bj.bcebos.com/paddlex/deploy/deps/yaml-cpp.zip
+        URL_MD5 9542d6de397d1fbd649ed468cb5850e6
+        CMAKE_ARGS
+        -DYAML_CPP_BUILD_TESTS=OFF
+		-DYAML_CPP_BUILD_TOOLS=OFF
+        -DYAML_CPP_INSTALL=OFF
+        -DYAML_CPP_BUILD_CONTRIB=OFF
+		-DMSVC_SHARED_RT=OFF
+		-DBUILD_SHARED_LIBS=OFF
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=${CMAKE_BINARY_DIR}/ext/yaml-cpp/lib
+        -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY=${CMAKE_BINARY_DIR}/ext/yaml-cpp/lib
+        PREFIX "${CMAKE_BINARY_DIR}/ext/yaml-cpp"
+        # Disable install step
+        INSTALL_COMMAND ""
+	    LOG_DOWNLOAD ON
+        LOG_BUILD 1
+)

deploy/cpp_shitu/include/feature_extracter.h

+// Copyright (c) 2020 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 "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include "paddle_inference_api.h"
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <vector>
+
+#include <cstring>
+#include <fstream>
+#include <numeric>
+
+#include <include/preprocess_op.h>
+#include <include/yaml_config.h>
+
+using namespace paddle_infer;
+
+namespace Feature {
+
+    class FeatureExtracter {
+    public:
+        explicit FeatureExtracter(const YAML::Node &config_file) {
+            this->use_gpu_ = config_file["Global"]["use_gpu"].as<bool>();
+            if (config_file["Global"]["gpu_id"].IsDefined())
+                this->gpu_id_ = config_file["Global"]["gpu_id"].as<int>();
+            else
+                this->gpu_id_ = 0;
+            this->gpu_mem_ = config_file["Global"]["gpu_mem"].as<int>();
+            this->cpu_math_library_num_threads_ =
+                    config_file["Global"]["cpu_num_threads"].as<int>();
+            this->use_mkldnn_ = config_file["Global"]["enable_mkldnn"].as<bool>();
+            this->use_tensorrt_ = config_file["Global"]["use_tensorrt"].as<bool>();
+            this->use_fp16_ = config_file["Global"]["use_fp16"].as<bool>();
+
+            this->cls_model_path_ =
+                    config_file["Global"]["rec_inference_model_dir"].as<std::string>() +
+                    OS_PATH_SEP + "inference.pdmodel";
+            this->cls_params_path_ =
+                    config_file["Global"]["rec_inference_model_dir"].as<std::string>() +
+                    OS_PATH_SEP + "inference.pdiparams";
+            this->resize_size_ =
+                    config_file["RecPreProcess"]["transform_ops"][0]["ResizeImage"]["size"]
+                            .as<int>();
+            this->scale_ = config_file["RecPreProcess"]["transform_ops"][1]["NormalizeImage"]["scale"].as<float>();
+            this->mean_ = config_file["RecPreProcess"]["transform_ops"][1]
+                          ["NormalizeImage"]["mean"]
+                                  .as < std::vector < float >> ();
+            this->std_ = config_file["RecPreProcess"]["transform_ops"][1]
+                         ["NormalizeImage"]["std"]
+                                 .as < std::vector < float >> ();
+            if (config_file["Global"]["rec_feature_normlize"].IsDefined())
+                this->feature_norm =
+                        config_file["Global"]["rec_feature_normlize"].as<bool>();
+
+            LoadModel(cls_model_path_, cls_params_path_);
+        }
+
+        // Load Paddle inference model
+        void LoadModel(const std::string &model_path, const std::string &params_path);
+
+        // Run predictor
+        void Run(cv::Mat &img, std::vector<float> &out_data,
+                 std::vector<double> &times);
+
+        void FeatureNorm(std::vector<float> &feature);
+
+        std::shared_ptr <Predictor> predictor_;
+
+    private:
+        bool use_gpu_ = false;
+        int gpu_id_ = 0;
+        int gpu_mem_ = 4000;
+        int cpu_math_library_num_threads_ = 4;
+        bool use_mkldnn_ = false;
+        bool use_tensorrt_ = false;
+        bool feature_norm = true;
+        bool use_fp16_ = false;
+        std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
+        std::vector<float> std_ = {0.229f, 0.224f, 0.225f};
+        float scale_ = 0.00392157;
+        int resize_size_ = 224;
+        int resize_short_ = 224;
+        std::string cls_model_path_;
+        std::string cls_params_path_;
+
+        // pre-process
+        ResizeImg resize_op_;
+        Normalize normalize_op_;
+        Permute permute_op_;
+    };
+
+} // namespace Feature

deploy/cpp_shitu/include/nms.h

+// Copyright (c) 2021 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.
+
+// This code is adpated from opencv(https://github.com/opencv/opencv)
+
+#include <algorithm>
+#include <include/object_detector.h>
+
+template<typename T>
+static inline bool SortScorePairDescend(const std::pair<float, T> &pair1,
+                                        const std::pair<float, T> &pair2) {
+    return pair1.first > pair2.first;
+}
+
+float RectOverlap(const Detection::ObjectResult &a,
+                  const Detection::ObjectResult &b) {
+    float Aa = (a.rect[2] - a.rect[0] + 1) * (a.rect[3] - a.rect[1] + 1);
+    float Ab = (b.rect[2] - b.rect[0] + 1) * (b.rect[3] - b.rect[1] + 1);
+
+    int iou_w = max(min(a.rect[2], b.rect[2]) - max(a.rect[0], b.rect[0]) + 1, 0);
+    int iou_h = max(min(a.rect[3], b.rect[3]) - max(a.rect[1], b.rect[1]) + 1, 0);
+    float Aab = iou_w * iou_h;
+    return Aab / (Aa + Ab - Aab);
+}
+
+// Get max scores with corresponding indices.
+//    scores: a set of scores.
+//    threshold: only consider scores higher than the threshold.
+//    top_k: if -1, keep all; otherwise, keep at most top_k.
+//    score_index_vec: store the sorted (score, index) pair.
+inline void
+GetMaxScoreIndex(const std::vector <Detection::ObjectResult> &det_result,
+                 const float threshold,
+                 std::vector <std::pair<float, int>> &score_index_vec) {
+    // Generate index score pairs.
+    for (size_t i = 0; i < det_result.size(); ++i) {
+        if (det_result[i].confidence > threshold) {
+            score_index_vec.push_back(std::make_pair(det_result[i].confidence, i));
+        }
+    }
+
+    // Sort the score pair according to the scores in descending order
+    std::stable_sort(score_index_vec.begin(), score_index_vec.end(),
+                     SortScorePairDescend<int>);
+
+    // // Keep top_k scores if needed.
+    // if (top_k > 0 && top_k < (int)score_index_vec.size())
+    // {
+    //     score_index_vec.resize(top_k);
+    // }
+}
+
+void NMSBoxes(const std::vector <Detection::ObjectResult> det_result,
+              const float score_threshold, const float nms_threshold,
+              std::vector<int> &indices) {
+    int a = 1;
+    // Get top_k scores (with corresponding indices).
+    std::vector <std::pair<float, int>> score_index_vec;
+    GetMaxScoreIndex(det_result, score_threshold, score_index_vec);
+
+    // Do nms
+    indices.clear();
+    for (size_t i = 0; i < score_index_vec.size(); ++i) {
+        const int idx = score_index_vec[i].second;
+        bool keep = true;
+        for (int k = 0; k < (int) indices.size() && keep; ++k) {
+            const int kept_idx = indices[k];
+            float overlap = RectOverlap(det_result[idx], det_result[kept_idx]);
+            keep = overlap <= nms_threshold;
+        }
+        if (keep)
+            indices.push_back(idx);
+    }
+}

deploy/cpp_shitu/include/object_detector.h

+//   Copyright (c) 2020 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 <ctime>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include "paddle_inference_api.h" // NOLINT
+
+#include "include/preprocess_op_det.h"
+#include "include/yaml_config.h"
+
+using namespace paddle_infer;
+
+namespace Detection {
+// Object Detection Result
+    struct ObjectResult {
+        // Rectangle coordinates of detected object: left, right, top, down
+        std::vector<int> rect;
+        // Class id of detected object
+        int class_id;
+        // Confidence of detected object
+        float confidence;
+    };
+
+// Generate visualization colormap for each class
+    std::vector<int> GenerateColorMap(int num_class);
+
+// Visualiztion Detection Result
+    cv::Mat VisualizeResult(const cv::Mat &img,
+                            const std::vector <ObjectResult> &results,
+                            const std::vector <std::string> &lables,
+                            const std::vector<int> &colormap, const bool is_rbox);
+
+    class ObjectDetector {
+    public:
+        explicit ObjectDetector(const YAML::Node &config_file) {
+            this->use_gpu_ = config_file["Global"]["use_gpu"].as<bool>();
+            if (config_file["Global"]["gpu_id"].IsDefined())
+                this->gpu_id_ = config_file["Global"]["gpu_id"].as<int>();
+            this->gpu_mem_ = config_file["Global"]["gpu_mem"].as<int>();
+            this->cpu_math_library_num_threads_ =
+                    config_file["Global"]["cpu_num_threads"].as<int>();
+            this->use_mkldnn_ = config_file["Global"]["enable_mkldnn"].as<bool>();
+            this->use_tensorrt_ = config_file["Global"]["use_tensorrt"].as<bool>();
+            this->use_fp16_ = config_file["Global"]["use_fp16"].as<bool>();
+            this->model_dir_ =
+                    config_file["Global"]["det_inference_model_dir"].as<std::string>();
+            this->threshold_ = config_file["Global"]["threshold"].as<float>();
+            this->max_det_results_ = config_file["Global"]["max_det_results"].as<int>();
+            this->image_shape_ =
+                    config_file["Global"]["image_shape"].as < std::vector < int >> ();
+            this->label_list_ =
+                    config_file["Global"]["labe_list"].as < std::vector < std::string >> ();
+            this->ir_optim_ = config_file["Global"]["ir_optim"].as<bool>();
+            this->batch_size_ = config_file["Global"]["batch_size"].as<int>();
+
+            preprocessor_.Init(config_file["DetPreProcess"]["transform_ops"]);
+            LoadModel(model_dir_, batch_size_, run_mode);
+        }
+
+        // Load Paddle inference model
+        void LoadModel(const std::string &model_dir, const int batch_size = 1,
+                       const std::string &run_mode = "fluid");
+
+        // Run predictor
+        void Predict(const std::vector <cv::Mat> imgs, const int warmup = 0,
+                     const int repeats = 1,
+                     std::vector <ObjectResult> *result = nullptr,
+                     std::vector<int> *bbox_num = nullptr,
+                     std::vector<double> *times = nullptr);
+
+        const std::vector <std::string> &GetLabelList() const {
+            return this->label_list_;
+        }
+
+        const float &GetThreshold() const { return this->threshold_; }
+
+    private:
+        bool use_gpu_ = true;
+        int gpu_id_ = 0;
+        int gpu_mem_ = 800;
+        int cpu_math_library_num_threads_ = 6;
+        std::string run_mode = "fluid";
+        bool use_mkldnn_ = false;
+        bool use_tensorrt_ = false;
+        bool batch_size_ = 1;
+        bool use_fp16_ = false;
+        std::string model_dir_;
+        float threshold_ = 0.5;
+        float max_det_results_ = 5;
+        std::vector<int> image_shape_ = {3, 640, 640};
+        std::vector <std::string> label_list_;
+        bool ir_optim_ = true;
+        bool det_permute_ = true;
+        bool det_postprocess_ = true;
+        int min_subgraph_size_ = 30;
+        bool use_dynamic_shape_ = false;
+        int trt_min_shape_ = 1;
+        int trt_max_shape_ = 1280;
+        int trt_opt_shape_ = 640;
+        bool trt_calib_mode_ = false;
+
+        // Preprocess image and copy data to input buffer
+        void Preprocess(const cv::Mat &image_mat);
+
+        // Postprocess result
+        void Postprocess(const std::vector <cv::Mat> mats,
+                         std::vector <ObjectResult> *result, std::vector<int> bbox_num,
+                         bool is_rbox);
+
+        std::shared_ptr <Predictor> predictor_;
+        Preprocessor preprocessor_;
+        ImageBlob inputs_;
+        std::vector<float> output_data_;
+        std::vector<int> out_bbox_num_data_;
+    };
+
+} // namespace Detection

deploy/cpp_shitu/include/preprocess_op.h

+// Copyright (c) 2020 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 "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <vector>
+
+#include <cstring>
+#include <fstream>
+#include <numeric>
+
+using namespace std;
+
+namespace Feature {
+
+    class Normalize {
+    public:
+        virtual void Run(cv::Mat *im, const std::vector<float> &mean,
+                         const std::vector<float> &std, float scale);
+    };
+
+// RGB -> CHW
+    class Permute {
+    public:
+        virtual void Run(const cv::Mat *im, float *data);
+    };
+
+    class CenterCropImg {
+    public:
+        virtual void Run(cv::Mat &im, const int crop_size = 224);
+    };
+
+    class ResizeImg {
+    public:
+        virtual void Run(const cv::Mat &img, cv::Mat &resize_img, int max_size_len,
+                         int size = 0);
+    };
+
+} // namespace Feature

deploy/cpp_shitu/include/preprocess_op_det.h

+//   Copyright (c) 2020 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 <glog/logging.h>
+#include <yaml-cpp/yaml.h>
+
+#include <iostream>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+namespace Detection {
+
+// Object for storing all preprocessed data
+    class ImageBlob {
+    public:
+        // image width and height
+        std::vector<float> im_shape_;
+        // Buffer for image data after preprocessing
+        std::vector<float> im_data_;
+        // in net data shape(after pad)
+        std::vector<float> in_net_shape_;
+        // Evaluation image width and height
+        // std::vector<float>  eval_im_size_f_;
+        // Scale factor for image size to origin image size
+        std::vector<float> scale_factor_;
+    };
+
+// Abstraction of preprocessing opration class
+    class PreprocessOp {
+    public:
+        virtual void Init(const YAML::Node &item) = 0;
+
+        virtual void Run(cv::Mat *im, ImageBlob *data) = 0;
+    };
+
+    class InitInfo : public PreprocessOp {
+    public:
+        virtual void Init(const YAML::Node &item) {}
+
+        virtual void Run(cv::Mat *im, ImageBlob *data);
+    };
+
+    class NormalizeImage : public PreprocessOp {
+    public:
+        virtual void Init(const YAML::Node &item) {
+            mean_ = item["mean"].as < std::vector < float >> ();
+            scale_ = item["std"].as < std::vector < float >> ();
+            is_scale_ = item["is_scale"].as<bool>();
+        }
+
+        virtual void Run(cv::Mat *im, ImageBlob *data);
+
+    private:
+        // CHW or HWC
+        std::vector<float> mean_;
+        std::vector<float> scale_;
+        bool is_scale_;
+    };
+
+    class Permute : public PreprocessOp {
+    public:
+        virtual void Init(const YAML::Node &item) {}
+
+        virtual void Run(cv::Mat *im, ImageBlob *data);
+    };
+
+    class Resize : public PreprocessOp {
+    public:
+        virtual void Init(const YAML::Node &item) {
+            interp_ = item["interp"].as<int>();
+            // max_size_ = item["target_size"].as<int>();
+            keep_ratio_ = item["keep_ratio"].as<bool>();
+            target_size_ = item["target_size"].as < std::vector < int >> ();
+        }
+
+        // Compute best resize scale for x-dimension, y-dimension
+        std::pair<double, double> GenerateScale(const cv::Mat &im);
+
+        virtual void Run(cv::Mat *im, ImageBlob *data);
+
+    private:
+        int interp_ = 2;
+        bool keep_ratio_;
+        std::vector<int> target_size_;
+        std::vector<int> in_net_shape_;
+    };
+
+// Models with FPN need input shape % stride == 0
+    class PadStride : public PreprocessOp {
+    public:
+        virtual void Init(const YAML::Node &item) {
+            stride_ = item["stride"].as<int>();
+        }
+
+        virtual void Run(cv::Mat *im, ImageBlob *data);
+
+    private:
+        int stride_;
+    };
+
+    class Preprocessor {
+    public:
+        void Init(const YAML::Node &config_node) {
+            // initialize image info at first
+            ops_["InitInfo"] = std::make_shared<InitInfo>();
+            for (int i = 0; i < config_node.size(); ++i) {
+                if (config_node[i]["DetResize"].IsDefined()) {
+                    ops_["Resize"] = std::make_shared<Resize>();
+                    ops_["Resize"]->Init(config_node[i]["DetResize"]);
+                }
+
+                if (config_node[i]["DetNormalizeImage"].IsDefined()) {
+                    ops_["NormalizeImage"] = std::make_shared<NormalizeImage>();
+                    ops_["NormalizeImage"]->Init(config_node[i]["DetNormalizeImage"]);
+                }
+
+                if (config_node[i]["DetPermute"].IsDefined()) {
+                    ops_["Permute"] = std::make_shared<Permute>();
+                    ops_["Permute"]->Init(config_node[i]["DetPermute"]);
+                }
+
+                if (config_node[i]["DetPadStrid"].IsDefined()) {
+                    ops_["PadStride"] = std::make_shared<PadStride>();
+                    ops_["PadStride"]->Init(config_node[i]["DetPadStrid"]);
+                }
+            }
+        }
+
+        void Run(cv::Mat *im, ImageBlob *data);
+
+    public:
+        static const std::vector <std::string> RUN_ORDER;
+
+    private:
+        std::unordered_map <std::string, std::shared_ptr<PreprocessOp>> ops_;
+    };
+
+} // namespace Detection

deploy/cpp_shitu/include/vector_search.h

+// Copyright (c) 2020 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
+#ifdef WIN32
+#define OS_PATH_SEP "\\"
+#else
+#define OS_PATH_SEP "/"
+#endif
+
+#include "yaml-cpp/yaml.h"
+#include <cstring>
+#include <faiss/Index.h>
+#include <faiss/index_io.h>
+#include <map>
+
+struct SearchResult {
+    std::vector <faiss::Index::idx_t> I;
+    std::vector<float> D;
+    int return_k;
+};
+
+class VectorSearch {
+public:
+    explicit VectorSearch(const YAML::Node &config_file) {
+        // IndexProcess
+        this->index_dir =
+                config_file["IndexProcess"]["index_dir"].as<std::string>();
+        this->return_k = config_file["IndexProcess"]["return_k"].as<int>();
+        this->score_thres = config_file["IndexProcess"]["score_thres"].as<float>();
+        this->max_query_number =
+                config_file["Global"]["max_det_results"].as<int>() + 1;
+        LoadIdMap();
+        LoadIndexFile();
+        this->I.resize(this->return_k * this->max_query_number);
+        this->D.resize(this->return_k * this->max_query_number);
+    };
+
+    void LoadIdMap();
+
+    void LoadIndexFile();
+
+    const SearchResult &Search(float *feature, int query_number);
+
+    const std::string &GetLabel(faiss::Index::idx_t ind);
+
+    const float &GetThreshold() { return this->score_thres; }
+
+private:
+    std::string index_dir;
+    int return_k = 5;
+    float score_thres = 0.5;
+    std::map<long int, std::string> id_map;
+    faiss::Index *index;
+    int max_query_number = 6;
+    std::vector<float> D;
+    std::vector <faiss::Index::idx_t> I;
+    SearchResult sr;
+};

deploy/cpp_shitu/include/yaml_config.h

+// Copyright (c) 2020 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
+
+#ifdef WIN32
+#define OS_PATH_SEP "\\"
+#else
+#define OS_PATH_SEP "/"
+#endif
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <stdlib.h>
+#include <vector>
+
+#include <algorithm>
+#include <cstring>
+#include <fstream>
+#include <map>
+#include <numeric>
+#include <regex>
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include "yaml-cpp/yaml.h"
+
+
+class YamlConfig {
+public:
+    explicit YamlConfig(const std::string &path) {
+        config_file = ReadYamlConfig(path);
+    }
+
+    static std::vector <std::string> ReadDict(const std::string &path);
+
+    static std::map<int, std::string> ReadIndexId(const std::string &path);
+
+    static YAML::Node ReadYamlConfig(const std::string &path);
+
+    void PrintConfigInfo();
+
+    YAML::Node config_file;
+};

deploy/cpp_shitu/readme.md

+# 服务器端C++预测
+
+本教程将介绍在服务器端部署PP-ShiTU的详细步骤。
+
+## 目录
+
+- [1.准备环境](#1)
+  - [1.1 升级cmake](#1.1)
+  - [1.2 编译opencv库](#1.2)
+  - [1.3 下载或者编译Paddle预测库](#1.3)
+    - [1.3.1 预测库源码编译](#1.3.1)
+    - [1.3.2 直接下载安装](#1.3.2)
+  - [1.4 安装faiss库](#1.4)
+- [2.代码编译](#2)
+- [3.运行demo](#3)
+- [4.使用自己模型](#4)
+
+<a name="1"></a>
+
+## 1. 准备环境
+
+### 运行准备
+- Linux环境，推荐使用ubuntu docker。
+
+<a name="1.1"></a>
+
+### 1.1 升级cmake
+
+由于依赖库编译需要较高版本的cmake，因此，第一步首先将cmake升级。
+
+- 下载最新版本cmake
+
+```shell
+# 当前版本最新为3.22.0，根据实际情况自行下载，建议最新版本
+wget https://github.com/Kitware/CMake/releases/download/v3.22.0/cmake-3.22.0.tar.gz
+tar xf cmake-3.22.0.tar.gz
+```
+
+最终可以在当前目录下看到`cmake-3.22.0/`的文件夹。
+
+- 编译cmake，首先设置came源码路径(`root_path`)以及安装路径(`install_path`)，`root_path`为下载的came源码路径，`install_path`为came的安装路径。在本例中，源码路径即为当前目录下的`cmake-3.22.0/`。
+
+```shell
+cd ./cmake-3.22.0
+export root_path=$PWD
+export install_path=${root_path}/cmake
+```
+
+- 然后在cmake源码路径下，按照下面的方式进行编译
+
+```shell
+./bootstrap --prefix=${install_path}
+make -j
+make install
+```
+
+- 设置环境变量
+
+```shell
+export PATH=${install_path}/bin:$PATH
+#检查是否正常使用
+cmake --version
+```
+
+此时，cmake就可以使用了
+
+<a name="1.2"></a>
+
+### 1.2 编译opencv库
+
+* 首先需要从opencv官网上下载在Linux环境下源码编译的包，以3.4.7版本为例，下载及解压缩命令如下：
+
+```
+wget https://github.com/opencv/opencv/archive/3.4.7.tar.gz
+tar -xvf 3.4.7.tar.gz
+```
+
+最终可以在当前目录下看到`opencv-3.4.7/`的文件夹。
+
+* 编译opencv，首先设置opencv源码路径(`root_path`)以及安装路径(`install_path`)，`root_path`为下载的opencv源码路径，`install_path`为opencv的安装路径。在本例中，源码路径即为当前目录下的`opencv-3.4.7/`。
+
+```shell
+cd ./opencv-3.4.7
+export root_path=$PWD
+export install_path=${root_path}/opencv3
+```
+
+* 然后在opencv源码路径下，按照下面的方式进行编译。
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake .. \
+    -DCMAKE_INSTALL_PREFIX=${install_path} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_SHARED_LIBS=OFF \
+    -DWITH_IPP=OFF \
+    -DBUILD_IPP_IW=OFF \
+    -DWITH_LAPACK=OFF \
+    -DWITH_EIGEN=OFF \
+    -DCMAKE_INSTALL_LIBDIR=lib64 \
+    -DWITH_ZLIB=ON \
+    -DBUILD_ZLIB=ON \
+    -DWITH_JPEG=ON \
+    -DBUILD_JPEG=ON \
+    -DWITH_PNG=ON \
+    -DBUILD_PNG=ON \
+    -DWITH_TIFF=ON \
+    -DBUILD_TIFF=ON
+
+make -j
+make install
+```
+
+* `make install`完成之后，会在该文件夹下生成opencv头文件和库文件，用于后面的PaddleClas代码编译。
+
+以opencv3.4.7版本为例，最终在安装路径下的文件结构如下所示。**注意**：不同的opencv版本，下述的文件结构可能不同。
+
+```
+opencv3/
+|-- bin
+|-- include
+|-- lib64
+|-- share
+```
+
+<a name="1.3"></a>
+
+### 1.3 下载或者编译Paddle预测库
+
+* 有2种方式获取Paddle预测库，下面进行详细介绍。
+
+<a name="1.3.1"></a>
+
+#### 1.3.1 预测库源码编译
+
+* 如果希望获取最新预测库特性，可以从Paddle github上克隆最新代码，源码编译预测库。
+* 可以参考[Paddle预测库官网](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/05_inference_deployment/inference/build_and_install_lib_cn.html#id16)的说明，从github上获取Paddle代码，然后进行编译，生成最新的预测库。使用git获取代码方法如下。
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle.git
+```
+
+* 进入Paddle目录后，使用如下方法编译。
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake  .. \
+    -DWITH_CONTRIB=OFF \
+    -DWITH_MKL=ON \
+    -DWITH_MKLDNN=ON  \
+    -DWITH_TESTING=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DWITH_INFERENCE_API_TEST=OFF \
+    -DON_INFER=ON \
+    -DWITH_PYTHON=ON
+make -j
+make inference_lib_dist
+```
+
+更多编译参数选项可以参考[Paddle C++预测库官网](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/05_inference_deployment/inference/build_and_install_lib_cn.html#id16)。
+
+
+* 编译完成之后，可以在`build/paddle_inference_install_dir/`文件下看到生成了以下文件及文件夹。
+
+```
+build/paddle_inference_install_dir/
+|-- CMakeCache.txt
+|-- paddle
+|-- third_party
+|-- version.txt
+```
+
+其中`paddle`就是之后进行C++预测时所需的Paddle库，`version.txt`中包含当前预测库的版本信息。
+
+<a name="1.3.2"></a>
+
+#### 1.3.2 直接下载安装
+
+* [Paddle预测库官网](https://paddle-inference.readthedocs.io/en/latest/user_guides/download_lib.html)上提供了不同cuda版本的Linux预测库，可以在官网查看并选择合适的预测库版本，注意必须选择`develop`版本。
+
+  以`https://paddle-inference-lib.bj.bcebos.com/2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2/paddle_inference.tgz`的`develop`版本为例，使用下述命令下载并解压：
+
+
+```shell
+wget https://paddle-inference-lib.bj.bcebos.com/2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2/paddle_inference.tgz
+
+tar -xvf paddle_inference.tgz
+```
+
+
+最终会在当前的文件夹中生成`paddle_inference/`的子文件夹。
+
+<a name="1.4"></a>
+
+### 1.4 安装faiss库
+
+```shell
+ # 下载 faiss
+ git clone https://github.com/facebookresearch/faiss.git
+ cd faiss
+ export faiss_install_path=$PWD/faiss_install
+ cmake -B build . -DFAISS_ENABLE_PYTHON=OFF  -DCMAKE_INSTALL_PREFIX=${faiss_install_path}
+ make -C build -j faiss
+ make -C build install
+```
+
+在安装`faiss`前，请安装`openblas`，`ubuntu`系统中安装命令如下：
+
+```shell
+apt-get install libopenblas-dev
+```
+
+注意本教程以安装faiss cpu版本为例，安装时请参考[faiss](https://github.com/facebookresearch/faiss)官网文档，根据需求自行安装。
+
+<a name="2"></a>
+
+## 2. 代码编译
+
+编译命令如下，其中Paddle C++预测库、opencv等其他依赖库的地址需要换成自己机器上的实际地址。同时，编译过程中需要下载编译`yaml-cpp`等C++库，请保持联网环境。
+
+
+```shell
+sh tools/build.sh
+```
+
+具体地，`tools/build.sh`中内容如下，请根据具体路径修改。
+
+```shell
+OPENCV_DIR=${opencv_install_dir}
+LIB_DIR=${paddle_inference_dir}
+CUDA_LIB_DIR=/usr/local/cuda/lib64
+CUDNN_LIB_DIR=/usr/lib/x86_64-linux-gnu/
+FAISS_DIR=${faiss_install_dir}
+FAISS_WITH_MKL=OFF
+
+BUILD_DIR=build
+rm -rf ${BUILD_DIR}
+mkdir ${BUILD_DIR}
+cd ${BUILD_DIR}
+cmake .. \
+    -DPADDLE_LIB=${LIB_DIR} \
+    -DWITH_MKL=ON \
+    -DWITH_GPU=OFF \
+    -DWITH_STATIC_LIB=OFF \
+    -DUSE_TENSORRT=OFF \
+    -DOPENCV_DIR=${OPENCV_DIR} \
+    -DCUDNN_LIB=${CUDNN_LIB_DIR} \
+    -DCUDA_LIB=${CUDA_LIB_DIR} \
+    -DFAISS_DIR=${FAISS_DIR} \
+    -DFAISS_WITH_MKL=${FAISS_WITH_MKL}
+
+make -j
+cd ..
+```
+
+上述命令中，
+
+* `OPENCV_DIR`为opencv编译安装的地址（本例中为`opencv-3.4.7/opencv3`文件夹的路径）；
+* `LIB_DIR`为下载的Paddle预测库（`paddle_inference`文件夹），或编译生成的Paddle预测库（`build/paddle_inference_install_dir`文件夹）的路径；
+* `CUDA_LIB_DIR`为cuda库文件地址，在docker中为`/usr/local/cuda/lib64`；
+* `CUDNN_LIB_DIR`为cudnn库文件地址，在docker中为`/usr/lib/x86_64-linux-gnu/`。
+* `TENSORRT_DIR`是tensorrt库文件地址，在dokcer中为`/usr/local/TensorRT6-cuda10.0-cudnn7/`，TensorRT需要结合GPU使用。
+* `FAISS_DIR`是faiss的安装地址
+* `FAISS_WITH_MKL`是指在编译faiss的过程中，是否使用了mkldnn，本文档中编译faiss，没有使用，而使用了openblas，故设置为`OFF`，若使用了mkldnn，则为`ON`.
+
+
+在执行上述命令，编译完成之后，会在当前路径下生成`build`文件夹，其中生成一个名为`pp_shitu`的可执行文件。
+
+<a name="3"></a>
+
+## 3. 运行demo
+
+- 请参考[识别快速开始文档](../../docs/zh_CN/quick_start/quick_start_recognition.md)，下载好相应的 轻量级通用主体检测模型、轻量级通用识别模型及瓶装饮料测试数据并解压。
+
+  ```shell
+  mkdir models
+  cd models
+  wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.tar
+  tar -xf picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.tar
+  wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/general_PPLCNet_x2_5_lite_v1.0_infer.tar
+  tar -xf general_PPLCNet_x2_5_lite_v1.0_infer.tar
+  cd ..
+
+  mkdir data
+  cd data
+  wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/drink_dataset_v1.0.tar
+  tar -xf drink_dataset_v1.0.tar
+  cd ..
+  ```
+
+- 将相应的yaml文件拷到当前文件夹下
+
+  ```shell
+  cp ../configs/inference_drink.yaml .
+  ```
+
+- 将`inference_drink.yaml`中的相对路径，改成基于本目录的路径或者绝对路径。涉及到的参数有
+
+  - Global.infer_imgs ：此参数可以是具体的图像地址，也可以是图像集所在的目录
+  - Global.det_inference_model_dir ： 检测模型存储目录
+  - Global.rec_inference_model_dir ： 识别模型存储目录
+  - IndexProcess.index_dir ： 检索库的存储目录，在示例中，检索库在下载的demo数据中。
+
+- 字典转换
+
+  由于python的检索库的字典，使用`pickle`进行的序列化存储，导致C++不方便读取，因此进行转换
+
+  ```shell
+  python tools/transform_id_map.py -c inference_drink.yaml
+  ```
+
+  转换成功后，在`IndexProcess.index_dir`目录下生成`id_map.txt`，方便c++ 读取。
+
+- 执行程序
+
+  ```shell
+  ./build/pp_shitu -c inference_drink.yaml
+  # or
+  ./build/pp_shitu -config inference_drink.yaml
+  ```
+
+  若对图像集进行检索，则可能得到，如下结果。注意，此结果只做展示，具体以实际运行结果为准。
+
+  同时，需注意的是，由于opencv 版本问题，会导致图像在预处理的过程中，resize产生细微差别，导致python 和c++结果，轻微不同，如bbox相差几个像素，检索结果小数点后3位diff等。但不会改变最终检索label。
+
+  ![](../../docs/images/quick_start/shitu_c++_result.png)
+
+<a name="4"></a>
+
+## 4.  使用自己模型
+
+使用自己训练的模型，可以参考[模型导出](../../docs/zh_CN/inference_deployment/export_model.md)，导出`inference model`，用于模型预测。
+
+同时注意修改`yaml`文件中具体参数。

deploy/cpp_shitu/readme_en.md

+# C++ Inference on Server
+
+This tutorial details the steps to deploy PP-ShiTU on the server side.
+
+## Catalogue
+
+- [1.Prepare the Environment](#1)
+  - [1.1 Update cmake](#1.1)
+  - [1.2 Compile opencv Library](#1.2)
+  - [1.3 Download or Compile Paddle Inference Library](#1.3)
+    - [1.3.1 Compile the Source of Inference Library](#1.3.1)
+    - [1.3.2 Direct Download and Installation](#1.3.2)
+  - [1.4 Install faiss Library](#1.4)
+- [2.Code Compilation](#2)
+- [3.Run the demo](#3)
+- [4.Use Your Own Model](#4)
+
+<a name="1"></a>
+
+## 1. Prepare the Environment
+
+### Environment Preparation
+
+- Linux environment, ubuntu docker recommended.
+
+<a name="1.1"></a>
+
+### 1.1 Update cmake
+
+The first step is to upgrade `cmake` considering the requirements of the dependency library compilation.
+
+- Download the latest version of cmake
+
+```
+# The latest version is 3.22.0, please download the appropriate one, the latest recommended.
+wget https://github.com/Kitware/CMake/releases/download/v3.22.0/cmake-3.22.0.tar.gz
+tar xf cmake-3.22.0.tar.gz
+```
+
+You can find `cmake-3.22.0/` folder in the current directory.
+
+- To compile cmake, first set the source path of `cmake` (`root_path`) and installation path (`install_path`). In this example, the source path is `cmake-3.22.0/` in the current directory.
+
+```shell
+cd ./cmake-3.22.0
+export root_path=$PWD
+export install_path=${root_path}/cmake
+```
+
+- Then compile under the source path as follows:
+
+```shell
+./bootstrap --prefix=${install_path}
+make -j
+make install
+```
+
+- Set environment variables
+
+```shell
+export PATH=${install_path}/bin:$PATH
+#Check its well functioning
+cmake --version
+```
+
+cmake is now ready for use.
+
+<a name="1.2"></a>
+
+### 1.2 Compile opencv Library
+
+- First, download the package for source compilation in Linux environment from the official website of opencv. Taking version 3.4.7 as an example, follow the command below to download and unzip it:
+
+```shell
+wget https://github.com/opencv/opencv/archive/3.4.7.tar.gz
+tar -xvf 3.4.7.tar.gz
+```
+
+You can find`opencv-3.4.7/`folder in the current directory.
+
+- To compile opencv, first set the source path of opencv(`root_path`) and installation path (`install_path`). In this example, the source path is`opencv-3.4.7/`in the current directory.
+
+```
+cd ./opencv-3.4.7
+export root_path=$PWD
+export install_path=${root_path}/opencv3
+```
+
+- Then compile under the source path as follows:
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake .. \
+    -DCMAKE_INSTALL_PREFIX=${install_path} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_SHARED_LIBS=OFF \
+    -DWITH_IPP=OFF \
+    -DBUILD_IPP_IW=OFF \
+    -DWITH_LAPACK=OFF \
+    -DWITH_EIGEN=OFF \
+    -DCMAKE_INSTALL_LIBDIR=lib64 \
+    -DWITH_ZLIB=ON \
+    -DBUILD_ZLIB=ON \
+    -DWITH_JPEG=ON \
+    -DBUILD_JPEG=ON \
+    -DWITH_PNG=ON \
+    -DBUILD_PNG=ON \
+    -DWITH_TIFF=ON \
+    -DBUILD_TIFF=ON
+
+make -j
+make install
+```
+
+- After `make install` is done, opencv header and library files will be generated in this folder for later compilation of PaddleClas code.
+
+For opencv version 3.4.7, the final file structure under the installation path is shown below. **Note**: The following file structure may vary for different opencv versions.
+
+```
+opencv3/
+|-- bin
+|-- include
+|-- lib64
+|-- share
+```
+
+<a name="1.3"></a>
+
+### 1.3 Download or Compile Paddle Inference Library
+
+- Here we detail 2 ways to obtain Paddle inference library.
+
+<a name="1.3.1"></a>
+
+#### 1.3.1 Compile the Source of Inference Library
+
+- To obtain the latest features of the inference library, you can clone the latest code from Paddle github and compile the source code of the library.
+- Please refer to the website of  [Paddle Inference Library](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/05_inference_deployment/inference/build_ and_install_lib_cn.html#id16) to get Paddle code from github and then compile it to generate the latest inference library. The method to obtain the code using git is as follows.
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle.git
+```
+
+- Adopt the following method to compile after entering Paddle directory.
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake  .. \
+    -DWITH_CONTRIB=OFF \
+    -DWITH_MKL=ON \
+    -DWITH_MKLDNN=ON  \
+    -DWITH_TESTING=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DWITH_INFERENCE_API_TEST=OFF \
+    -DON_INFER=ON \
+    -DWITH_PYTHON=ON
+make -j
+make inference_lib_dist
+```
+
+See the official website of [Paddle C++ Inference Library](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/05_inference_deployment/inference/build_and_install_lib_cn.html#id16) for more compilation parameters.
+
+- The following files and folders can be found generated under `build/paddle_inference_install_dir/` after compilation.
+
+```
+build/paddle_inference_install_dir/
+|-- CMakeCache.txt
+|-- paddle
+|-- third_party
+|-- version.txt
+```
+
+ `paddle` is the Paddle library needed for later C++ inference, and `version.txt` contains the version information of the current inference library.
+
+<a name="1.3.2"></a>
+
+#### 1.3.2 Direct Download and Installation
+
+- The Linux inference library of different cuda versions are available on the official website of [Paddle Inference Library ](https://paddle-inference.readthedocs.io/en/latest/user_guides/download_lib.html), where you can choose the appropriate version. Note that you must select the `develop` version.
+
+  For the `develop` version of `https://paddle-inference-lib.bj.bcebos.com/2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2/paddle_inference.tgz`, use the following command to download and unzip it:
+
+```shell
+wget https://paddle-inference-lib.bj.bcebos.com/2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2/paddle_inference.tgz
+
+tar -xvf paddle_inference.tgz
+```
+
+The subfolder `paddle_inference/` will finally be created in the current folder.
+
+<a name="1.4"></a>
+
+### 1.4 Install faiss Library
+
+```shell
+ # Download faiss
+ git clone https://github.com/facebookresearch/faiss.git
+ cd faiss
+ export faiss_install_path=$PWD/faiss_install
+ cmake -B build . -DFAISS_ENABLE_PYTHON=OFF  -DCMAKE_INSTALL_PREFIX=${faiss_install_path}
+ make -C build -j faiss
+ make -C build install
+```
+
+Please install `openblas` before `faiss`, the installation command in `ubuntu` system is as follows:
+
+```
+apt-get install libopenblas-dev
+```
+
+Note that this tutorial installs the cpu version of faiss as an example, please install it as your need by referring to the official documents of [faiss](https://github.com/facebookresearch/faiss).
+
+<a name="2"></a>
+
+## 2. Code Compilation
+
+The command is as follows, where the address of Paddle C++ inference library, opencv and other dependency libraries need to be replaced with the actual address on your own machine. Also, you need to download and compile `yaml-cpp` and other C++ libraries during the compilation, so please keep the network unblocked.
+
+```shell
+sh tools/build.sh
+```
+
+Specifically, the contents of `tools/build.sh` are as follows, please modify according to the specific path.
+
+```shell
+OPENCV_DIR=${opencv_install_dir}
+LIB_DIR=${paddle_inference_dir}
+CUDA_LIB_DIR=/usr/local/cuda/lib64
+CUDNN_LIB_DIR=/usr/lib/x86_64-linux-gnu/
+FAISS_DIR=${faiss_install_dir}
+FAISS_WITH_MKL=OFF
+
+BUILD_DIR=build
+rm -rf ${BUILD_DIR}
+mkdir ${BUILD_DIR}
+cd ${BUILD_DIR}
+cmake .. \
+    -DPADDLE_LIB=${LIB_DIR} \
+    -DWITH_MKL=ON \
+    -DWITH_GPU=OFF \
+    -DWITH_STATIC_LIB=OFF \
+    -DUSE_TENSORRT=OFF \
+    -DOPENCV_DIR=${OPENCV_DIR} \
+    -DCUDNN_LIB=${CUDNN_LIB_DIR} \
+    -DCUDA_LIB=${CUDA_LIB_DIR} \
+    -DFAISS_DIR=${FAISS_DIR} \
+    -DFAISS_WITH_MKL=${FAISS_WITH_MKL}
+
+make -j
+cd ..
+```
+
+In the above commands:
+
+- `OPENCV_DIR` is the address of the opencv compilation and installation (in this case, the path of the `opencv-3.4.7/opencv3` folder).
+- `LIB_DIR` is the path of the downloaded Paddle inference library (`paddle_inference` folder), or the generated Paddle inference library after compilation (`build/paddle_inference_install_dir` folder).
+- `CUDA_LIB_DIR` is path of the cuda library file, which in docker is `/usr/local/cuda/lib64`.
+- `CUDNN_LIB_DIR` is the path of the cudnn library file, which in docker is `/usr/lib/x86_64-linux-gnu/` .
+- `TENSORRT_DIR` is the path of the tensorrt library file, which in docker is `/usr/local/TensorRT6-cuda10.0-cudnn7/`. TensorRT needs to be used in combination with GPU.
+- `FAISS_DIR` is the installation path of faiss.
+- `FAISS_WITH_MKL` means whether mkldnn is used during the compilation of faiss. The compilation in this document employs openbals instead of mkldnn, so it is set to `OFF`, otherwise it is `ON`.
+
+A `build` folder will be created in the current path after the compilation, which generates an executable file named `pp_shitu`.
+
+<a name="3"></a>
+
+## 3. Run the demo
+
+- Please refer to the [Quick Start of Recognition](../../docs/en/quick_start/quick_start_recognition_en.md), download the corresponding Lightweight Generic Mainbody Detection Model, Lightweight Generic Recognition Model, and the beverage test data and unzip them.
+
+  ```shell
+  mkdir models
+  cd models
+  wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.tar
+  tar -xf picodet_PPLCNet_x2_5_mainbody_lite_v1.0_infer.tar
+  wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/general_PPLCNet_x2_5_lite_v1.0_infer.tar
+  tar -xf general_PPLCNet_x2_5_lite_v1.0_infer.tar
+  cd ..
+
+  mkdir data
+  cd data
+  wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/drink_dataset_v1.0.tar
+  tar -xf drink_dataset_v1.0.tar
+  cd ..
+  ```
+
+- Copy the corresponding yaml file to the current folder
+
+  ```
+  cp ../configs/inference_drink.yaml .
+  ```
+
+- Change the relative path in `inference_drink.yaml` to a path based on this directory or an absolute path. The parameters involved are:
+
+  - Global.infer_imgs: This parameter can be a specific image path or the directory where the image set is located
+  - Global.det_inference_model_dir: The directory where detection models are saved.
+  - Global.rec_inference_model_dir: The directory where recognition models are saved.
+  - IndexProcess.index_dir: The storage directory of the retrieval library, in the exmple, the retrieval library is in the downloaded demo data.
+
+- Transform the ID-Label Map Dictionary
+
+  The id-label map dictionary in python is serialized using `pickle`, which make it hard to read for C++, so the transformation is needed:
+
+  ```
+  python tools/transform_id_map.py -c inference_drink.yaml
+  ```
+
+   `id_map.txt` is generated in `IndexProcess.index_dir` directory for convenience of C++ reading.
+
+- Execute the program
+
+  ```shell
+  ./build/pp_shitu -c inference_drink.yaml
+  # or
+  ./build/pp_shitu -config inference_drink.yaml
+  ```
+
+  The following results can be obtained after searching the image set.
+
+  At the same time, it should be noticed that a slight difference may occur during the pre-processing of the image due to the version of opencv, resulting in a minor discrepancy in python and c++ results, such as a few pixels for bbox, 3 decimal places for retrieval results, etc. But it has no impact on the final search label.
+
+  [![img](../../docs/images/quick_start/shitu_c++_result.png)](https://github.com/PaddlePaddle/PaddleClas/blob/develop/docs/images/quick_start/shitu_c++_result.png)
+
+<a name="4"></a>
+
+## 4. Use Your Own Model
+
+You can also use your self-trained models. Please refer to [model export](../../docs/en/inference_deployment/export_model_en.md) to export ` inference model` for model inference.
+
+Mind modifying the specific parameters in the `yaml` file.

deploy/cpp_shitu/src/feature_extracter.cpp

+// Copyright (c) 2020 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 <cmath>
+#include <include/feature_extracter.h>
+#include <numeric>
+
+namespace Feature {
+
+    void FeatureExtracter::LoadModel(const std::string &model_path,
+                                     const std::string &params_path) {
+        paddle_infer::Config config;
+        config.SetModel(model_path, params_path);
+
+        if (this->use_gpu_) {
+            config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+            if (this->use_tensorrt_) {
+                config.EnableTensorRtEngine(
+                        1 << 20, 1, 3,
+                        this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
+                                        : paddle_infer::Config::Precision::kFloat32,
+                        false, false);
+            }
+        } else {
+            config.DisableGpu();
+            if (this->use_mkldnn_) {
+                config.EnableMKLDNN();
+                // cache 10 different shapes for mkldnn to avoid memory leak
+                config.SetMkldnnCacheCapacity(10);
+            }
+            config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+        }
+
+        config.SwitchUseFeedFetchOps(false);
+        // true for multiple input
+        config.SwitchSpecifyInputNames(true);
+
+        config.SwitchIrOptim(true);
+
+        config.EnableMemoryOptim();
+        config.DisableGlogInfo();
+
+        this->predictor_ = CreatePredictor(config);
+    }
+
+    void FeatureExtracter::Run(cv::Mat &img, std::vector<float> &out_data,
+                               std::vector<double> &times) {
+        cv::Mat resize_img;
+        std::vector<double> time;
+
+        auto preprocess_start = std::chrono::steady_clock::now();
+        this->resize_op_.Run(img, resize_img, this->resize_short_,
+                             this->resize_size_);
+
+        this->normalize_op_.Run(&resize_img, this->mean_, this->std_, this->scale_);
+        std::vector<float> input(1 * 3 * resize_img.rows * resize_img.cols, 0.0f);
+        this->permute_op_.Run(&resize_img, input.data());
+
+        auto input_names = this->predictor_->GetInputNames();
+        auto input_t = this->predictor_->GetInputHandle(input_names[0]);
+        input_t->Reshape({1, 3, resize_img.rows, resize_img.cols});
+        auto preprocess_end = std::chrono::steady_clock::now();
+
+        auto infer_start = std::chrono::steady_clock::now();
+        input_t->CopyFromCpu(input.data());
+        this->predictor_->Run();
+
+        auto output_names = this->predictor_->GetOutputNames();
+        auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
+        std::vector<int> output_shape = output_t->shape();
+        int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1,
+                                      std::multiplies<int>());
+
+        out_data.resize(out_num);
+        output_t->CopyToCpu(out_data.data());
+        auto infer_end = std::chrono::steady_clock::now();
+
+        auto postprocess_start = std::chrono::steady_clock::now();
+        if (this->feature_norm)
+            FeatureNorm(out_data);
+        auto postprocess_end = std::chrono::steady_clock::now();
+
+        std::chrono::duration<float> preprocess_diff =
+                preprocess_end - preprocess_start;
+        time.push_back(double(preprocess_diff.count()) * 1000);
+        std::chrono::duration<float> inference_diff = infer_end - infer_start;
+        double inference_cost_time = double(inference_diff.count() * 1000);
+        time.push_back(inference_cost_time);
+        // std::chrono::duration<float> postprocess_diff =
+        //     postprocess_end - postprocess_start;
+        time.push_back(0);
+
+        // std::cout << "result: " << std::endl;
+        // std::cout << "\tclass id: " << maxPosition << std::endl;
+        // std::cout << std::fixed << std::setprecision(10)
+        //           << "\tscore: " << double(out_data[maxPosition]) << std::endl;
+        times[0] += time[0];
+        times[1] += time[1];
+        times[2] += time[2];
+    }
+
+    void FeatureExtracter::FeatureNorm(std::vector<float> &featuer) {
+        float featuer_sqrt = std::sqrt(std::inner_product(
+                featuer.begin(), featuer.end(), featuer.begin(), 0.0f));
+        for (int i = 0; i < featuer.size(); ++i)
+            featuer[i] /= featuer_sqrt;
+    }
+} // namespace Feature

deploy/cpp_shitu/src/main.cpp

+// Copyright (c) 2021 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 "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <opencv2/core/utils/filesystem.hpp>
+#include <ostream>
+#include <vector>
+
+#include <cstring>
+#include <fstream>
+#include <numeric>
+
+#include <auto_log/autolog.h>
+#include <gflags/gflags.h>
+#include <include/feature_extracter.h>
+#include <include/nms.h>
+#include <include/object_detector.h>
+#include <include/vector_search.h>
+#include <include/yaml_config.h>
+
+using namespace std;
+using namespace cv;
+
+DEFINE_string(config,
+"", "Path of yaml file");
+DEFINE_string(c,
+"", "Path of yaml file");
+
+void DetPredictImage(const std::vector <cv::Mat> &batch_imgs,
+                     const std::vector <std::string> &all_img_paths,
+                     const int batch_size, Detection::ObjectDetector *det,
+                     std::vector <Detection::ObjectResult> &im_result,
+                     std::vector<int> &im_bbox_num, std::vector<double> &det_t,
+                     const bool visual_det = false,
+                     const bool run_benchmark = false,
+                     const std::string &output_dir = "output") {
+    int steps = ceil(float(all_img_paths.size()) / batch_size);
+    //   printf("total images = %d, batch_size = %d, total steps = %d\n",
+    //                 all_img_paths.size(), batch_size, steps);
+    for (int idx = 0; idx < steps; idx++) {
+        int left_image_cnt = all_img_paths.size() - idx * batch_size;
+        if (left_image_cnt > batch_size) {
+            left_image_cnt = batch_size;
+        }
+        // for (int bs = 0; bs < left_image_cnt; bs++) {
+        // std::string image_file_path = all_img_paths.at(idx * batch_size+bs);
+        // cv::Mat im = cv::imread(image_file_path, 1);
+        // batch_imgs.insert(batch_imgs.end(), im);
+        // }
+
+        // Store all detected result
+        std::vector <Detection::ObjectResult> result;
+        std::vector<int> bbox_num;
+        std::vector<double> det_times;
+        bool is_rbox = false;
+        if (run_benchmark) {
+            det->Predict(batch_imgs, 10, 10, &result, &bbox_num, &det_times);
+        } else {
+            det->Predict(batch_imgs, 0, 1, &result, &bbox_num, &det_times);
+            // get labels and colormap
+            auto labels = det->GetLabelList();
+            auto colormap = Detection::GenerateColorMap(labels.size());
+
+            int item_start_idx = 0;
+            for (int i = 0; i < left_image_cnt; i++) {
+                cv::Mat im = batch_imgs[i];
+                int detect_num = 0;
+
+                for (int j = 0; j < bbox_num[i]; j++) {
+                    Detection::ObjectResult item = result[item_start_idx + j];
+                    if (item.confidence < det->GetThreshold() || item.class_id == -1) {
+                        continue;
+                    }
+                    detect_num += 1;
+                    im_result.push_back(item);
+                    if (visual_det) {
+                        if (item.rect.size() > 6) {
+                            is_rbox = true;
+                            printf(
+                                    "class=%d confidence=%.4f rect=[%d %d %d %d %d %d %d %d]\n",
+                                    item.class_id, item.confidence, item.rect[0], item.rect[1],
+                                    item.rect[2], item.rect[3], item.rect[4], item.rect[5],
+                                    item.rect[6], item.rect[7]);
+                        } else {
+                            printf("class=%d confidence=%.4f rect=[%d %d %d %d]\n",
+                                   item.class_id, item.confidence, item.rect[0], item.rect[1],
+                                   item.rect[2], item.rect[3]);
+                        }
+                    }
+                }
+                im_bbox_num.push_back(detect_num);
+                item_start_idx = item_start_idx + bbox_num[i];
+
+                // Visualization result
+                if (visual_det) {
+                    std::cout << all_img_paths.at(idx * batch_size + i)
+                              << " The number of detected box: " << detect_num
+                              << std::endl;
+                    cv::Mat vis_img = Detection::VisualizeResult(im, im_result, labels,
+                                                                 colormap, is_rbox);
+                    std::vector<int> compression_params;
+                    compression_params.push_back(CV_IMWRITE_JPEG_QUALITY);
+                    compression_params.push_back(95);
+                    std::string output_path(output_dir);
+                    if (output_dir.rfind(OS_PATH_SEP) != output_dir.size() - 1) {
+                        output_path += OS_PATH_SEP;
+                    }
+                    std::string image_file_path = all_img_paths.at(idx * batch_size + i);
+                    output_path +=
+                            image_file_path.substr(image_file_path.find_last_of('/') + 1);
+                    cv::imwrite(output_path, vis_img, compression_params);
+                    printf("Visualized output saved as %s\n", output_path.c_str());
+                }
+            }
+        }
+        det_t[0] += det_times[0];
+        det_t[1] += det_times[1];
+        det_t[2] += det_times[2];
+    }
+}
+
+void PrintResult(std::string &img_path,
+                 std::vector <Detection::ObjectResult> &det_result,
+                 std::vector<int> &indeices, VectorSearch &vector_search,
+                 SearchResult &search_result) {
+    printf("%s:\n", img_path.c_str());
+    for (int i = 0; i < indeices.size(); ++i) {
+        int t = indeices[i];
+        printf("\tresult%d: bbox[%d, %d, %d, %d], score: %f, label: %s\n", i,
+               det_result[t].rect[0], det_result[t].rect[1], det_result[t].rect[2],
+               det_result[t].rect[3], det_result[t].confidence,
+               vector_search.GetLabel(search_result.I[search_result.return_k * t])
+                       .c_str());
+    }
+}
+
+int main(int argc, char **argv) {
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    std::string yaml_path = "";
+    if (FLAGS_config == "" && FLAGS_c == "") {
+        std::cerr << "[ERROR] usage: " << std::endl
+                  << argv[0] << " -c $yaml_path" << std::endl
+                  << "or:" << std::endl
+                  << argv[0] << " -config $yaml_path" << std::endl;
+        exit(1);
+    } else if (FLAGS_config != "") {
+        yaml_path = FLAGS_config;
+    } else {
+        yaml_path = FLAGS_c;
+    }
+
+    YamlConfig config(yaml_path);
+    config.PrintConfigInfo();
+
+    // initialize detector, rec_Model, vector_search
+    Feature::FeatureExtracter feature_extracter(config.config_file);
+    Detection::ObjectDetector detector(config.config_file);
+    VectorSearch searcher(config.config_file);
+
+    // config
+    const int batch_size = config.config_file["Global"]["batch_size"].as<int>();
+    bool visual_det = false;
+    if (config.config_file["Global"]["visual_det"].IsDefined()) {
+        visual_det = config.config_file["Global"]["visual_det"].as<bool>();
+    }
+    bool benchmark = false;
+    if (config.config_file["Global"]["benchmark"].IsDefined()) {
+        benchmark = config.config_file["Global"]["benchmark"].as<bool>();
+    }
+    int max_det_results = 5;
+    if (config.config_file["Global"]["max_det_results"].IsDefined()) {
+        max_det_results = config.config_file["Global"]["max_det_results"].as<int>();
+    }
+    float rec_nms_thresold = 0.05;
+    if (config.config_file["Global"]["rec_nms_thresold"].IsDefined()) {
+        rec_nms_thresold =
+                config.config_file["Global"]["rec_nms_thresold"].as<float>();
+    }
+
+    // load image_file_path
+    std::string path =
+            config.config_file["Global"]["infer_imgs"].as<std::string>();
+    std::vector <std::string> img_files_list;
+    if (cv::utils::fs::isDirectory(path)) {
+        std::vector <cv::String> filenames;
+        cv::glob(path, filenames);
+        for (auto f : filenames) {
+            img_files_list.push_back(f);
+        }
+    } else {
+        img_files_list.push_back(path);
+    }
+    std::cout << "img_file_list length: " << img_files_list.size() << std::endl;
+    // for time log
+    std::vector<double> cls_times = {0, 0, 0};
+    std::vector<double> det_times = {0, 0, 0};
+    std::vector<double> search_times = {0, 0, 0};
+    int instance_num = 0;
+    // for read images
+    std::vector <cv::Mat> batch_imgs;
+    std::vector <std::string> img_paths;
+    // for detection
+    std::vector <Detection::ObjectResult> det_result;
+    std::vector<int> det_bbox_num;
+    // for vector search
+    std::vector<float> features;
+    std::vector<float> feature;
+    // for nms
+    std::vector<int> indeices;
+
+    int warmup_iter = img_files_list.size() > 5 ? 5 : img_files_list.size();
+    if (benchmark) {
+        img_files_list.insert(img_files_list.begin(), img_files_list.begin(),
+                              img_files_list.begin() + warmup_iter);
+    }
+
+    for (int idx = 0; idx < img_files_list.size(); ++idx) {
+        std::string img_path = img_files_list[idx];
+        cv::Mat srcimg = cv::imread(img_path, cv::IMREAD_COLOR);
+        if (!srcimg.data) {
+            std::cerr << "[ERROR] image read failed! image path: " << img_path
+                      << "\n";
+            exit(-1);
+        }
+        cv::cvtColor(srcimg, srcimg, cv::COLOR_BGR2RGB);
+
+        batch_imgs.push_back(srcimg);
+        img_paths.push_back(img_path);
+
+        // step1: get all detection results
+        DetPredictImage(batch_imgs, img_paths, batch_size, &detector, det_result,
+                        det_bbox_num, det_times, visual_det, false);
+
+        // select max_det_results bbox
+        if (det_result.size() > max_det_results) {
+            det_result.resize(max_det_results);
+        }
+        instance_num += det_result.size();
+
+        // step2: add the whole image for recognition to improve recall
+        Detection::ObjectResult result_whole_img = {
+                {0, 0, srcimg.cols - 1, srcimg.rows - 1}, 0, 1.0};
+        det_result.push_back(result_whole_img);
+        det_bbox_num[0] = det_result.size() + 1;
+
+        // step3: extract feature for all boxes in an inmage
+        SearchResult search_result;
+        for (int j = 0; j < det_result.size(); ++j) {
+            int w = det_result[j].rect[2] - det_result[j].rect[0];
+            int h = det_result[j].rect[3] - det_result[j].rect[1];
+            cv::Rect rect(det_result[j].rect[0], det_result[j].rect[1], w, h);
+            cv::Mat crop_img = srcimg(rect);
+            feature_extracter.Run(crop_img, feature, cls_times);
+            features.insert(features.end(), feature.begin(), feature.end());
+        }
+
+        // step4: get search result
+        auto search_start = std::chrono::steady_clock::now();
+        search_result = searcher.Search(features.data(), det_result.size());
+        auto search_end = std::chrono::steady_clock::now();
+
+        // nms for search result
+        for (int i = 0; i < det_result.size(); ++i) {
+            det_result[i].confidence = search_result.D[search_result.return_k * i];
+        }
+        NMSBoxes(det_result, searcher.GetThreshold(), rec_nms_thresold, indeices);
+        auto nms_end = std::chrono::steady_clock::now();
+        std::chrono::duration<float> search_diff = search_end - search_start;
+        search_times[1] += double(search_diff.count() * 1000);
+
+        std::chrono::duration<float> nms_diff = nms_end - search_end;
+        search_times[2] += double(nms_diff.count() * 1000);
+
+        // print result
+        if (not benchmark or (benchmark and idx >= warmup_iter))
+            PrintResult(img_path, det_result, indeices, searcher, search_result);
+
+        // for postprocess
+        batch_imgs.clear();
+        img_paths.clear();
+        det_bbox_num.clear();
+        det_result.clear();
+        feature.clear();
+        features.clear();
+        indeices.clear();
+        if (benchmark and warmup_iter == idx + 1) {
+            det_times = {0, 0, 0};
+            cls_times = {0, 0, 0};
+            search_times = {0, 0, 0};
+            instance_num = 0;
+        }
+    }
+
+    if (benchmark) {
+        std::string presion = "fp32";
+        if (config.config_file["Global"]["use_fp16"].IsDefined() and
+            config.config_file["Global"]["use_fp16"].as<bool>())
+            presion = "fp16";
+        bool use_gpu = config.config_file["Global"]["use_gpu"].as<bool>();
+        bool use_tensorrt = config.config_file["Global"]["use_tensorrt"].as<bool>();
+        bool enable_mkldnn =
+                config.config_file["Global"]["enable_mkldnn"].as<bool>();
+        int cpu_num_threads =
+                config.config_file["Global"]["cpu_num_threads"].as<int>();
+        int batch_size = config.config_file["Global"]["batch_size"].as<int>();
+        std::vector<int> shape =
+                config.config_file["Global"]["image_shape"].as < std::vector < int >> ();
+        std::string det_shape = std::to_string(shape[0]);
+        for (int i = 1; i < shape.size(); ++i)
+            det_shape = det_shape + ", " + std::to_string(shape[i]);
+
+        AutoLogger autolog_det("Det", use_gpu, use_tensorrt, enable_mkldnn,
+                               cpu_num_threads, batch_size, det_shape, presion,
+                               det_times, img_files_list.size() - warmup_iter);
+        autolog_det.report();
+        AutoLogger autolog_rec("Rec", use_gpu, use_tensorrt, enable_mkldnn,
+                               cpu_num_threads, batch_size, "3, 224, 224", presion,
+                               cls_times, instance_num);
+        autolog_rec.report();
+        AutoLogger autolog_search("Search", false, use_tensorrt, enable_mkldnn,
+                                  cpu_num_threads, batch_size, "dynamic", presion,
+                                  search_times, instance_num);
+        autolog_search.report();
+    }
+    return 0;
+}

deploy/cpp_shitu/src/object_detector.cpp

+//   Copyright (c) 2020 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 <sstream>
+// for setprecision
+#include "include/object_detector.h"
+#include <chrono>
+#include <iomanip>
+
+using namespace paddle_infer;
+
+namespace Detection {
+
+// Load Model and create model predictor
+    void ObjectDetector::LoadModel(const std::string &model_dir,
+                                   const int batch_size,
+                                   const std::string &run_mode) {
+        paddle_infer::Config config;
+        std::string prog_file = model_dir + OS_PATH_SEP + "inference.pdmodel";
+        std::string params_file = model_dir + OS_PATH_SEP + "inference.pdiparams";
+        config.SetModel(prog_file, params_file);
+        if (this->use_gpu_) {
+            config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+            config.SwitchIrOptim(this->ir_optim_);
+            //     // use tensorrt
+            // if (run_mode != "fluid") {
+            //   auto precision = paddle_infer::Config::Precision::kFloat32;
+            //   if (run_mode == "trt_fp32") {
+            //     precision = paddle_infer::Config::Precision::kFloat32;
+            //   }
+            //   else if (run_mode == "trt_fp16") {
+            //     precision = paddle_infer::Config::Precision::kHalf;
+            //   }
+            //   else if (run_mode == "trt_int8") {
+            //     precision = paddle_infer::Config::Precision::kInt8;
+            //   } else {
+            //       printf("run_mode should be 'fluid', 'trt_fp32', 'trt_fp16' or
+            //       'trt_int8'");
+            //       }
+            // set tensorrt
+
+            if (this->use_tensorrt_) {
+                config.EnableTensorRtEngine(
+                        1 << 30, batch_size, this->min_subgraph_size_,
+                        this->use_fp16_ ? paddle_infer::Config::Precision::kHalf
+                                        : paddle_infer::Config::Precision::kFloat32,
+                        false, this->trt_calib_mode_);
+                // set use dynamic shape
+                if (this->use_dynamic_shape_) {
+                    // set DynamicShsape for image tensor
+                    const std::vector<int> min_input_shape = {1, 3, this->trt_min_shape_,
+                                                              this->trt_min_shape_};
+                    const std::vector<int> max_input_shape = {1, 3, this->trt_max_shape_,
+                                                              this->trt_max_shape_};
+                    const std::vector<int> opt_input_shape = {1, 3, this->trt_opt_shape_,
+                                                              this->trt_opt_shape_};
+                    const std::map <std::string, std::vector<int>> map_min_input_shape = {
+                            {"image", min_input_shape}};
+                    const std::map <std::string, std::vector<int>> map_max_input_shape = {
+                            {"image", max_input_shape}};
+                    const std::map <std::string, std::vector<int>> map_opt_input_shape = {
+                            {"image", opt_input_shape}};
+
+                    config.SetTRTDynamicShapeInfo(map_min_input_shape, map_max_input_shape,
+                                                  map_opt_input_shape);
+                    std::cout << "TensorRT dynamic shape enabled" << std::endl;
+                }
+            }
+
+            // } else if (this->device_ == "XPU"){
+            //   config.EnableXpu(10*1024*1024);
+        } else {
+            config.DisableGpu();
+            if (this->use_mkldnn_) {
+                config.EnableMKLDNN();
+                // cache 10 different shapes for mkldnn to avoid memory leak
+                config.SetMkldnnCacheCapacity(10);
+            }
+            config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+        }
+        config.SwitchUseFeedFetchOps(false);
+        config.SwitchIrOptim(this->ir_optim_);
+        config.DisableGlogInfo();
+        // Memory optimization
+        config.EnableMemoryOptim();
+        predictor_ = std::move(CreatePredictor(config));
+    }
+
+// Visualiztion MaskDetector results
+    cv::Mat VisualizeResult(const cv::Mat &img,
+                            const std::vector <ObjectResult> &results,
+                            const std::vector <std::string> &lables,
+                            const std::vector<int> &colormap,
+                            const bool is_rbox = false) {
+        cv::Mat vis_img = img.clone();
+        for (int i = 0; i < results.size(); ++i) {
+            // Configure color and text size
+            std::ostringstream oss;
+            oss << std::setiosflags(std::ios::fixed) << std::setprecision(4);
+            oss << lables[results[i].class_id] << " ";
+            oss << results[i].confidence;
+            std::string text = oss.str();
+            int c1 = colormap[3 * results[i].class_id + 0];
+            int c2 = colormap[3 * results[i].class_id + 1];
+            int c3 = colormap[3 * results[i].class_id + 2];
+            cv::Scalar roi_color = cv::Scalar(c1, c2, c3);
+            int font_face = cv::FONT_HERSHEY_COMPLEX_SMALL;
+            double font_scale = 0.5f;
+            float thickness = 0.5;
+            cv::Size text_size =
+                    cv::getTextSize(text, font_face, font_scale, thickness, nullptr);
+            cv::Point origin;
+
+            if (is_rbox) {
+                // Draw object, text, and background
+                for (int k = 0; k < 4; k++) {
+                    cv::Point pt1 = cv::Point(results[i].rect[(k * 2) % 8],
+                                              results[i].rect[(k * 2 + 1) % 8]);
+                    cv::Point pt2 = cv::Point(results[i].rect[(k * 2 + 2) % 8],
+                                              results[i].rect[(k * 2 + 3) % 8]);
+                    cv::line(vis_img, pt1, pt2, roi_color, 2);
+                }
+            } else {
+                int w = results[i].rect[2] - results[i].rect[0];
+                int h = results[i].rect[3] - results[i].rect[1];
+                cv::Rect roi = cv::Rect(results[i].rect[0], results[i].rect[1], w, h);
+                // Draw roi object, text, and background
+                cv::rectangle(vis_img, roi, roi_color, 2);
+            }
+
+            origin.x = results[i].rect[0];
+            origin.y = results[i].rect[1];
+
+            // Configure text background
+            cv::Rect text_back =
+                    cv::Rect(results[i].rect[0], results[i].rect[1] - text_size.height,
+                             text_size.width, text_size.height);
+            // Draw text, and background
+            cv::rectangle(vis_img, text_back, roi_color, -1);
+            cv::putText(vis_img, text, origin, font_face, font_scale,
+                        cv::Scalar(255, 255, 255), thickness);
+        }
+        return vis_img;
+    }
+
+    void ObjectDetector::Preprocess(const cv::Mat &ori_im) {
+        // Clone the image : keep the original mat for postprocess
+        cv::Mat im = ori_im.clone();
+        cv::cvtColor(im, im, cv::COLOR_BGR2RGB);
+        preprocessor_.Run(&im, &inputs_);
+    }
+
+    void ObjectDetector::Postprocess(const std::vector <cv::Mat> mats,
+                                     std::vector <ObjectResult> *result,
+                                     std::vector<int> bbox_num,
+                                     bool is_rbox = false) {
+        result->clear();
+        int start_idx = 0;
+        for (int im_id = 0; im_id < mats.size(); im_id++) {
+            cv::Mat raw_mat = mats[im_id];
+            int rh = 1;
+            int rw = 1;
+            //     if (config_.arch_ == "Face") {
+            // rh = raw_mat.rows;
+            // rw = raw_mat.cols;
+            //     }
+            for (int j = start_idx; j < start_idx + bbox_num[im_id]; j++) {
+                if (is_rbox) {
+                    // Class id
+                    int class_id = static_cast<int>(round(output_data_[0 + j * 10]));
+                    // Confidence score
+                    float score = output_data_[1 + j * 10];
+                    int x1 = (output_data_[2 + j * 10] * rw);
+                    int y1 = (output_data_[3 + j * 10] * rh);
+                    int x2 = (output_data_[4 + j * 10] * rw);
+                    int y2 = (output_data_[5 + j * 10] * rh);
+                    int x3 = (output_data_[6 + j * 10] * rw);
+                    int y3 = (output_data_[7 + j * 10] * rh);
+                    int x4 = (output_data_[8 + j * 10] * rw);
+                    int y4 = (output_data_[9 + j * 10] * rh);
+
+                    ObjectResult result_item;
+                    result_item.rect = {x1, y1, x2, y2, x3, y3, x4, y4};
+                    result_item.class_id = class_id;
+                    result_item.confidence = score;
+                    result->push_back(result_item);
+                } else {
+                    // Class id
+                    int class_id = static_cast<int>(round(output_data_[0 + j * 6]));
+                    // Confidence score
+                    float score = output_data_[1 + j * 6];
+                    int xmin = (output_data_[2 + j * 6] * rw);
+                    int ymin = (output_data_[3 + j * 6] * rh);
+                    int xmax = (output_data_[4 + j * 6] * rw);
+                    int ymax = (output_data_[5 + j * 6] * rh);
+                    int wd = xmax - xmin;
+                    int hd = ymax - ymin;
+
+                    ObjectResult result_item;
+                    result_item.rect = {xmin, ymin, xmax, ymax};
+                    result_item.class_id = class_id;
+                    result_item.confidence = score;
+                    result->push_back(result_item);
+                }
+            }
+            start_idx += bbox_num[im_id];
+        }
+    }
+
+    void ObjectDetector::Predict(const std::vector <cv::Mat> imgs, const int warmup,
+                                 const int repeats,
+                                 std::vector <ObjectResult> *result,
+                                 std::vector<int> *bbox_num,
+                                 std::vector<double> *times) {
+        auto preprocess_start = std::chrono::steady_clock::now();
+        int batch_size = imgs.size();
+
+        // in_data_batch
+        std::vector<float> in_data_all;
+        std::vector<float> im_shape_all(batch_size * 2);
+        std::vector<float> scale_factor_all(batch_size * 2);
+
+        // Preprocess image
+        for (int bs_idx = 0; bs_idx < batch_size; bs_idx++) {
+            cv::Mat im = imgs.at(bs_idx);
+            Preprocess(im);
+            im_shape_all[bs_idx * 2] = inputs_.im_shape_[0];
+            im_shape_all[bs_idx * 2 + 1] = inputs_.im_shape_[1];
+
+            scale_factor_all[bs_idx * 2] = inputs_.scale_factor_[0];
+            scale_factor_all[bs_idx * 2 + 1] = inputs_.scale_factor_[1];
+
+            // TODO: reduce cost time
+            in_data_all.insert(in_data_all.end(), inputs_.im_data_.begin(),
+                               inputs_.im_data_.end());
+        }
+
+        // Prepare input tensor
+        auto input_names = predictor_->GetInputNames();
+        for (const auto &tensor_name : input_names) {
+            auto in_tensor = predictor_->GetInputHandle(tensor_name);
+            if (tensor_name == "image") {
+                int rh = inputs_.in_net_shape_[0];
+                int rw = inputs_.in_net_shape_[1];
+                in_tensor->Reshape({batch_size, 3, rh, rw});
+                in_tensor->CopyFromCpu(in_data_all.data());
+            } else if (tensor_name == "im_shape") {
+                in_tensor->Reshape({batch_size, 2});
+                in_tensor->CopyFromCpu(im_shape_all.data());
+            } else if (tensor_name == "scale_factor") {
+                in_tensor->Reshape({batch_size, 2});
+                in_tensor->CopyFromCpu(scale_factor_all.data());
+            }
+        }
+
+        auto preprocess_end = std::chrono::steady_clock::now();
+        // Run predictor
+        // warmup
+        for (int i = 0; i < warmup; i++) {
+            predictor_->Run();
+            // Get output tensor
+            auto output_names = predictor_->GetOutputNames();
+            auto out_tensor = predictor_->GetOutputHandle(output_names[0]);
+            std::vector<int> output_shape = out_tensor->shape();
+            auto out_bbox_num = predictor_->GetOutputHandle(output_names[1]);
+            std::vector<int> out_bbox_num_shape = out_bbox_num->shape();
+            // Calculate output length
+            int output_size = 1;
+            for (int j = 0; j < output_shape.size(); ++j) {
+                output_size *= output_shape[j];
+            }
+
+            if (output_size < 6) {
+                std::cerr << "[WARNING] No object detected." << std::endl;
+            }
+            output_data_.resize(output_size);
+            out_tensor->CopyToCpu(output_data_.data());
+
+            int out_bbox_num_size = 1;
+            for (int j = 0; j < out_bbox_num_shape.size(); ++j) {
+                out_bbox_num_size *= out_bbox_num_shape[j];
+            }
+            out_bbox_num_data_.resize(out_bbox_num_size);
+            out_bbox_num->CopyToCpu(out_bbox_num_data_.data());
+        }
+
+        bool is_rbox = false;
+        auto inference_start = std::chrono::steady_clock::now();
+        for (int i = 0; i < repeats; i++) {
+            predictor_->Run();
+            // Get output tensor
+            auto output_names = predictor_->GetOutputNames();
+            auto out_tensor = predictor_->GetOutputHandle(output_names[0]);
+            std::vector<int> output_shape = out_tensor->shape();
+            auto out_bbox_num = predictor_->GetOutputHandle(output_names[1]);
+            std::vector<int> out_bbox_num_shape = out_bbox_num->shape();
+            // Calculate output length
+            int output_size = 1;
+            for (int j = 0; j < output_shape.size(); ++j) {
+                output_size *= output_shape[j];
+            }
+            is_rbox = output_shape[output_shape.size() - 1] % 10 == 0;
+
+            if (output_size < 6) {
+                std::cerr << "[WARNING] No object detected." << std::endl;
+            }
+            output_data_.resize(output_size);
+            out_tensor->CopyToCpu(output_data_.data());
+
+            int out_bbox_num_size = 1;
+            for (int j = 0; j < out_bbox_num_shape.size(); ++j) {
+                out_bbox_num_size *= out_bbox_num_shape[j];
+            }
+            out_bbox_num_data_.resize(out_bbox_num_size);
+            out_bbox_num->CopyToCpu(out_bbox_num_data_.data());
+        }
+        auto inference_end = std::chrono::steady_clock::now();
+        auto postprocess_start = std::chrono::steady_clock::now();
+        // Postprocessing result
+        result->clear();
+        Postprocess(imgs, result, out_bbox_num_data_, is_rbox);
+        bbox_num->clear();
+        for (int k = 0; k < out_bbox_num_data_.size(); k++) {
+            int tmp = out_bbox_num_data_[k];
+            bbox_num->push_back(tmp);
+        }
+        auto postprocess_end = std::chrono::steady_clock::now();
+
+        std::chrono::duration<float> preprocess_diff =
+                preprocess_end - preprocess_start;
+        times->push_back(double(preprocess_diff.count() * 1000));
+        std::chrono::duration<float> inference_diff = inference_end - inference_start;
+        times->push_back(double(inference_diff.count() / repeats * 1000));
+        std::chrono::duration<float> postprocess_diff =
+                postprocess_end - postprocess_start;
+        times->push_back(double(postprocess_diff.count() * 1000));
+    }
+
+    std::vector<int> GenerateColorMap(int num_class) {
+        auto colormap = std::vector<int>(3 * num_class, 0);
+        for (int i = 0; i < num_class; ++i) {
+            int j = 0;
+            int lab = i;
+            while (lab) {
+                colormap[i * 3] |= (((lab >> 0) & 1) << (7 - j));
+                colormap[i * 3 + 1] |= (((lab >> 1) & 1) << (7 - j));
+                colormap[i * 3 + 2] |= (((lab >> 2) & 1) << (7 - j));
+                ++j;
+                lab >>= 3;
+            }
+        }
+        return colormap;
+    }
+
+} // namespace Detection

deploy/cpp_shitu/src/preprocess_op.cpp

+// Copyright (c) 2020 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 "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include "paddle_api.h"
+#include "paddle_inference_api.h"
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <ostream>
+#include <vector>
+
+#include <cstring>
+#include <fstream>
+#include <math.h>
+#include <numeric>
+
+#include <include/preprocess_op.h>
+
+namespace Feature {
+
+    void Permute::Run(const cv::Mat *im, float *data) {
+        int rh = im->rows;
+        int rw = im->cols;
+        int rc = im->channels();
+        for (int i = 0; i < rc; ++i) {
+            cv::extractChannel(*im, cv::Mat(rh, rw, CV_32FC1, data + i * rh * rw), i);
+        }
+    }
+
+    void Normalize::Run(cv::Mat *im, const std::vector<float> &mean,
+                        const std::vector<float> &std, float scale) {
+        (*im).convertTo(*im, CV_32FC3, scale);
+        for (int h = 0; h < im->rows; h++) {
+            for (int w = 0; w < im->cols; w++) {
+                im->at<cv::Vec3f>(h, w)[0] =
+                        (im->at<cv::Vec3f>(h, w)[0] - mean[0]) / std[0];
+                im->at<cv::Vec3f>(h, w)[1] =
+                        (im->at<cv::Vec3f>(h, w)[1] - mean[1]) / std[1];
+                im->at<cv::Vec3f>(h, w)[2] =
+                        (im->at<cv::Vec3f>(h, w)[2] - mean[2]) / std[2];
+            }
+        }
+    }
+
+    void CenterCropImg::Run(cv::Mat &img, const int crop_size) {
+        int resize_w = img.cols;
+        int resize_h = img.rows;
+        int w_start = int((resize_w - crop_size) / 2);
+        int h_start = int((resize_h - crop_size) / 2);
+        cv::Rect rect(w_start, h_start, crop_size, crop_size);
+        img = img(rect);
+    }
+
+    void ResizeImg::Run(const cv::Mat &img, cv::Mat &resize_img,
+                        int resize_short_size, int size) {
+        int resize_h = 0;
+        int resize_w = 0;
+        if (size > 0) {
+            resize_h = size;
+            resize_w = size;
+        } else {
+            int w = img.cols;
+            int h = img.rows;
+
+            float ratio = 1.f;
+            if (h < w) {
+                ratio = float(resize_short_size) / float(h);
+            } else {
+                ratio = float(resize_short_size) / float(w);
+            }
+            resize_h = round(float(h) * ratio);
+            resize_w = round(float(w) * ratio);
+        }
+        cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
+    }
+
+} // namespace Feature

deploy/cpp_shitu/src/preprocess_op_det.cpp

+//   Copyright (c) 2020 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 <string>
+#include <vector>
+
+#include "include/preprocess_op_det.h"
+
+namespace Detection {
+
+    void InitInfo::Run(cv::Mat *im, ImageBlob *data) {
+        data->im_shape_ = {static_cast<float>(im->rows),
+                           static_cast<float>(im->cols)};
+        data->scale_factor_ = {1., 1.};
+        data->in_net_shape_ = {static_cast<float>(im->rows),
+                               static_cast<float>(im->cols)};
+    }
+
+    void NormalizeImage::Run(cv::Mat *im, ImageBlob *data) {
+        double e = 1.0;
+        if (is_scale_) {
+            e /= 255.0;
+        }
+        (*im).convertTo(*im, CV_32FC3, e);
+        for (int h = 0; h < im->rows; h++) {
+            for (int w = 0; w < im->cols; w++) {
+                im->at<cv::Vec3f>(h, w)[0] =
+                        (im->at<cv::Vec3f>(h, w)[0] - mean_[0]) / scale_[0];
+                im->at<cv::Vec3f>(h, w)[1] =
+                        (im->at<cv::Vec3f>(h, w)[1] - mean_[1]) / scale_[1];
+                im->at<cv::Vec3f>(h, w)[2] =
+                        (im->at<cv::Vec3f>(h, w)[2] - mean_[2]) / scale_[2];
+            }
+        }
+    }
+
+    void Permute::Run(cv::Mat *im, ImageBlob *data) {
+        int rh = im->rows;
+        int rw = im->cols;
+        int rc = im->channels();
+        (data->im_data_).resize(rc * rh * rw);
+        float *base = (data->im_data_).data();
+        for (int i = 0; i < rc; ++i) {
+            cv::extractChannel(*im, cv::Mat(rh, rw, CV_32FC1, base + i * rh * rw), i);
+        }
+    }
+
+    void Resize::Run(cv::Mat *im, ImageBlob *data) {
+        auto resize_scale = GenerateScale(*im);
+        data->im_shape_ = {static_cast<float>(im->cols * resize_scale.first),
+                           static_cast<float>(im->rows * resize_scale.second)};
+        data->in_net_shape_ = {static_cast<float>(im->cols * resize_scale.first),
+                               static_cast<float>(im->rows * resize_scale.second)};
+        cv::resize(*im, *im, cv::Size(), resize_scale.first, resize_scale.second,
+                   interp_);
+        data->im_shape_ = {
+                static_cast<float>(im->rows), static_cast<float>(im->cols),
+        };
+        data->scale_factor_ = {
+                resize_scale.second, resize_scale.first,
+        };
+    }
+
+    std::pair<double, double> Resize::GenerateScale(const cv::Mat &im) {
+        std::pair<double, double> resize_scale;
+        int origin_w = im.cols;
+        int origin_h = im.rows;
+
+        if (keep_ratio_) {
+            int im_size_max = std::max(origin_w, origin_h);
+            int im_size_min = std::min(origin_w, origin_h);
+            int target_size_max =
+                    *std::max_element(target_size_.begin(), target_size_.end());
+            int target_size_min =
+                    *std::min_element(target_size_.begin(), target_size_.end());
+            double scale_min =
+                    static_cast<double>(target_size_min) / static_cast<double>(im_size_min);
+            double scale_max =
+                    static_cast<double>(target_size_max) / static_cast<double>(im_size_max);
+            double scale_ratio = std::min(scale_min, scale_max);
+            resize_scale = {scale_ratio, scale_ratio};
+        } else {
+            resize_scale.first =
+                    static_cast<double>(target_size_[1]) / static_cast<double>(origin_w);
+            resize_scale.second =
+                    static_cast<double>(target_size_[0]) / static_cast<double>(origin_h);
+        }
+        return resize_scale;
+    }
+
+    void PadStride::Run(cv::Mat *im, ImageBlob *data) {
+        if (stride_ <= 0) {
+            return;
+        }
+        int rc = im->channels();
+        int rh = im->rows;
+        int rw = im->cols;
+        int nh = (rh / stride_) * stride_ + (rh % stride_ != 0) * stride_;
+        int nw = (rw / stride_) * stride_ + (rw % stride_ != 0) * stride_;
+        cv::copyMakeBorder(*im, *im, 0, nh - rh, 0, nw - rw, cv::BORDER_CONSTANT,
+                           cv::Scalar(0));
+        data->in_net_shape_ = {
+                static_cast<float>(im->rows), static_cast<float>(im->cols),
+        };
+    }
+
+// Preprocessor op running order
+    const std::vector <std::string> Preprocessor::RUN_ORDER = {
+            "InitInfo", "Resize", "NormalizeImage", "PadStride", "Permute"};
+
+    void Preprocessor::Run(cv::Mat *im, ImageBlob *data) {
+        for (const auto &name : RUN_ORDER) {
+            if (ops_.find(name) != ops_.end()) {
+                ops_[name]->Run(im, data);
+            }
+        }
+    }
+
+} // namespace Detection

deploy/cpp_shitu/src/vector_search.cpp

+// Copyright (c) 2020 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 "include/vector_search.h"
+#include <cstdio>
+#include <faiss/index_factory.h>
+#include <faiss/index_io.h>
+#include <fstream>
+#include <iostream>
+#include <regex>
+
+void VectorSearch::LoadIndexFile() {
+    std::string file_path = this->index_dir + OS_PATH_SEP + "vector.index";
+    const char *fname = file_path.c_str();
+    this->index = faiss::read_index(fname, 0);
+}
+
+void VectorSearch::LoadIdMap() {
+    std::string file_path = this->index_dir + OS_PATH_SEP + "id_map.txt";
+    std::ifstream in(file_path);
+    std::string line;
+    std::vector <std::string> m_vec;
+    if (in) {
+        while (getline(in, line)) {
+            std::regex ws_re("\\s+");
+            std::vector <std::string> v(
+                    std::sregex_token_iterator(line.begin(), line.end(), ws_re, -1),
+                    std::sregex_token_iterator());
+            if (v.size() != 2) {
+                std::cout << "The number of element for each line in : " << file_path
+                          << "must be 2, exit the program..." << std::endl;
+                exit(1);
+            } else
+                this->id_map.insert(std::pair<long int, std::string>(
+                        std::stol(v[0], nullptr, 10), v[1]));
+        }
+    }
+}
+
+const SearchResult &VectorSearch::Search(float *feature, int query_number) {
+    this->D.resize(this->return_k * query_number);
+    this->I.resize(this->return_k * query_number);
+    this->index->search(query_number, feature, return_k, D.data(), I.data());
+    this->sr.return_k = this->return_k;
+    this->sr.D = this->D;
+    this->sr.I = this->I;
+    return this->sr;
+}
+
+const std::string &VectorSearch::GetLabel(faiss::Index::idx_t ind) {
+    return this->id_map.at(ind);
+}

deploy/cpp_shitu/src/yaml_config.cpp

+// Copyright (c) 2020 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 <iostream>
+#include <ostream>
+#include <vector>
+
+#include <include/yaml_config.h>
+
+
+std::vector <std::string> YamlConfig::ReadDict(const std::string &path) {
+    std::ifstream in(path);
+    std::string line;
+    std::vector <std::string> m_vec;
+    if (in) {
+        while (getline(in, line)) {
+            m_vec.push_back(line);
+        }
+    } else {
+        std::cout << "no such label file: " << path << ", exit the program..."
+                  << std::endl;
+        exit(1);
+    }
+    return m_vec;
+}
+
+std::map<int, std::string> YamlConfig::ReadIndexId(const std::string &path) {
+    std::ifstream in(path);
+    std::string line;
+    std::map<int, std::string> m_vec;
+    if (in) {
+        while (getline(in, line)) {
+            std::regex ws_re("\\s+");
+            std::vector <std::string> v(
+                    std::sregex_token_iterator(line.begin(), line.end(), ws_re, -1),
+                    std::sregex_token_iterator());
+            if (v.size() != 3) {
+                std::cout << "The number of element for each line in : " << path
+                          << "must be 3, exit the program..." << std::endl;
+                exit(1);
+            } else
+                m_vec.insert(std::pair<int, std::string>(stoi(v[0]), v[2]));
+        }
+    }
+    return m_vec;
+}
+
+YAML::Node YamlConfig::ReadYamlConfig(const std::string &path) {
+    YAML::Node config;
+    try {
+        config = YAML::LoadFile(path);
+    } catch (YAML::BadFile &e) {
+        std::cout << "Something wrong in yaml file, please check yaml file"
+                  << std::endl;
+        exit(1);
+    }
+    return config;
+}
+
+void YamlConfig::PrintConfigInfo() {
+    std::cout << this->config_file << std::endl;
+    //   for (YAML::const_iterator
+    //   it=config_file.begin();it!=config_file.end();++it)
+    // {
+    //   std::cout << it->as<std::string>() << "\n";
+    //   }
+}

deploy/cpp_shitu/tools/build.sh

+OPENCV_DIR=${opencv_install_dir}
+LIB_DIR=${paddle_inference_dir}
+CUDA_LIB_DIR=/usr/local/cuda/lib64
+CUDNN_LIB_DIR=/usr/lib/x86_64-linux-gnu/
+FAISS_DIR=${faiss_install_dir}
+FAISS_WITH_MKL=OFF
+
+BUILD_DIR=build
+rm -rf ${BUILD_DIR}
+mkdir ${BUILD_DIR}
+cd ${BUILD_DIR}
+cmake .. \
+    -DPADDLE_LIB=${LIB_DIR} \
+    -DWITH_MKL=ON \
+    -DWITH_GPU=OFF \
+    -DWITH_STATIC_LIB=OFF \
+    -DUSE_TENSORRT=OFF \
+    -DOPENCV_DIR=${OPENCV_DIR} \
+    -DCUDNN_LIB=${CUDNN_LIB_DIR} \
+    -DCUDA_LIB=${CUDA_LIB_DIR} \
+    -DFAISS_DIR=${FAISS_DIR} \
+    -DFAISS_WITH_MKL=${FAISS_WITH_MKL}
+
+make -j
+cd ..

deploy/cpp_shitu/tools/transform_id_map.py

+import argparse
+import os
+import pickle
+
+import yaml
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--config', type=str, required=True)
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    with open(args.config) as fd:
+        config = yaml.load(fd.read(), yaml.FullLoader)
+    index_dir = ""
+    try:
+        index_dir = config["IndexProcess"]["index_dir"]
+    except Exception as e:
+        print("The IndexProcess.index_dir in config_file dose not exist")
+        exit(1)
+    id_map_path = os.path.join(index_dir, "id_map.pkl")
+    assert os.path.exists(
+        id_map_path), "The id_map file dose not exist: {}".format(id_map_path)
+
+    with open(id_map_path, "rb") as fd:
+        ids = pickle.load(fd)
+    with open(os.path.join(index_dir, "id_map.txt"), "w") as fd:
+        for k, v in ids.items():
+            v = v.split("\t")[1]
+            fd.write(str(k) + " " + v + "\n")
+    print('Transform id_map sucess')
+
+
+if __name__ == "__main__":
+    main()

deploy/lite_shitu/Makefile

+ARM_ABI = arm8#[arm7/arm8]
+export ARM_ABI
+
+ifeq ($(ARM_ABI), arm8)
+    ARM_PLAT=arm64-v8a
+else
+    ARM_PLAT=armeabi-v7a
+endif
+${info ARM_ABI: ${ARM_ABI}}
+${info ARM_PLAT: ${ARM_PLAT}; option[arm7/arm8]}
+
+include ../Makefile.def
+
+LITE_ROOT=../../../
+${info LITE_ROOT: $(abspath ${LITE_ROOT})}
+
+THIRD_PARTY_DIR=third_party
+${info THIRD_PARTY_DIR: $(abspath ${THIRD_PARTY_DIR})}
+
+
+OPENCV_VERSION=opencv4.1.0
+OPENCV_LIBS = ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/libs/libopencv_imgcodecs.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/libs/libopencv_imgproc.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/libs/libopencv_core.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/libtegra_hal.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/liblibjpeg-turbo.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/liblibwebp.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/liblibpng.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/liblibjasper.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/liblibtiff.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/libIlmImf.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/libtbb.a \
+              ${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/3rdparty/libs/libcpufeatures.a
+
+
+LITE_LIBS = -L${LITE_ROOT}/cxx/lib/ -lpaddle_light_api_shared
+###############################################################
+# How to use one of static libaray:                           #
+#  `libpaddle_api_full_bundled.a`                             #
+#  `libpaddle_api_light_bundled.a`                            #
+###############################################################
+# Note: default use lite's shared library.                    #
+###############################################################
+# 1. Comment above line using `libpaddle_light_api_shared.so`
+# 2. Undo comment below line using `libpaddle_api_light_bundled.a`
+# LITE_LIBS = ${LITE_ROOT}/cxx/lib/libpaddle_api_light_bundled.a
+
+CXX_LIBS = $(LITE_LIBS) ${OPENCV_LIBS} $(SYSTEM_LIBS)
+
+LOCAL_DIRSRCS=$(wildcard src/*.cc)
+LOCAL_SRCS=$(notdir $(LOCAL_DIRSRCS))
+LOCAL_OBJS=$(patsubst %.cpp, %.o, $(patsubst %.cc, %.o, $(LOCAL_SRCS)))
+
+JSON_OBJS = json_reader.o json_value.o json_writer.o
+
+pp_shitu: $(LOCAL_OBJS) $(JSON_OBJS) fetch_opencv
+	$(CC) $(SYSROOT_LINK) $(CXXFLAGS_LINK) $(LOCAL_OBJS) $(JSON_OBJS) -o pp_shitu $(CXX_LIBS) $(LDFLAGS)
+
+fetch_opencv:
+	@ test -d ${THIRD_PARTY_DIR} ||  mkdir ${THIRD_PARTY_DIR}
+	@ test -e ${THIRD_PARTY_DIR}/${OPENCV_VERSION}.tar.gz || \
+      (echo "fetch opencv libs" && \
+      wget -P ${THIRD_PARTY_DIR} https://paddle-inference-dist.bj.bcebos.com/${OPENCV_VERSION}.tar.gz)
+	@ test -d ${THIRD_PARTY_DIR}/${OPENCV_VERSION} || \
+      tar -zxf ${THIRD_PARTY_DIR}/${OPENCV_VERSION}.tar.gz -C ${THIRD_PARTY_DIR}
+
+fetch_json_code:
+	@ test -d ${THIRD_PARTY_DIR} ||  mkdir ${THIRD_PARTY_DIR}
+	@ test -e ${THIRD_PARTY_DIR}/jsoncpp_code.tar.gz || \
+      (echo "fetch jsoncpp_code.tar.gz" && \
+      wget -P ${THIRD_PARTY_DIR} https://bj.bcebos.com/v1/paddledet/deploy/jsoncpp_code.tar.gz )
+	@ test -d ${THIRD_PARTY_DIR}/jsoncpp_code || \
+      tar -zxf ${THIRD_PARTY_DIR}/jsoncpp_code.tar.gz -C ${THIRD_PARTY_DIR}
+
+LOCAL_INCLUDES = -I./ -Iinclude
+OPENCV_INCLUDE = -I${THIRD_PARTY_DIR}/${OPENCV_VERSION}/${ARM_PLAT}/include
+JSON_INCLUDE = -I${THIRD_PARTY_DIR}/jsoncpp_code/include
+CXX_INCLUDES = ${LOCAL_INCLUDES} ${INCLUDES} ${OPENCV_INCLUDE} ${JSON_INCLUDE} -I$(LITE_ROOT)/cxx/include
+
+
+$(LOCAL_OBJS): %.o: src/%.cc fetch_opencv fetch_json_code
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -c $< -o $@
+
+$(JSON_OBJS): %.o: ${THIRD_PARTY_DIR}/jsoncpp_code/%.cpp fetch_json_code
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -c $< -o $@
+
+.PHONY: clean fetch_opencv fetch_json_code
+clean:
+	rm -rf $(LOCAL_OBJS) $(JSON_OBJS)
+	rm -f pp_shitu

deploy/lite_shitu/generate_json_config.py

+import argparse
+import json
+import os
+
+import yaml
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--yaml_path', type=str, default='../configs/inference_drink.yaml')
+    parser.add_argument(
+        '--img_dir',
+        type=str,
+        default=None,
+        help='The dir path for inference images')
+    parser.add_argument(
+        '--img_path',
+        type=str,
+        default=None,
+        help='The dir path for inference images')
+    parser.add_argument(
+        '--det_model_path',
+        type=str,
+        default='./det.nb',
+        help="The model path for mainbody  detection")
+    parser.add_argument(
+        '--rec_model_path',
+        type=str,
+        default='./rec.nb',
+        help="The rec model path")
+    parser.add_argument(
+        '--rec_label_path',
+        type=str,
+        default='./label.txt',
+        help='The rec model label')
+    parser.add_argument(
+        '--arch',
+        type=str,
+        default='PicoDet',
+        help='The model structure for detection model')
+    parser.add_argument(
+        '--fpn-stride',
+        type=list,
+        default=[8, 16, 32, 64],
+        help="The fpn strid for detection model")
+    parser.add_argument(
+        '--keep_top_k',
+        type=int,
+        default=100,
+        help='The params for nms(postprocess for detection)')
+    parser.add_argument(
+        '--nms-name',
+        type=str,
+        default='MultiClassNMS',
+        help='The nms name for postprocess of detection model')
+    parser.add_argument(
+        '--nms_threshold',
+        type=float,
+        default=0.5,
+        help='The nms nms_threshold for detection postprocess')
+    parser.add_argument(
+        '--nms_top_k',
+        type=int,
+        default=1000,
+        help='The nms_top_k in postprocess of detection model')
+    parser.add_argument(
+        '--score_threshold',
+        type=float,
+        default=0.3,
+        help='The score_threshold for postprocess of detection')
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    config_yaml = yaml.safe_load(open(args.yaml_path))
+    config_json = {}
+    config_json["Global"] = {}
+    config_json["Global"][
+        "infer_imgs"] = args.img_path if args.img_path else config_yaml[
+            "Global"]["infer_imgs"]
+    if args.img_dir is not None:
+        config_json["Global"]["infer_imgs_dir"] = args.img_dir
+        config_json["Global"]["infer_imgs"] = None
+    else:
+        config_json["Global"][
+            "infer_imgs"] = args.img_path if args.img_path else config_yaml[
+                "Global"]["infer_imgs"]
+    config_json["Global"]["batch_size"] = config_yaml["Global"]["batch_size"]
+    config_json["Global"]["cpu_num_threads"] = min(
+        config_yaml["Global"]["cpu_num_threads"], 4)
+    config_json["Global"]["image_shape"] = config_yaml["Global"]["image_shape"]
+    config_json["Global"]["det_model_path"] = args.det_model_path
+    config_json["Global"]["rec_model_path"] = args.rec_model_path
+    config_json["Global"]["rec_label_path"] = args.rec_label_path
+    config_json["Global"]["label_list"] = config_yaml["Global"]["labe_list"]
+    config_json["Global"]["rec_nms_thresold"] = config_yaml["Global"][
+        "rec_nms_thresold"]
+    config_json["Global"]["max_det_results"] = config_yaml["Global"][
+        "max_det_results"]
+    config_json["Global"]["det_fpn_stride"] = args.fpn_stride
+    config_json["Global"]["det_arch"] = args.arch
+    config_json["Global"]["return_k"] = config_yaml["IndexProcess"]["return_k"]
+
+    # config_json["DetPreProcess"] = config_yaml["DetPreProcess"]
+    config_json["DetPreProcess"] = {}
+    config_json["DetPreProcess"]["transform_ops"] = []
+    for x in config_yaml["DetPreProcess"]["transform_ops"]:
+        k = list(x.keys())[0]
+        y = x[k]
+        y['type'] = k
+        config_json["DetPreProcess"]["transform_ops"].append(y)
+
+    config_json["DetPostProcess"] = {
+        "keep_top_k": args.keep_top_k,
+        "name": args.nms_name,
+        "nms_threshold": args.nms_threshold,
+        "nms_top_k": args.nms_top_k,
+        "score_threshold": args.score_threshold
+    }
+    #  config_json["RecPreProcess"] = config_yaml["RecPreProcess"]
+    config_json["RecPreProcess"] = {}
+    config_json["RecPreProcess"]["transform_ops"] = []
+    for x in config_yaml["RecPreProcess"]["transform_ops"]:
+        k = list(x.keys())[0]
+        y = x[k]
+        if y is not None:
+            y["type"] = k
+            config_json["RecPreProcess"]["transform_ops"].append(y)
+
+    with open('shitu_config.json', 'w') as fd:
+        json.dump(config_json, fd, indent=4)
+
+
+if __name__ == '__main__':
+    main()

deploy/lite_shitu/include/picodet_postprocess.h

+//   Copyright (c) 2021 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 <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include <ctime>
+#include <numeric>
+
+#include "include/utils.h"
+
+namespace PPShiTu {
+
+void PicoDetPostProcess(std::vector<PPShiTu::ObjectResult>* results,
+                         std::vector<const float *> outs,
+                         std::vector<int> fpn_stride,
+                         std::vector<float> im_shape,
+                         std::vector<float> scale_factor,
+                         float score_threshold = 0.3,
+                         float nms_threshold = 0.5,
+                         int num_class = 80,
+                         int reg_max = 7);
+
+}  // namespace PPShiTu