enable mobilenetv1, and fix conv, pool, relu and split op

paddle/fluid/lite/api/cxx_api_bin.cc

@@ -13,17 +13,16 @@
 // limitations under the License.
 
 #include "paddle/fluid/lite/api/cxx_api.h"
-
-#ifndef LITE_WITH_LIGHT_WEIGHT_FRAMEWORK
 #include "paddle/fluid/lite/core/mir/passes.h"
-#endif
-
 #include "paddle/fluid/lite/core/op_registry.h"
 
 namespace paddle {
 namespace lite {
 
 void Run(const char* model_dir) {
+#ifdef LITE_WITH_ARM
+  DeviceInfo::Init();
+#endif
   lite::ExecutorLite predictor;
   std::vector<Place> valid_places({Place{TARGET(kHost), PRECISION(kFloat)},
                                    Place{TARGET(kARM), PRECISION(kFloat)}});
@@ -32,9 +31,9 @@ void Run(const char* model_dir) {
                   valid_places);
 
   auto* input_tensor = predictor.GetInput(0);
-  input_tensor->Resize(DDim(std::vector<DDim::value_type>({3, 224, 224})));
+  input_tensor->Resize(DDim(std::vector<DDim::value_type>({1, 3, 224, 224})));
   auto* data = input_tensor->mutable_data<float>();
-  for (int i = 0; i < 3 * 224 * 224; i++) {
+  for (int i = 0; i < input_tensor->dims().production(); i++) {
     data[i] = i;
   }
 
@@ -65,8 +64,8 @@ USE_LITE_OP(feed);
 USE_LITE_OP(fetch);
 USE_LITE_OP(io_copy);
 
-USE_LITE_OP(con2d);
-// USE_LITE_OP(batch_norm);
+USE_LITE_OP(conv2d);
+USE_LITE_OP(batch_norm);
 USE_LITE_OP(relu);
 USE_LITE_OP(depthwise_conv2d);
 USE_LITE_OP(pool2d);
@@ -81,10 +80,10 @@ USE_LITE_KERNEL(fc, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(mul, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(scale, kARM, kFloat, kNCHW, def);
 
-USE_LITE_KERNEL(con2d, kARM, kFloat, kNCHW, def);
+USE_LITE_KERNEL(conv2d, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(batch_norm, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(relu, kARM, kFloat, kNCHW, def);
-USE_LITE_KERNEL(depthwise_con2d, kARM, kFloat, kNCHW, def);
+USE_LITE_KERNEL(depthwise_conv2d, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(pool2d, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(elementwise_add, kARM, kFloat, kNCHW, def);
 USE_LITE_KERNEL(softmax, kARM, kFloat, kNCHW, def);

paddle/fluid/lite/core/mir/passes.h

@@ -21,6 +21,7 @@ namespace mir {}  // namespace mir
 }  // namespace lite
 }  // namespace paddle
 
+#ifndef LITE_WITH_LIGHT_WEIGHT_FRAMEWORK
 USE_MIR_PASS(demo);
 USE_MIR_PASS(static_kernel_pick_pass);
 USE_MIR_PASS(variable_place_inference_pass);
@@ -28,4 +29,5 @@ USE_MIR_PASS(type_target_transform_pass);
 USE_MIR_PASS(generate_program_pass);
 USE_MIR_PASS(io_copy_kernel_pick_pass);
 USE_MIR_PASS(argument_type_display_pass);
+#endif
 USE_MIR_PASS(runtime_context_assign_pass);

paddle/fluid/lite/core/optimizer.h

@@ -46,9 +46,9 @@ class Optimizer {
     SpecifyKernelPickTactic(kernel_pick_factor);
     InitTargetTypeTransformPass();
 
-#ifndef LITE_WITH_LIGHT_WEIGHT_FRAMEWORK
     if (passes.empty()) {
       RunPasses(std::vector<std::string>{{
+#ifndef LITE_WITH_LIGHT_WEIGHT_FRAMEWORK
           "static_kernel_pick_pass",        //
           "variable_place_inference_pass",  //
           "argument_type_display_pass",     //
@@ -58,12 +58,12 @@ class Optimizer {
           "argument_type_display_pass",     //
           "io_copy_kernel_pick_pass",       //
           "variable_place_inference_pass",  //
-          "runtime_context_assign_pass",    //
+#endif
+          "runtime_context_assign_pass",  //
       }});
     } else {
       RunPasses(passes);
     }
-#endif
     exec_scope_ = program.exec_scope();
   }
 

paddle/fluid/lite/kernels/arm/conv_compute_test.cc

@@ -45,7 +45,7 @@ void conv_compute_ref(const operators::ConvParam& param) {
     bias_data = param.bias->mutable_data<float>();
   }
   bool flag_bias = bias_data != nullptr;
-  bool flag_relu = false;  // TODO(hong19860320) param.relu
+  bool flag_relu = param.fuse_relu;
 
   int num = input_dims[0];
   int chout = output_dims[1];
@@ -183,7 +183,8 @@ TEST(conv_arm, compute) {
                           auto* filter_data = filter.mutable_data<float>();
                           auto* output_data = output.mutable_data<float>();
                           for (int i = 0; i < input.dims().production(); i++) {
-                            input_data[i] = static_cast<float>(i % 128);
+                            float sign = i % 3 == 0 ? -1.0f : 1.0f;
+                            input_data[i] = sign * static_cast<float>(i % 128);
                           }
                           for (int i = 0; i < filter.dims().production(); i++) {
                             filter_data[i] =
@@ -208,7 +209,7 @@ TEST(conv_arm, compute) {
                             }
                             param.bias = &bias;
                           }
-                          // TODO(hong19860320) param.relu = flag_relu;
+                          param.fuse_relu = flag_relu;
                           param.paddings = std::vector<int>({padding, padding});
                           param.strides = std::vector<int>({stride, stride});
                           param.dilations =

paddle/fluid/lite/kernels/arm/pool_compute.cc

@@ -163,7 +163,7 @@ PrecisionType PoolCompute::precision() const { return PRECISION(kFloat); }
 }  // namespace lite
 }  // namespace paddle
 
-REGISTER_LITE_KERNEL(pool, kARM, kFloat, kNCHW,
+REGISTER_LITE_KERNEL(pool2d, kARM, kFloat, kNCHW,
                      paddle::lite::kernels::arm::PoolCompute, def)
     .BindInput("X", {LiteType::GetTensorTy(TARGET(kARM))})
     .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kARM))})

paddle/fluid/lite/kernels/arm/pool_compute_test.cc

@@ -261,8 +261,8 @@ TEST(pool_arm, compute) {
 }
 
 TEST(pool, retrive_op) {
-  auto pool =
-      KernelRegistry::Global().Create<TARGET(kARM), PRECISION(kFloat)>("pool");
+  auto pool = KernelRegistry::Global().Create<TARGET(kARM), PRECISION(kFloat)>(
+      "pool2d");
   ASSERT_FALSE(pool.empty());
   ASSERT_TRUE(pool.front());
 }
@@ -272,4 +272,4 @@ TEST(pool, retrive_op) {
 }  // namespace lite
 }  // namespace paddle
 
-USE_LITE_KERNEL(pool, kARM, kFloat, kNCHW, def);
+USE_LITE_KERNEL(pool2d, kARM, kFloat, kNCHW, def);

paddle/fluid/lite/kernels/arm/relu_compute.h

@@ -45,4 +45,6 @@ class ReluCompute : public KernelLite<TARGET(kARM), PRECISION(kFloat)> {
 
 REGISTER_LITE_KERNEL(relu, kARM, kFloat, kNCHW,
                      paddle::lite::kernels::arm::ReluCompute, def)
+    .BindInput("X", {LiteType::GetTensorTy(TARGET(kARM))})
+    .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kARM))})
     .Finalize();

paddle/fluid/lite/operators/batch_norm_op.cc

@@ -82,7 +82,7 @@ bool BatchNormOp::AttachImpl(const cpp::OpDesc &op_desc, lite::Scope *scope) {
   param_.variance =
       scope->FindVar(op_desc.Input("Variance").front())->GetMutable<Tensor>();
   param_.y = scope->FindVar(op_desc.Output("Y").front())->GetMutable<Tensor>();
-  param_.is_test = op_desc.GetAttr<bool>("is_test");
+  param_.is_test = op_desc.GetAttr<int>("is_test");
   param_.use_global_stats = op_desc.GetAttr<bool>("use_global_stats");
   if (!param_.is_test) {
     param_.mean_out =

paddle/fluid/lite/operators/batch_norm_op_test.cc

@@ -46,7 +46,7 @@ TEST(batch_norm_op_lite, test) {
   desc.SetInput("Mean", {"mean"});
   desc.SetInput("Variance", {"variance"});
   desc.SetOutput("Y", {"y"});
-  desc.SetAttr("is_test", true);
+  desc.SetAttr("is_test", static_cast<int>(1));
   desc.SetAttr("use_global_stats", false);
   desc.SetAttr("epsilon", 1e-5f);
   desc.SetAttr("momentum", 0.9f);
@@ -101,7 +101,7 @@ TEST(batch_norm_op_lite, test_enable_is_test) {
   desc.SetOutput("VarianceOut", {"variance_out"});
   desc.SetOutput("SavedMean", {"saved_mean"});
   desc.SetOutput("SavedVariance", {"saved_variance"});
-  desc.SetAttr("is_test", false);
+  desc.SetAttr("is_test", static_cast<int>(0));
   desc.SetAttr("use_global_stats", false);
   desc.SetAttr("epsilon", 1e-5f);
   desc.SetAttr("momentum", 0.9f);

paddle/fluid/lite/operators/conv_op.h

@@ -40,11 +40,11 @@ class ConvOpLite : public OpLite {
   bool AttachImpl(const cpp::OpDesc &op_desc, lite::Scope *scope) override {
     auto input = op_desc.Input("Input").front();
     auto filter = op_desc.Input("Filter").front();
-    auto out = op_desc.Output("Out").front();
+    auto output = op_desc.Output("Output").front();
     param_.x = scope->FindVar(input)->GetMutable<lite::Tensor>();
     param_.filter = scope->FindVar(filter)->GetMutable<lite::Tensor>();
-    CHECK(scope->FindVar(out));
-    param_.output = scope->FindVar(out)->GetMutable<lite::Tensor>();
+    CHECK(scope->FindVar(output));
+    param_.output = scope->FindVar(output)->GetMutable<lite::Tensor>();
     param_.strides = op_desc.GetAttr<std::vector<int>>("strides");
     param_.paddings = op_desc.GetAttr<std::vector<int>>("paddings");
     param_.groups = op_desc.GetAttr<int>("groups");
@@ -53,21 +53,27 @@ class ConvOpLite : public OpLite {
     std::vector<std::string> input_arg_names = op_desc.InputArgumentNames();
     if (std::find(input_arg_names.begin(), input_arg_names.end(), "Bias") !=
         input_arg_names.end()) {
-      auto bias_var = scope->FindVar(op_desc.Input("Bias").front());
-      if (bias_var != nullptr) {
-        param_.bias =
-            const_cast<lite::Tensor *>(&(bias_var->Get<lite::Tensor>()));
+      auto bias_arguments = op_desc.Input("Bias");
+      if (bias_arguments.size() > 0) {
+        auto bias_var = scope->FindVar(bias_arguments.front());
+        if (bias_var != nullptr) {
+          param_.bias =
+              const_cast<lite::Tensor *>(&(bias_var->Get<lite::Tensor>()));
+        }
       }
     }
     if (std::find(input_arg_names.begin(), input_arg_names.end(),
                   "ResidualData") != input_arg_names.end()) {
-      auto residual_data_var =
-          scope->FindVar(op_desc.Input("ResidualData").front());
-      if (residual_data_var != nullptr) {
-        param_.residualData = const_cast<lite::Tensor *>(
-            &(residual_data_var->Get<lite::Tensor>()));
+      auto res_data_arguments = op_desc.Input("ResidualData");
+      if (res_data_arguments.size() > 0) {
+        auto residual_data_var = scope->FindVar(res_data_arguments.front());
+        if (residual_data_var != nullptr) {
+          param_.residualData = const_cast<lite::Tensor *>(
+              &(residual_data_var->Get<lite::Tensor>()));
+        }
       }
     }
+    param_.fuse_relu = op_desc.GetAttr<bool>("fuse_relu");
     return true;
   }
 

paddle/fluid/lite/operators/pool_op.h

@@ -53,17 +53,25 @@ class PoolOpLite : public OpLite {
     param_.strides = op_desc.GetAttr<std::vector<int>>("strides");
     param_.paddings = op_desc.GetAttr<std::vector<int>>("paddings");
 
-    param_.exclusive = op_desc.GetAttr<bool>("exclusive");
-    param_.adaptive = op_desc.GetAttr<bool>("adaptive");
-    param_.ceil_mode = op_desc.GetAttr<bool>("ceil_mode");
-    param_.use_quantizer = op_desc.GetAttr<bool>("use_quantizer");
+    if (op_desc.HasAttr("exclusive")) {
+      param_.exclusive = op_desc.GetAttr<bool>("exclusive");
+    }
+    if (op_desc.HasAttr("adaptive")) {
+      param_.adaptive = op_desc.GetAttr<bool>("adaptive");
+    }
+    if (op_desc.HasAttr("ceil_mode")) {
+      param_.ceil_mode = op_desc.GetAttr<bool>("ceil_mode");
+    }
+    if (op_desc.HasAttr("use_quantizer")) {
+      param_.use_quantizer = op_desc.GetAttr<bool>("use_quantizer");
+    }
     // param_.data_format = op_desc.GetAttr<bool>("data_format");
     return true;
   }
 
   void AttachKernel(KernelBase *kernel) override { kernel->SetParam(param_); }
 
-  std::string DebugString() const override { return "pool"; }
+  std::string DebugString() const override { return "pool2d"; }
 
  private:
   mutable PoolParam param_;

paddle/fluid/lite/operators/pool_op_test.cc

@@ -38,7 +38,7 @@ TEST(pool_op_lite, test) {
 
   // prepare op desc
   cpp::OpDesc desc;
-  desc.SetType("pool");
+  desc.SetType("pool2d");
   desc.SetInput("X", {"x"});
   desc.SetOutput("Out", {"output"});
 
@@ -69,7 +69,7 @@ TEST(pool_op_lite, test) {
   bool use_quantizer{false};
   desc.SetAttr("use_quantizer", use_quantizer);
 
-  PoolOpLite pool("pool");
+  PoolOpLite pool("pool2d");
   pool.SetValidPlaces({Place{TARGET(kARM), PRECISION(kFloat)}});
   pool.Attach(desc, &scope);
   auto kernels = pool.CreateKernels({Place{TARGET(kARM), PRECISION(kFloat)}});
@@ -86,5 +86,5 @@ TEST(pool_op_lite, test) {
 }  // namespace paddle
 
 #ifdef LITE_WITH_ARM
-USE_LITE_KERNEL(pool, kARM, kFloat, kNCHW, def);
+USE_LITE_KERNEL(pool2d, kARM, kFloat, kNCHW, def);
 #endif

paddle/fluid/lite/operators/relu_op.cc

@@ -32,12 +32,11 @@ bool ReluOp::InferShape() const {
 
 bool ReluOp::AttachImpl(const cpp::OpDesc &opdesc, lite::Scope *scope) {
   param_.input = const_cast<lite::Tensor *>(
-      &scope->FindVar(opdesc.Input("Input").front())->Get<lite::Tensor>());
+      &scope->FindVar(opdesc.Input("X").front())->Get<lite::Tensor>());
   param_.output =
       scope->FindVar(opdesc.Output("Out").front())->GetMutable<lite::Tensor>();
   CHECK(param_.input);
   CHECK(param_.output);
-  kernel_->SetParam(param_);
   return true;
 }
 

paddle/fluid/lite/operators/split_op.cc

@@ -37,7 +37,7 @@ bool SplitOp::InferShape() const {
   const auto &sections = param_.sections;
 
   const int outs_number = outs.size();
-  std::vector<lite::DDimHvy> outs_dims;
+  std::vector<lite::DDim> outs_dims;
   outs_dims.reserve(outs_number);
 
   if (num > 0) {