Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle-Lite into jiansowa/img_nna

Just before commit.

lite/api/CMakeLists.txt

@@ -15,7 +15,6 @@ if ((NOT LITE_ON_TINY_PUBLISH) AND (LITE_WITH_CUDA OR LITE_WITH_X86 OR LITE_WITH
     #full api dynamic library
     lite_cc_library(paddle_full_api_shared SHARED SRCS paddle_api.cc light_api.cc cxx_api.cc cxx_api_impl.cc light_api_impl.cc
                   DEPS paddle_api paddle_api_light  paddle_api_full)
-    target_sources(paddle_full_api_shared PUBLIC ${__lite_cc_files})
     add_dependencies(paddle_full_api_shared op_list_h kernel_list_h framework_proto op_registry fbs_headers)
     target_link_libraries(paddle_full_api_shared framework_proto op_registry)
     if(LITE_WITH_X86)

lite/api/benchmark.cc

@@ -30,8 +30,6 @@
 #include <string>
 #include <vector>
 #include "lite/api/paddle_api.h"
-#include "lite/api/paddle_use_kernels.h"
-#include "lite/api/paddle_use_ops.h"
 #include "lite/core/device_info.h"
 #include "lite/utils/cp_logging.h"
 #include "lite/utils/string.h"

lite/api/light_api_impl.cc

@@ -17,6 +17,10 @@
 #include "lite/api/paddle_api.h"
 #include "lite/core/version.h"
 #include "lite/model_parser/model_parser.h"
+#ifndef LITE_ON_TINY_PUBLISH
+#include "lite/api/paddle_use_kernels.h"
+#include "lite/api/paddle_use_ops.h"
+#endif
 
 namespace paddle {
 namespace lite {

lite/api/model_test.cc

@@ -25,8 +25,6 @@
 #include "lite/core/profile/basic_profiler.h"
 #endif  // LITE_WITH_PROFILE
 #include <gflags/gflags.h>
-#include "lite/api/paddle_use_kernels.h"
-#include "lite/api/paddle_use_ops.h"
 
 using paddle::lite::profile::Timer;
 

lite/api/paddle_api_test.cc

@@ -15,8 +15,6 @@
 #include "lite/api/paddle_api.h"
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
-#include "lite/api/paddle_use_kernels.h"
-#include "lite/api/paddle_use_ops.h"
 #include "lite/utils/cp_logging.h"
 #include "lite/utils/io.h"
 

lite/core/mir/subgraph/subgraph_pass_test.cc

@@ -17,8 +17,6 @@
 #include <cmath>
 
 #include "lite/api/paddle_api.h"
-#include "lite/api/paddle_use_kernels.h"
-#include "lite/api/paddle_use_ops.h"
 #include "lite/api/test_helper.h"
 #include "lite/utils/cp_logging.h"
 #include "lite/utils/string.h"

lite/kernels/bm/bridges/box_coder_op.cc

@@ -73,10 +73,16 @@ int BoxCoderConverter(void* ctx, OpLite* op, KernelBase* kernel) {
   if (op_info->HasAttr("variance")) {
     variance = op_info->GetAttr<std::vector<float>>("variance");
   }
+  int variance_len = variance.size();
   user_cpu_param_t bm_param;
   bm_param.op_type = USER_PADDLE_BOX_CODER;
   bm_param.u.box_coder_param.axis = axis;
-  bm_param.u.box_coder_param.variance = &variance[0];
+  CHECK_LE(variance_len, 2000);
+  memset(bm_param.u.box_coder_param.variance, 0, 2000 * sizeof(float));
+  memcpy(bm_param.u.box_coder_param.variance,
+         &variance[0],
+         variance_len * sizeof(float));
+  bm_param.u.box_coder_param.variance_len = variance_len;
   bm_param.u.box_coder_param.code_type =
       (code_type == "encode_center_size") ? 0 : 1;
   bm_param.u.box_coder_param.normalized = box_normalized;

lite/kernels/bm/bridges/cast_op.cc

@@ -32,7 +32,8 @@ bool CvtDtype(int dtype, int* ptype) {
       *ptype = DTYPE_INT16;
       break;
     case 2:
-      *ptype = DTYPE_FP32;
+    case 3:
+      *ptype = DTYPE_INT32;
       break;
     case 5:
       *ptype = DTYPE_FP32;

lite/kernels/bm/bridges/elementwise_ops.cc

@@ -127,7 +127,7 @@ int ElementwiseConverter(void* ctx, OpLite* op, KernelBase* kernel) {
   const float* y_data = const_cast<const float*>(y->mutable_data<float>());
   const float* x_data = const_cast<const float*>(x->mutable_data<float>());
   auto unique_op_name = lite::subgraph::bm::UniqueName("expand_ndims");
-  std::vector<int32_t> i_expand_shape_data(3);
+  std::vector<int32_t> i_expand_shape_data;
   if (x_is_const && y_is_const) {
     float* cpu_data = compute_elementwise_both_const(op);
     bm_add_const_tensor(graph->GetCompilerHandle(),
@@ -157,12 +157,31 @@ int ElementwiseConverter(void* ctx, OpLite* op, KernelBase* kernel) {
             static_cast<const char*>(unique_op_name.c_str()));
         name[1] = static_cast<const char*>(unique_op_name.c_str());
         dim[1] = 3;
-        i_expand_shape_data[0] = i_y_shape_data[0];
-        i_expand_shape_data[1] = 1;
-        i_expand_shape_data[2] = 1;
+        i_expand_shape_data.push_back(i_y_shape_data[0]);
+        i_expand_shape_data.push_back(1);
+        i_expand_shape_data.push_back(1);
         shape[1] = &i_expand_shape_data[0];
         y_data = nullptr;
       }
+    } else {
+      if (dim[1] < dim[0]) {
+        for (size_t i = 0; i < dim[1]; i++) {
+          i_expand_shape_data.push_back(i_y_shape_data[i]);
+        }
+        for (size_t i = dim[1]; i < dim[0]; i++) {
+          i_expand_shape_data.push_back(1);
+        }
+        add_reshape_layer_v2(graph->GetCompilerHandle(),
+                             name[1],
+                             shape[1],
+                             dim[1],
+                             static_cast<const char*>(unique_op_name.c_str()),
+                             const_cast<const int*>(&i_expand_shape_data[0]),
+                             i_expand_shape_data.size());
+        dim[1] = dim[0];
+        shape[1] = &i_expand_shape_data[0];
+        name[1] = static_cast<const char*>(unique_op_name.c_str());
+      }
     }
     add_binary_layer_v2(graph->GetCompilerHandle(),
                         name[0],

lite/kernels/bm/bridges/multiclass_nms_op.cc

@@ -51,7 +51,7 @@ int MultiClassNMSConverter(void* ctx, OpLite* op, KernelBase* kernel) {
   auto score_threshold = op_info->GetAttr<float>("score_threshold");
   auto nms_threshold = op_info->GetAttr<float>("nms_threshold");
   auto nms_eta = op_info->GetAttr<float>("nms_eta");
-  bool normalized;
+  bool normalized = false;
   if (op_info->HasAttr("normalized")) {
     normalized = op_info->GetAttr<bool>("normalized");
   }
@@ -97,12 +97,39 @@ int MultiClassNMSConverter(void* ctx, OpLite* op, KernelBase* kernel) {
   in_dim[1] = score_dims.size();
   in_name[0] = static_cast<const char*>(boxes_var_name.c_str());
   in_name[1] = static_cast<const char*>(score_var_name.c_str());
-  int32_t* out_shape[1];
-  int32_t out_dim[1];
-  const char* out_name[1];
+  int32_t* out_shape[2];
+  int32_t out_dim[2];
+  const char* out_name[2];
   out_shape[0] = &i_out_shape_data[0];
   out_dim[0] = out_dims.size();
   out_name[0] = static_cast<const char*>(out_var_name.c_str());
+
+  std::vector<int64_t> vec_index_dim(score_dims.size());
+  std::vector<int32_t> i_out_index_shape_data(score_dims.size());
+  std::string out_index_name = "";
+  if (op_type == "multiclass_nms2") {
+    output_num = 2;
+    out_index_name = op_info->Output("Index").front();
+    auto out_index = scope->FindVar(out_index_name)->GetMutable<lite::Tensor>();
+    if (3 == score_dims.size()) {
+      vec_index_dim[0] = score_dims[0];
+      vec_index_dim[1] = keep_top_k;
+      vec_index_dim[2] = 1;
+    } else {
+      vec_index_dim[0] = keep_top_k;
+      vec_index_dim[1] = 1;
+    }
+    DDimLite index_dims(vec_index_dim);
+    out_index->Resize(index_dims);
+    out_index->mutable_data<float>();
+    for (size_t i = 0; i < index_dims.size(); i++) {
+      i_out_index_shape_data[i] = static_cast<int32_t>(index_dims[i]);
+    }
+    out_shape[1] = &i_out_index_shape_data[0];
+    out_dim[1] = index_dims.size();
+    out_name[1] = static_cast<const char*>(out_index_name.c_str());
+  }
+
   add_user_cpu_layer(graph->GetCompilerHandle(),
                      input_num,
                      in_shape,
@@ -126,3 +153,6 @@ int MultiClassNMSConverter(void* ctx, OpLite* op, KernelBase* kernel) {
 REGISTER_SUBGRAPH_BRIDGE(multiclass_nms,
                          kBM,
                          paddle::lite::subgraph::bm::MultiClassNMSConverter);
+REGISTER_SUBGRAPH_BRIDGE(multiclass_nms2,
+                         kBM,
+                         paddle::lite::subgraph::bm::MultiClassNMSConverter);

lite/kernels/bm/bridges/paddle_use_bridges.h

@@ -39,6 +39,7 @@ USE_SUBGRAPH_BRIDGE(norm, kBM);
 USE_SUBGRAPH_BRIDGE(prior_box, kBM);
 USE_SUBGRAPH_BRIDGE(box_coder, kBM);
 USE_SUBGRAPH_BRIDGE(multiclass_nms, kBM);
+USE_SUBGRAPH_BRIDGE(multiclass_nms2, kBM);
 USE_SUBGRAPH_BRIDGE(nearest_interp, kBM);
 USE_SUBGRAPH_BRIDGE(bilinear_interp, kBM);
 USE_SUBGRAPH_BRIDGE(yolo_box, kBM);

lite/kernels/bm/bridges/yolo_box_op.cc

@@ -67,17 +67,17 @@ int YoloBoxConverter(void* ctx, OpLite* op, KernelBase* kernel) {
   auto downsample_ratio = op_info->GetAttr<int>("downsample_ratio");
   auto conf_thresh = op_info->GetAttr<float>("conf_thresh");
   auto anchors = op_info->GetAttr<std::vector<int>>("anchors");
-  int* anchors_buffer = static_cast<int*>(malloc(sizeof(int) * anchors.size()));
-  CHECK(anchors_buffer != nullptr);
-  memcpy(anchors_buffer, &anchors[0], sizeof(int) * anchors.size());
+  CHECK_LE(anchors.size(), 2000);
   user_cpu_param_t bm_param;
   bm_param.op_type = USER_PADDLE_YOLO_BOX;
   bm_param.u.yolo_box_param.class_num = class_num;
   bm_param.u.yolo_box_param.downsample_ratio = downsample_ratio;
   bm_param.u.yolo_box_param.conf_thresh = conf_thresh;
-  bm_param.u.yolo_box_param.anchors = anchors_buffer;
+  memset(bm_param.u.yolo_box_param.anchors, 0, 2000 * sizeof(int));
+  memcpy(bm_param.u.yolo_box_param.anchors,
+         &anchors[0],
+         anchors.size() * sizeof(int));
   bm_param.u.yolo_box_param.anchors_size = anchors.size();
-  memcpy(anchors_buffer, &anchors[0], sizeof(int) * anchors.size());
   int32_t input_num = 2;
   int32_t output_num = 2;
   int32_t* in_shape[2];

lite/model_parser/flatbuffers/program_desc.h

@@ -79,6 +79,13 @@ class ProgramDescView : public ProgramDescAPI {
     return desc_->version()->version();
   }
 
+  void ClearBlocks() override {
+    CHECK_EQ(BlocksSize(), 0u) << "For backward compatibility, in the "
+                                  "read-only flatbuffers version, this "
+                                  "interface degenerates to force the number "
+                                  "of blocks to be zero.";
+  }
+
   proto::ProgramDesc const* raw_desc() const { return desc_; }
 
   const std::vector<char>& buf() const { return buf_; }

lite/model_parser/model_parser.cc

@@ -1000,14 +1000,17 @@ void LoadModelNaiveFromMemory(const std::string &model_buffer,
 #ifndef LITE_ON_TINY_PUBLISH
       LoadModelNaiveV0FromMemory(model_buffer, scope, cpp_prog);
 #else
-      LOG(FATAL) << "Error: Unsupported model type.";
+      LOG(FATAL) << "Paddle-Lite v2.7 has upgraded the naive-buffer model "
+                    "format. Please use the OPT to generate a new model. "
+                    "Thanks!";
 #endif
       break;
     case 1:
       LoadModelNaiveV1FromMemory(model_buffer, scope, cpp_prog);
       break;
     default:
-      LOG(FATAL) << "Error: Unsupported model type.";
+      LOG(FATAL) << "The model format cannot be recognized. Please make sure "
+                    "you use the correct interface and model file.";
       break;
   }
 }