coding paser

Author: wangsiyuan06

commit-prepare.sh

@@ -0,0 +1,6 @@
+path=$(cd `dirname $0`; pwd)
+cd $path
+
+pip install pre-commit
+pip install yapf
+pre-commit install

cpp/demo/paddle_inference/ppdet_infer.cpp

@@ -0,0 +1,55 @@
+#include <glog/logging.h>
+
+#include "yaml-cpp/yaml.h"
+#include "include/deploy/config.h"
+#include "include/deploy/blob.h"
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+
+DEFINE_string(model_dir, "", "Path of inference model");
+DEFINE_string(cfg_file, "", "Path of yaml file");
+DEFINE_string(pp_type, "", "Type of Paddle toolkit");
+DEFINE_string(image, "", "Path of test image file");
+
+int main(int argc, char** argv) {
+    // Parsing command-line
+    google::ParseCommandLineFlags(&argc, &argv, true);
+    //paser yaml file
+    Deploy::ConfigPaser paser;
+    paser.Load(FLAGS_cfg_file);
+
+    // data preprocess
+    // preprocess init
+    Deploy::DetPreprocess detpreprocess;
+    detpreprocess.Init(config)
+    if (FLAGS_image_list != "") {
+        //img_list
+    }
+    else {
+        //read image
+        std::vector<cv::mat> imgs
+        cv::mat img;
+        img = cv::imread(FLAGS_cfg_image);
+        imgs.push_back(img)
+        //create inpus and shape_traces
+        std::vector<Deploy::ShapeInfo> shape_traces;
+        std::vector<std::vector<Deploy::DataBlob>> inputs;
+        //preprocess 
+        detpreprocess.Run(imgs, &inputs, &shape_traces);
+        //infer
+        std::vector<std::vector<Deploy::Datablob>> outputs;
+        Deploy::PpInferenceEngine ppi_engine;
+        Deploy::PpiConfig ppi_config;
+        ppi_engine.Init(FLAGS_model_dir, ppi_config);
+        ppi_engine.Infer(inputs, &outputs);
+
+        //postprocess
+        Deploy::DetPreprocess detpostprocess;
+        detpostprocess.Init(config)
+        std::vector<Deploy::DetResult> detresults;
+        detpostprocess.Run(detresults, shape_traces)
+    }
+}

cpp/include/config.h

@@ -3,12 +3,13 @@
 include <vector>
 include <map>
 
