Merge pull request #1 from PaddlePaddle/develop

Develop

.gitignore

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

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

dataset/flowers102/generate_flowers102_list.py

-"""
-.mat files data format
-imagelabel.mat
-jpg_name   1     2     3 ... 
-label      32    12    66 ... 
-
-setid.mat
-jpg_name(10 records in a class)  24 6 100 65 32 ...
-label                            4 ...
-"""
-"""
-Usage: 
-    python generate_flower_list.py prefix_folder mode
-    python generate_flower_list.py jpg train > train_list.txt
-    python generate_flower_list.py jpg valid > val_list.txt
-"""
-
-import scipy.io
-import numpy as np
-import os
-import sys
-
-data_path = sys.argv[1]
-imagelabels_path = './imagelabels.mat'
-setid_path = './setid.mat'
-
-labels = scipy.io.loadmat(imagelabels_path)
-labels = np.array(labels['labels'][0])
-setid = scipy.io.loadmat(setid_path)
-
-d = {}
-d['train'] = np.array(setid['trnid'][0])
-d['valid'] = np.array(setid['valid'][0])
-d['test'] = np.array(setid['tstid'][0])
-
-for id in d[sys.argv[2]]:
-    message = str(data_path) + "/image_" + str(id).zfill(5) + ".jpg " + str(
-        labels[id - 1] - 1)
-    print(message)

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_general.yaml

-Global:
-  rec_inference_model_dir: "./models/general_PPLCNet_x2_5_lite_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
-  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

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_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_product_binary.yaml

@@ -53,8 +53,15 @@ RecPostProcess:
 
 # indexing engine config
 IndexProcess:
-  binary_index: true
+  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
+  batch_size: 32
+  binary_index: true
   return_k: 5
-  score_thres: 0
-  
+  score_thres: 0
\ 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,62 @@
 #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
+        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;
+        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,85 @@
 #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;