-class InBlob{
+namespace Deploy {
+
+class DataBlob{
   public:
     // data
-    template <typename T>
-    std::vector<T> data;
-
+    char *data;
+    
     // data name
     std::string name;
 
@@ -20,21 +21,7 @@ class InBlob{
 
 }
 
-
-class OutBlob{
-  public:
-    // output data
-    char *output_data;
-  
-    // output name
-    std::string name; 
-    
-    // output shape
-    std::vector<int> shape;
-}
-
-
-class ShapeBlob{
+class ShapeInfo{
   public:
 
     // shape trace
@@ -44,3 +31,5 @@ class ShapeBlob{
     std::vector<std::string> transform_order;
 
 }
+
+}//namespace

cpp/include/blob.h cpp/include/deploy/common/blob.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+
+#include "yaml-cpp/yaml.h"
+
+namespace Deploy {
+
+class ConfigPaser {
+  public:
+    ConfigPaser() {}
+
+    ~ConfigPaser() {}
+
+    bool Load(const std::string &cfg_file, const std::string &pp_type);
+
+    
+  private:
+    bool Det_paser(const YAML::Node &det_config);
+    bool Det_paser_transforms(const YAML::Node &preprocess_op);
+
+
+    YAML::Node config_;
+}
+
+}//namespace

cpp/include/deploy/common/config.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include "blob.h"
+
+class Transform {
+  public:
+  
+  virtual void Init(const YAML::Node& item) = 0;
+  
+  virtual void Shape_infer(ShapeBlob* shape) = 0;
+  
+  virtual bool Run(cv::Mat* im) = 0;
+};

cpp/include/deploy/common/transforms.h

@@ -1,11 +1,11 @@
 #pragma once
 
 
-class Engine_config{
+class EngineConfig{
 
 }
 
-class PPI_onfig:Engine_cofig{
+class PpiConfig:EngineConfig{
   public:
      bool use_trt;
      bool use_gpu;

cpp/include/engine_config.h cpp/include/deploy/engine_config.h

@@ -4,11 +4,11 @@
 
 #include "paddle_inference_api.h"
 
-class PPInference_Engine{
+class PpInferenceEngine{
   public:
     void Init(std::string model_dir, PPI_config &config)
 
-    void Infer(std::vector<std::map<std::string,InBlob>> &inputs, std::vector<OutBlob> *outputs)
+    void Infer(std::vector<std::vector<std::DateBlob,DateBlob>> &inputs, std::vector<std::vector<DateBlob>> *outputs)
   private:
     std::unique_ptr<paddle::PaddlePredictor> predictor;
 }

cpp/include/postprocess.h cpp/include/deploy/postprocess.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <vector>
+
+
+#include "deploy/blob.h"
+#include "transform.h"
+#include "config.h" 
+
+class BasePreprocess {
+  public:
+    BasePreprocess() {}
+    
+    ~BasePreprocess() {}
+  
+    virtual bool Init(const YAML::Node &config);
+
+    virtual bool Run(const std::vector<cv::mat> &imgs, std::vector<std::vector<Inblob>> *inputs, std::vector<ShapeInfo> *shape_traces);
+
+    bool BuildTransform(); 
+  private:
+
+    std::shared_ptr<Transform> CreateTransform(const std::string& name);
+    
+    std::vector<std::shared_ptr<Transform>> transforms_;
+}

cpp/include/ppinference_engine.h cpp/include/deploy/ppinference_engine.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "preprocess.h"
+
+
+namespace Deploy {
+
+class DetProecess:BaseProcess {
+    private:
+    
+}
+}

cpp/include/ppinference_model.h cpp/include/deploy/ppinference_model.h

@@ -0,0 +1,99 @@
+#include <string>
+
+#include "yaml-cpp/yaml.h"
+
+#include "include/deploy/config/ppdet_cfg.h"
+
+namespace Deploy {
+
+bool ConfigPaser::Load(const std::string &cfg_file, const std::string &pp_type) {
+    //Load config as a YAML::Node
+    det_config = YAML::LoadFile(cfg_file);
+    //Paser yaml file
+    if (pp_type == 'det') {
+        if(!Det_paser(det_config)) {
+            std::cerr << "Fail to paser PaddleDection yaml file" << std::endl;
+            return false
+        }
+    }
+    
+}
+
+bool ConfigPaser::Det_paser(const YAML::Node &det_config) {
+    config_["model_format"] = "Paddle";
+    //arch support value:YOLO, SSD, RetinaNet, RCNN, Face
+    if(det_config["arch"].IsDefined()) {
+        config_["model_name"] = det_config["arch"];
+    }
+    else {
+        std::cerr << "Fail to find arch in PaddleDection yaml file" << std::endl;
+        return false
+    }   
+    config_["toolkit"] = "PaddleDetection";
+    config_["toolkit_version"] = "Unknown";
+    
+    if(det_config["label_list"].IsDefined()) {
+        int i = 0;
+        for (const auto& label : det_config["label_list"]) {
+            config_["lables"][i] = label.as<std::string>();
+            i++;
+        }
+    }
+    else {
+        std::cerr << "Fail to find label_list in  PaddleDection yaml file" << std::endl;
+        return false
+    }
+    //Preprocess support Normalize, Permute, Resize, PadStride
+    if(det_config["Preprocess"].IsDefined()) {
+        YAML::Node preprocess_info = det_config["Preprocess"];
+        for (const auto& preprocess_op : preprocess_info) {
+            if(!Det_paser_transforms(preprocess_op)) {
+                std::cerr << "Fail to parser PaddleDetection transforms" << std::endl;
+                return false
+            }
+        }    
+    }
+    else {
+        std::cerr << "Fail to find Preprocess in  PaddleDection yaml file" << std::endl;
+        return false
+    }
+
+}
+
+bool Det_build_transforms(const YAML::Node &preprocess_op) {
+    if (preprocess_op["type"] == "Normalize") {
+        std::vector<float> mean = preprocess_op.as<std::vector<float>>();
+        std::vector<float> scale = preprocess_op.as<std::vector<float>>();
+        config_["transforms"]["Normalize"]["is_scale"] = preprocess_op["is_scale"].as<bool>()
+        for (int i = 0; i < mean.size(); i++) {
+            config_["transforms"]["Normalize"]["mean"].push_back(mean[i]);
+            config_["transforms"]["Normalize"]["std"].push_back(std[i]);
+            config_["transforms"]["Normalize"]["min_val"].push_back(0);
+            config_["transforms"]["Normalize"]["max_val"].push_back(255);
+        }        
+    }
+    else if (preprocess_op["type"] == "Permute") {
+        config_["transforms"]["Permute"] = True;
+        if (preprocess_op["to_bgr"]) {
+            config_["transforms"]["RGB2BRG"] = True;
+        }
+    }
+    else if (preprocess_op["type"] == "Resize") {
+        int max_size = preprocess_op["max_size"].as<int>()
+        if (max_size !=0 && (config_["model_name"] == "RCNN" || config_["model_name"] == "RetinaNet")) {
+            config_["transforms"]["ResizeByShort"]["target_size"] = preprocess_op["target_size"].as<int>();
+            config_["transforms"]["ResizeByShort"]["max_size"] = max_size;
+            config_["transforms"]["ResizeByShort"]["interp"] = preprocess_op["interp"].as<int>();
+        }
+        else {
+            config_["transforms"]["Resize"]["width"] = preprocess_op["target_size"].as<int>();
+            config_["transforms"]["Resize"]["height"] = preprocess_op["target_size"].as<int>();
+            config_["transforms"]["Resize"]["max_size"] = max_size;
+            config_["transforms"]["Resize"]["interp"] = preprocess_op["interp"].as<int>();
+        }
+    }
+}
+
+
+}//namespace
+

cpp/include/deploy/preprocess/preprocess.h

@@ -0,0 +1,5 @@
+#include "preprocess.h"
+
+namespace Deploy {   
+    
+} // namespace name