+        }
+
+        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};
+
+        void PrintConfigInfo();
+
+        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
\ No newline at end of file
+    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

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`等参数。
 
-* 最后执行以下命令，完成对一幅图像的分类。
+#### 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

@@ -16,98 +16,97 @@
 
 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);
+
+    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->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();
+
+        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;
     }
-    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;
-}
 
 } // namespace PaddleClas

deploy/cpp/src/cls_config.cpp

@@ -16,49 +16,20 @@
 
 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;
-}
-
-std::map<std::string, std::string>
-ClsConfig::LoadConfig(const std::string &config_path) {
-  auto config = Utility::ReadDict(config_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;
+    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::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;
-}
+    void ClsConfig::ReadYamlConfig(const std::string &path) {
 
-} // namespace PaddleClas
\ No newline at end of file
+        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);
+        }
+    }
+}; // namespace PaddleClas

deploy/cpp/src/main.cpp

@@ -27,6 +27,7 @@
 #include <numeric>
 
 #include <auto_log/autolog.h>
+#include <gflags/gflags.h>
 #include <include/cls.h>
 #include <include/cls_config.h>
 
@@ -34,74 +35,81 @@ 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);
+
+    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);
+        }
+
+        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::string presion = "fp32";
+    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,
-                       img_files_list.size());
-    autolog.report();
-  }
-  return 0;
+    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;
 }

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
\ No newline at end of file
+} // namespace PaddleClas

deploy/cpp/tools/build.sh

@@ -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. 准备环境
+
+### 运行准备
+- Linux环境，推荐使用ubuntu docker。
+
+### 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就可以使用了
+
+### 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
+```
+
+### 1.3 下载或者编译Paddle预测库
+
+* 有2种方式获取Paddle预测库，下面进行详细介绍。
+
+#### 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`中包含当前预测库的版本信息。
+
+#### 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/`的子文件夹。
+
+### 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)官网文档，根据需求自行安装。
+
+## 2 代码编译
+
+### 2.2 编译PaddleClas C++预测demo
+
+编译命令如下，其中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`的可执行文件。
+
+## 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)
+
+## 4  使用自己模型
+
+使用自己训练的模型，可以参考[模型导出](../../docs/zh_CN/inference_deployment/export_model.md)，导出`inference model`，用于模型预测。
+
+同时注意修改`yaml`文件中具体参数。

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/paddleserving/README.MD

+../../docs/zh_CN/inference_deployment/paddle_serving_deploy.md
\ No newline at end of file

deploy/paddleserving/README.md

-# PaddleClas Pipeline WebService
-
-(English|[简体中文](./README_CN.md))
-
-PaddleClas provides two service deployment methods:
-- Based on **PaddleHub Serving**: Code path is "`./deploy/hubserving`". Please refer to the [tutorial](../../deploy/hubserving/readme_en.md)
-- Based on **PaddleServing**: Code path is "`./deploy/paddleserving`".  if you prefer retrieval_based image reocognition service, please refer to [tutorial](./recognition/README.md)，if you'd like image classification service, Please follow this tutorial.
-
-# Image Classification Service deployment based on PaddleServing  
-
-This document will introduce how to use the [PaddleServing](https://github.com/PaddlePaddle/Serving/blob/develop/README.md) to deploy the ResNet50_vd model as a pipeline online service.
-
-Some Key Features of Paddle Serving:
-- Integrate with Paddle training pipeline seamlessly, most paddle models can be deployed with one line command.
-- Industrial serving features supported, such as models management, online loading, online A/B testing etc.
-- Highly concurrent and efficient communication between clients and servers supported.
-
-The introduction and tutorial of Paddle Serving service deployment framework reference [document](https://github.com/PaddlePaddle/Serving/blob/develop/README.md).
-
-
-## Contents
-- [Environmental preparation](#environmental-preparation)
-- [Model conversion](#model-conversion)
-- [Paddle Serving pipeline deployment](#paddle-serving-pipeline-deployment)
-- [FAQ](#faq)
-
-<a name="environmental-preparation"></a>
-## Environmental preparation
-
-PaddleClas operating environment and PaddleServing operating environment are needed.
-
-1. Please prepare PaddleClas operating environment reference [link](../../docs/zh_CN/tutorials/install.md).
-   Download the corresponding paddle whl package according to the environment, it is recommended to install version 2.1.0.
-
-2. The steps of PaddleServing operating environment prepare are as follows:
-
-    Install serving which used to start the service
-    ```
-    pip3 install paddle-serving-server==0.6.1 # for CPU
-    pip3 install paddle-serving-server-gpu==0.6.1 # for GPU
-    # Other GPU environments need to confirm the environment and then choose to execute the following commands
-    pip3 install paddle-serving-server-gpu==0.6.1.post101 # GPU with CUDA10.1 + TensorRT6
-    pip3 install paddle-serving-server-gpu==0.6.1.post11 # GPU with CUDA11 + TensorRT7
-    ```
-
-3. Install the client to send requests to the service
-    In [download link](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md) find the client installation package corresponding to the python version.
-    The python3.7 version is recommended here:
-
-    ```
-    wget https://paddle-serving.bj.bcebos.com/test-dev/whl/paddle_serving_client-0.0.0-cp37-none-any.whl
-    pip3 install paddle_serving_client-0.0.0-cp37-none-any.whl
-    ```
-
-4. Install serving-app
-    ```
-    pip3 install paddle-serving-app==0.6.1
-    ```
-
-   **note:** If you want to install the latest version of PaddleServing, refer to [link](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md).
-
-
-<a name="model-conversion"></a>
-## Model conversion
-When using PaddleServing for service deployment, you need to convert the saved inference model into a serving model that is easy to deploy.
-
-Firstly, download the inference model of ResNet50_vd
-```
-# Download and unzip the ResNet50_vd model
-wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/ResNet50_vd_infer.tar  && tar xf ResNet50_vd_infer.tar
-```
-
-Then, you can use installed paddle_serving_client tool to convert inference model to mobile model.
-```
-#  ResNet50_vd model conversion
-python3 -m paddle_serving_client.convert --dirname ./ResNet50_vd_infer/ \
-                                         --model_filename inference.pdmodel  \
-                                         --params_filename inference.pdiparams \
-                                         --serving_server ./ResNet50_vd_serving/ \
-                                         --serving_client ./ResNet50_vd_client/
-```
-
-After the ResNet50_vd inference model is converted, there will be additional folders of `ResNet50_vd_serving` and `ResNet50_vd_client` in the current folder, with the following format:
-```
-|- ResNet50_vd_client/
-  |- __model__  
-  |- __params__
-  |- serving_server_conf.prototxt  
-  |- serving_server_conf.stream.prototxt
-
-|- ResNet50_vd_client
-  |- serving_client_conf.prototxt  
-  |- serving_client_conf.stream.prototxt
-```
-
-Once you have the model file for deployment, you need to change the alias name in `serving_server_conf.prototxt`: Change `alias_name` in `feed_var` to `image`, change `alias_name` in `fetch_var` to `prediction`,
-The modified serving_server_conf.prototxt file is as follows:
-```
-feed_var {
-  name: "inputs"
-  alias_name: "image"
-  is_lod_tensor: false
-  feed_type: 1
-  shape: 3
-  shape: 224
-  shape: 224
-}
-fetch_var {
-  name: "save_infer_model/scale_0.tmp_1"
-  alias_name: "prediction"
-  is_lod_tensor: true
-  fetch_type: 1
-  shape: -1
-}
-```
-
-<a name="paddle-serving-pipeline-deployment"></a>
-## Paddle Serving pipeline deployment
-
-1. Download the PaddleClas code, if you have already downloaded it, you can skip this step.
-    ```
-    git clone https://github.com/PaddlePaddle/PaddleClas
-
-    # Enter the working directory  
-    cd PaddleClas/deploy/paddleserving/
-    ```
-
-    The paddleserving directory contains the code to start the pipeline service and send prediction requests, including:
-    ```
-    __init__.py
-    config.yml                # configuration file of starting the service
-    pipeline_http_client.py   # script to send pipeline prediction request by http
-    pipeline_rpc_client.py    # script to send pipeline prediction request by rpc
-    classification_web_service.py   # start the script of the pipeline server
-    ```
-
-2. Run the following command to start the service.
-    ```
-    # Start the service and save the running log in log.txt
-    python3 classification_web_service.py &>log.txt &
-    ```
-    After the service is successfully started, a log similar to the following will be printed in log.txt
-    ![](./imgs/start_server.png)
-
-3. Send service request
-    ```
-    python3 pipeline_http_client.py
-    ```
-    After successfully running, the predicted result of the model will be printed in the cmd window. An example of the result is:
-    ![](./imgs/results.png)
-
-    Adjust the number of concurrency in config.yml to get the largest QPS. 
-
-    ```
-    op:
-        concurrency: 8
-        ...
-    ```
-
-    Multiple service requests can be sent at the same time if necessary.
-
-    The predicted performance data will be automatically written into the `PipelineServingLogs/pipeline.tracer` file.
-
-<a name="faq"></a>
-## FAQ
-**Q1**: No result return after sending the request.
-
-**A1**: Do not set the proxy when starting the service and sending the request. You can close the proxy before starting the service and before sending the request. The command to close the proxy is:
-```
-unset https_proxy
-unset http_proxy
-```  

deploy/paddleserving/README_CN.md

-# PaddleClas 服务化部署
-
-([English](./README.md)|简体中文)
-
-PaddleClas提供2种服务部署方式：
-- 基于PaddleHub Serving的部署：代码路径为"`./deploy/hubserving`"，使用方法参考[文档](../../deploy/hubserving/readme.md)；
-- 基于PaddleServing的部署：代码路径为"`./deploy/paddleserving`"， 基于检索方式的图像识别服务参考[文档](./recognition/README_CN.md)， 图像分类服务按照本教程使用。
-
-# 基于PaddleServing的图像分类服务部署
-
-本文档以经典的ResNet50_vd模型为例，介绍如何使用[PaddleServing](https://github.com/PaddlePaddle/Serving/blob/develop/README_CN.md)工具部署PaddleClas
-动态图模型的pipeline在线服务。
-
-相比较于hubserving部署，PaddleServing具备以下优点：
-- 支持客户端和服务端之间高并发和高效通信
-- 支持 工业级的服务能力 例如模型管理，在线加载，在线A/B测试等
-- 支持 多种编程语言 开发客户端，例如C++, Python和Java
-
-更多有关PaddleServing服务化部署框架介绍和使用教程参考[文档](https://github.com/PaddlePaddle/Serving/blob/develop/README_CN.md)。
-
-## 目录
-- [环境准备](#环境准备)
-- [模型转换](#模型转换)
-- [Paddle Serving pipeline部署](#部署)
-- [FAQ](#FAQ)
-
-<a name="环境准备"></a>
-## 环境准备
-
-需要准备PaddleClas的运行环境和PaddleServing的运行环境。
-
-- 准备PaddleClas的[运行环境](../../docs/zh_CN/tutorials/install.md), 根据环境下载对应的paddle whl包，推荐安装2.1.0版本
-
-- 准备PaddleServing的运行环境，步骤如下
-
-1. 安装serving，用于启动服务
-    ```
-    pip3 install paddle-serving-server==0.6.1 # for CPU
-    pip3 install paddle-serving-server-gpu==0.6.1 # for GPU
-    # 其他GPU环境需要确认环境再选择执行如下命令
-    pip3 install paddle-serving-server-gpu==0.6.1.post101 # GPU with CUDA10.1 + TensorRT6
-    pip3 install paddle-serving-server-gpu==0.6.1.post11 # GPU with CUDA11 + TensorRT7
-    ```
-
-2. 安装client，用于向服务发送请求
-    在[下载链接](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md)中找到对应python版本的client安装包，这里推荐python3.7版本：
-
-    ```
-    wget https://paddle-serving.bj.bcebos.com/test-dev/whl/paddle_serving_client-0.0.0-cp37-none-any.whl
-    pip3 install paddle_serving_client-0.0.0-cp37-none-any.whl
-    ```
-
-3. 安装serving-app
-    ```
-    pip3 install paddle-serving-app==0.6.1
-    ```
-    **Note:** 如果要安装最新版本的PaddleServing参考[链接](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md)。
-
-<a name="模型转换"></a>
-## 模型转换
-
-使用PaddleServing做服务化部署时，需要将保存的inference模型转换为serving易于部署的模型。
-
-首先，下载ResNet50_vd的inference模型
-```
-# 下载并解压ResNet50_vd模型
-wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/ResNet50_vd_infer.tar && tar xf ResNet50_vd_infer.tar
-```
-
-接下来，用安装的paddle_serving_client把下载的inference模型转换成易于server部署的模型格式。
-
-```
-# 转换ResNet50_vd模型
-python3 -m paddle_serving_client.convert --dirname ./ResNet50_vd_infer/ \
-                                         --model_filename inference.pdmodel  \
-                                         --params_filename inference.pdiparams \
-                                         --serving_server ./ResNet50_vd_serving/ \
-                                         --serving_client ./ResNet50_vd_client/
-```
-ResNet50_vd推理模型转换完成后，会在当前文件夹多出`ResNet50_vd_serving` 和`ResNet50_vd_client`的文件夹，具备如下格式：
-```
-|- ResNet50_vd_client/
-  |- __model__  
-  |- __params__
-  |- serving_server_conf.prototxt  
-  |- serving_server_conf.stream.prototxt
-
-|- ResNet50_vd_client
-  |- serving_client_conf.prototxt  
-  |- serving_client_conf.stream.prototxt
-
-```
-得到模型文件之后，需要修改serving_server_conf.prototxt中的alias名字： 将`feed_var`中的`alias_name`改为`image`, 将`fetch_var`中的`alias_name`改为`prediction`, 
-修改后的serving_server_conf.prototxt内容如下：
-```
-feed_var {
-  name: "inputs"
-  alias_name: "image"
-  is_lod_tensor: false
-  feed_type: 1
-  shape: 3
-  shape: 224
-  shape: 224
-}
-fetch_var {
-  name: "save_infer_model/scale_0.tmp_1"
-  alias_name: "prediction"
-  is_lod_tensor: true
-  fetch_type: 1
-  shape: -1
-}
-```
-
-<a name="部署"></a>
-## Paddle Serving pipeline部署
-
-1. 下载PaddleClas代码，若已下载可跳过此步骤
-    ```
-    git clone https://github.com/PaddlePaddle/PaddleClas
-
-    # 进入到工作目录
-    cd PaddleClas/deploy/paddleserving/
-    ```
-    paddleserving目录包含启动pipeline服务和发送预测请求的代码，包括：
-    ```
-    __init__.py
-    config.yml                 # 启动服务的配置文件
-    pipeline_http_client.py    # http方式发送pipeline预测请求的脚本
-    pipeline_rpc_client.py     # rpc方式发送pipeline预测请求的脚本
-    classification_web_service.py    # 启动pipeline服务端的脚本
-    ```
-
-2. 启动服务可运行如下命令：
-    ```
-    # 启动服务，运行日志保存在log.txt
-    python3 classification_web_service.py &>log.txt &
-    ```
-    成功启动服务后，log.txt中会打印类似如下日志
-    ![](./imgs/start_server.png)
-
-3. 发送服务请求：
-    ```
-    python3 pipeline_http_client.py
-    ```
-    成功运行后，模型预测的结果会打印在cmd窗口中，结果示例为：
-    ![](./imgs/results.png)
-
-    调整 config.yml 中的并发个数可以获得最大的QPS
-    ```
-    op:
-        #并发数，is_thread_op=True时，为线程并发；否则为进程并发
-        concurrency: 8
-        ...
-    ```
-    有需要的话可以同时发送多个服务请求
-
-    预测性能数据会被自动写入 `PipelineServingLogs/pipeline.tracer` 文件中。
-
-<a name="FAQ"></a>
-## FAQ
-**Q1**： 发送请求后没有结果返回或者提示输出解码报错
-
-**A1**： 启动服务和发送请求时不要设置代理，可以在启动服务前和发送请求前关闭代理，关闭代理的命令是：
-```
-unset https_proxy
-unset http_proxy
-```

deploy/paddleserving/classification_web_service.py

@@ -21,6 +21,7 @@ import logging
 import numpy as np
 import base64, cv2
 
+
 class ImagenetOp(Op):
     def init_op(self):
         self.seq = Sequential([
@@ -46,9 +47,9 @@ class ImagenetOp(Op):
             img = self.seq(im)
             imgs.append(img[np.newaxis, :].copy())
         input_imgs = np.concatenate(imgs, axis=0)
-        return {"image": input_imgs}, False, None, ""
+        return {"inputs": input_imgs}, False, None, ""
 
-    def postprocess(self, input_dicts, fetch_dict, log_id):
+    def postprocess(self, input_dicts, fetch_dict, data_id, log_id):
         score_list = fetch_dict["prediction"]
         result = {"label": [], "prob": []}
         for score in score_list:

deploy/paddleserving/pipeline_http_client.py

@@ -3,15 +3,18 @@ import json
 import base64
 import os
 
+
 def cv2_to_base64(image):
     return base64.b64encode(image).decode('utf8')
 
+
 if __name__ == "__main__":
     url = "http://127.0.0.1:18080/imagenet/prediction"
     with open(os.path.join(".", "daisy.jpg"), 'rb') as file:
         image_data1 = file.read()
     image = cv2_to_base64(image_data1)
+
     data = {"key": ["image"], "value": [image]}
-    for i in range(100):
+    for i in range(1):
         r = requests.post(url=url, data=json.dumps(data))
         print(r.json())

deploy/paddleserving/recognition/README.md

-# Product Recognition Service deployment based on PaddleServing  
-
-(English|[简体中文](./README_CN.md))
-
-This document will introduce how to use the [PaddleServing](https://github.com/PaddlePaddle/Serving/blob/develop/README.md) to deploy the product recognition model based on retrieval method as a pipeline online service.
-
-Some Key Features of Paddle Serving:
-- Integrate with Paddle training pipeline seamlessly, most paddle models can be deployed with one line command.
-- Industrial serving features supported, such as models management, online loading, online A/B testing etc.
-- Highly concurrent and efficient communication between clients and servers supported.
-
-The introduction and tutorial of Paddle Serving service deployment framework reference [document](https://github.com/PaddlePaddle/Serving/blob/develop/README.md).
-
-## Contents
-- [Environmental preparation](#environmental-preparation)
-- [Model conversion](#model-conversion)
-- [Paddle Serving pipeline deployment](#paddle-serving-pipeline-deployment)
-- [FAQ](#faq)
-
-<a name="environmental-preparation"></a>
-## Environmental preparation
-
-PaddleClas operating environment and PaddleServing operating environment are needed.
-
-1. Please prepare PaddleClas operating environment reference [link](../../docs/zh_CN/tutorials/install.md).
-   Download the corresponding paddle whl package according to the environment, it is recommended to install version 2.1.0.
-
-2. The steps of PaddleServing operating environment prepare are as follows:
-
-    Install serving which used to start the service
-    ```
-    pip3 install paddle-serving-server==0.6.1 # for CPU
-    pip3 install paddle-serving-server-gpu==0.6.1 # for GPU
-    # Other GPU environments need to confirm the environment and then choose to execute the following commands
-    pip3 install paddle-serving-server-gpu==0.6.1.post101 # GPU with CUDA10.1 + TensorRT6
-    pip3 install paddle-serving-server-gpu==0.6.1.post11 # GPU with CUDA11 + TensorRT7
-    ```
-
-3. Install the client to send requests to the service
-    In [download link](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md) find the client installation package corresponding to the python version.
-    The python3.7 version is recommended here:
-
-    ```
-    wget https://paddle-serving.bj.bcebos.com/test-dev/whl/paddle_serving_client-0.0.0-cp37-none-any.whl
-    pip3 install paddle_serving_client-0.0.0-cp37-none-any.whl
-    ```
-
-4. Install serving-app
-    ```
-    pip3 install paddle-serving-app==0.6.1
-    ```
-
-   **note:** If you want to install the latest version of PaddleServing, refer to [link](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md).
-
-
-<a name="model-conversion"></a>
-## Model conversion
-When using PaddleServing for service deployment, you need to convert the saved inference model into a serving model that is easy to deploy.
-The following assumes that the current working directory is the PaddleClas root directory
-
-Firstly, download the inference model of ResNet50_vd
-```
-cd deploy
-# Download and unzip the ResNet50_vd model
-wget -P models/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/product_ResNet50_vd_aliproduct_v1.0_infer.tar
-cd models
-tar -xf product_ResNet50_vd_aliproduct_v1.0_infer.tar
-```
-
-Then, you can use installed paddle_serving_client tool to convert inference model to mobile model.
-```
-#  Product recognition model conversion
-python3 -m paddle_serving_client.convert --dirname ./product_ResNet50_vd_aliproduct_v1.0_infer/ \
-                                         --model_filename inference.pdmodel  \
-                                         --params_filename inference.pdiparams \
-                                         --serving_server ./product_ResNet50_vd_aliproduct_v1.0_serving/ \
-                                         --serving_client ./product_ResNet50_vd_aliproduct_v1.0_client/
-```
-
-After the ResNet50_vd inference model is converted, there will be additional folders of `product_ResNet50_vd_aliproduct_v1.0_serving` and `product_ResNet50_vd_aliproduct_v1.0_client` in the current folder, with the following format:
-```
-|- product_ResNet50_vd_aliproduct_v1.0_serving/
-  |- __model__  
-  |- __params__
-  |- serving_server_conf.prototxt  
-  |- serving_server_conf.stream.prototxt
-
-|- product_ResNet50_vd_aliproduct_v1.0_client
-  |- serving_client_conf.prototxt  
-  |- serving_client_conf.stream.prototxt
-```
-
-Once you have the model file for deployment, you need to change the alias name in `serving_server_conf.prototxt`:  change `alias_name` in `fetch_var` to `features`,
-The modified serving_server_conf.prototxt file is as follows:
-```
-feed_var {
-  name: "x"
-  alias_name: "x"
-  is_lod_tensor: false
-  feed_type: 1
-  shape: 3
-  shape: 224
-  shape: 224
-}
-fetch_var {
-  name: "save_infer_model/scale_0.tmp_1"
-  alias_name: "features"
-  is_lod_tensor: true
-  fetch_type: 1
-  shape: -1
-}
-```
-
-Next，download and unpack the built index of product gallery
-```
-cd ../
-wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/data/recognition_demo_data_v1.1.tar && tar -xf recognition_demo_data_v1.1.tar
-```
-
-
-<a name="paddle-serving-pipeline-deployment"></a>
-## Paddle Serving pipeline deployment
-
-**Attention:** pipeline deployment mode does not support Windows platform
-
-1. Download the PaddleClas code, if you have already downloaded it, you can skip this step.
-    ```
-    git clone https://github.com/PaddlePaddle/PaddleClas
-
-    # Enter the working directory  
-    cd PaddleClas/deploy/paddleserving/recognition
-    ```
-
-    The paddleserving directory contains the code to start the pipeline service and send prediction requests, including:
-    ```
-    __init__.py
-    config.yml                # configuration file of starting the service
-    pipeline_http_client.py   # script to send pipeline prediction request by http
-    pipeline_rpc_client.py    # script to send pipeline prediction request by rpc
-    recognition_web_service.py   # start the script of the pipeline server
-    ```
-
-2. Run the following command to start the service.
-    ```
-    # Start the service and save the running log in log.txt
-    python3 recognition_web_service.py &>log.txt &
-    ```
-    After the service is successfully started, a log similar to the following will be printed in log.txt
-    ![](../imgs/start_server_recog.png)
-
-3. Send service request
-    ```
-    python3 pipeline_http_client.py
-    ```
-    After successfully running, the predicted result of the model will be printed in the cmd window. An example of the result is:
-    ![](../imgs/results_recog.png)  
-
-    Adjust the number of concurrency in config.yml to get the largest QPS. 
-
-    ```
-    op:
-        concurrency: 8
-        ...
-    ```
-
-    Multiple service requests can be sent at the same time if necessary.
-
-    The predicted performance data will be automatically written into the `PipelineServingLogs/pipeline.tracer` file.
-
-<a name="faq"></a>
-## FAQ
-**Q1**: No result return after sending the request.
-
-**A1**: Do not set the proxy when starting the service and sending the request. You can close the proxy before starting the service and before sending the request. The command to close the proxy is:
-```
-unset https_proxy
-unset http_proxy
-```  

deploy/paddleserving/recognition/recognition_web_service.py

@@ -23,6 +23,7 @@ import faiss
 import pickle
 import json
 
+
 class DetOp(Op):
     def init_op(self):
         self.img_preprocess = Sequential([
@@ -62,39 +63,46 @@ class DetOp(Op):
 
             im_scale_y, im_scale_x = self.generate_scale(raw_im)
             im = self.img_preprocess(raw_im)
-            
+
+            im_shape = np.array(im.shape[1:]).reshape(-1)
+            scale_factor = np.array([im_scale_y, im_scale_x]).reshape(-1)
             imgs.append({
-              "image": im[np.newaxis, :],
-              "im_shape": np.array(list(im.shape[1:])).reshape(-1)[np.newaxis,:],
-              "scale_factor": np.array([im_scale_y, im_scale_x]).astype('float32'),
+                "image": im[np.newaxis, :],
+                "im_shape": im_shape[np.newaxis, :],
+                "scale_factor": scale_factor[np.newaxis, :],
             })
         self.raw_img = raw_imgs
 
         feed_dict = {
-            "image":        np.concatenate([x["image"] for x in imgs], axis=0),
-            "im_shape":     np.concatenate([x["im_shape"] for x in imgs], axis=0),
-            "scale_factor": np.concatenate([x["scale_factor"] for x in imgs], axis=0)
+            "image": np.concatenate(
+                [x["image"] for x in imgs], axis=0),
+            "im_shape": np.concatenate(
+                [x["im_shape"] for x in imgs], axis=0),
+            "scale_factor": np.concatenate(
+                [x["scale_factor"] for x in imgs], axis=0)
         }
-        return feed_dict, False,  None,  ""
+        return feed_dict, False, None, ""
 
-    def postprocess(self, input_dicts, fetch_dict, log_id):
+    def postprocess(self, input_dicts, fetch_dict, data_id, log_id):
         boxes = self.img_postprocess(fetch_dict, visualize=False)
-        boxes.sort(key = lambda x: x["score"], reverse = True)
-        boxes = filter(lambda x: x["score"] >= self.threshold, boxes[:self.max_det_results])
+        boxes.sort(key=lambda x: x["score"], reverse=True)
+        boxes = filter(lambda x: x["score"] >= self.threshold,
+                       boxes[:self.max_det_results])
         boxes = list(boxes)
         for i in range(len(boxes)):
             boxes[i]["bbox"][2] += boxes[i]["bbox"][0] - 1
             boxes[i]["bbox"][3] += boxes[i]["bbox"][1] - 1
         result = json.dumps(boxes)
         res_dict = {"bbox_result": result, "image": self.raw_img}
-        return res_dict,  None,  ""
+        return res_dict, None, ""
+
 
 class RecOp(Op):
     def init_op(self):
         self.seq = Sequential([
-            BGR2RGB(), Resize((224, 224)), 
-            Div(255), Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225],
-                                False), Transpose((2, 0, 1))
+            BGR2RGB(), Resize((224, 224)), Div(255),
+            Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225],
+                      False), Transpose((2, 0, 1))
         ])
 
         index_dir = "../../drink_dataset_v1.0/index"
@@ -102,10 +110,10 @@ class RecOp(Op):
             index_dir, "vector.index")), "vector.index not found ..."
         assert os.path.exists(os.path.join(
             index_dir, "id_map.pkl")), "id_map.pkl not found ... "
-        
+
         self.searcher = faiss.read_index(
             os.path.join(index_dir, "vector.index"))
-                
+
         with open(os.path.join(index_dir, "id_map.pkl"), "rb") as fd:
             self.id_map = pickle.load(fd)
 
@@ -121,24 +129,25 @@ class RecOp(Op):
         origin_img = cv2.imdecode(data, cv2.IMREAD_COLOR)
         dt_boxes = input_dict["bbox_result"]
         boxes = json.loads(dt_boxes)
-        boxes.append({"category_id": 0,
-                      "score": 1.0,
-                      "bbox": [0, 0, origin_img.shape[1], origin_img.shape[0]]
-                     })
+        boxes.append({
+            "category_id": 0,
+            "score": 1.0,
+            "bbox": [0, 0, origin_img.shape[1], origin_img.shape[0]]
+        })
         self.det_boxes = boxes
 
         #construct batch images for rec
         imgs = []
         for box in boxes:
             box = [int(x) for x in box["bbox"]]
-            im = origin_img[box[1]: box[3], box[0]: box[2]].copy()
+            im = origin_img[box[1]:box[3], box[0]:box[2]].copy()
             img = self.seq(im)
             imgs.append(img[np.newaxis, :].copy())
 
         input_imgs = np.concatenate(imgs, axis=0)
-        return {"x": input_imgs},  False,  None,  ""
+        return {"x": input_imgs}, False, None, ""
 
-    def nms_to_rec_results(self, results, thresh = 0.1):
+    def nms_to_rec_results(self, results, thresh=0.1):
         filtered_results = []
         x1 = np.array([r["bbox"][0] for r in results]).astype("float32")
         y1 = np.array([r["bbox"][1] for r in results]).astype("float32")
@@ -164,7 +173,7 @@ class RecOp(Op):
             filtered_results.append(results[i])
         return filtered_results
 
-    def postprocess(self, input_dicts, fetch_dict, log_id):
+    def postprocess(self, input_dicts, fetch_dict, data_id, log_id):
         batch_features = fetch_dict["features"]
 
         if self.feature_normalize:
@@ -172,7 +181,7 @@ class RecOp(Op):
                 np.sum(np.square(batch_features), axis=1, keepdims=True))
             batch_features = np.divide(batch_features, feas_norm)
 
-        scores, docs = self.searcher.search(batch_features,  self.return_k)
+        scores, docs = self.searcher.search(batch_features, self.return_k)
 
         results = []
         for i in range(scores.shape[0]):
@@ -182,17 +191,19 @@ class RecOp(Op):
                 pred["rec_docs"] = self.id_map[docs[i][0]].split()[1]
                 pred["rec_scores"] = scores[i][0]
                 results.append(pred)
-        
+
         #do nms
         results = self.nms_to_rec_results(results, self.rec_nms_thresold)
         return {"result": str(results)}, None, ""
 
+
 class RecognitionService(WebService):
     def get_pipeline_response(self, read_op):
         det_op = DetOp(name="det", input_ops=[read_op])
         rec_op = RecOp(name="rec", input_ops=[det_op])
         return rec_op
 
+
 product_recog_service = RecognitionService(name="recognition")
 product_recog_service.prepare_pipeline_config("config.yml")
 product_recog_service.run_service()

deploy/python/predict_cls.py

@@ -47,12 +47,14 @@ class ClsPredictor(Predictor):
             import auto_log
             import os
             pid = os.getpid()
+            size = config["PreProcess"]["transform_ops"][1]["CropImage"][
+                "size"]
             self.auto_logger = auto_log.AutoLogger(
                 model_name=config["Global"].get("model_name", "cls"),
                 model_precision='fp16'
                 if config["Global"]["use_fp16"] else 'fp32',
                 batch_size=config["Global"].get("batch_size", 1),
-                data_shape=[3, 224, 224],
+                data_shape=[3, size, size],
                 save_path=config["Global"].get("save_log_path",
                                                "./auto_log.log"),
                 inference_config=self.config,