fix some mlu kernel test

lite/kernels/mlu/bridges/batch_norm_op_test.cc

@@ -137,9 +137,7 @@ void test_batch_norm(
             {bs, ic, ih, iw},
             {0, 2, 3, 1});
 
-  out->Resize({bs, ih, iw, ic});
   x->CopyDataFrom(input_trans);
-  x->Resize({bs, ih, iw, ic});
 
   LaunchOp(op, {x_var_name}, {out_var_name});
 

lite/kernels/mlu/bridges/concat_op_test.cc

@@ -113,21 +113,8 @@ void test_concat(std::vector<std::vector<int64_t>> input, int axis) {
              static_cast<int>(input[1][2]),
              static_cast<int>(input[1][3])},
             {0, 2, 3, 1});
-  auto os = out->dims();
-  out->Resize({static_cast<int>(os[0]),
-               static_cast<int>(os[2]),
-               static_cast<int>(os[3]),
-               static_cast<int>(os[1])});
   x->CopyDataFrom(input_x);
   y->CopyDataFrom(input_y);
-  x->Resize({static_cast<int>(input[0][0]),
-             static_cast<int>(input[0][2]),
-             static_cast<int>(input[0][3]),
-             static_cast<int>(input[0][1])});
-  y->Resize({static_cast<int>(input[1][0]),
-             static_cast<int>(input[1][2]),
-             static_cast<int>(input[1][3]),
-             static_cast<int>(input[1][1])});
 
   LaunchOp(op, {x_var_name, y_var_name}, {out_var_name});
 
@@ -136,6 +123,7 @@ void test_concat(std::vector<std::vector<int64_t>> input, int axis) {
 
   Tensor output_trans;
   output_trans.Resize(out->dims());
+  auto os = out->dims();
   transpose(out_data,
             output_trans.mutable_data<float>(),
             {static_cast<int>(os[0]),

lite/kernels/mlu/bridges/conv_op_test.cc

@@ -244,10 +244,6 @@ void test_conv(int bs,
     }
   }
 
-  input->Resize({bs, ih, iw, ic});
-  output->Resize(
-      {output_shape[0], output_shape[2], output_shape[3], output_shape[1]});
-
   // create and convert op to MLU model, then run it on MLU
   auto op = CreateOp<operators::ConvOpLite>(opdesc_mlu, &scope);
   LaunchOp(op, {input_var_name}, {output_var_name});

lite/kernels/mlu/bridges/fc_op_test.cc

@@ -139,15 +139,34 @@ void test_fc(const std::vector<int64_t>& input_shape,
   }
 
   auto fc_op_mlu = CreateOp<operators::FcOpLite>(fc_op_desc_mlu, &scope);
-  input->Resize({static_cast<int>(input_shape[0]),
+
+  Tensor input_tmp, out_tmp;
+  input_tmp.Resize(input_shape);
+  transpose(input->mutable_data<float>(),
+            input_tmp.mutable_data<float>(),
+            {static_cast<int>(input_shape[0]),
+             static_cast<int>(input_shape[1]),
              static_cast<int>(input_shape[2]),
-                 static_cast<int>(input_shape[3]),
-                 static_cast<int>(input_shape[1])});
-  out->Resize({static_cast<int>(input_shape[0]), static_cast<int>(w_shape[1])});
+             static_cast<int>(input_shape[3])},
+            {0, 2, 3, 1});
+  input->CopyDataFrom(input_tmp);
+
   LaunchOp(fc_op_mlu, {input_var_name}, {out_var_name});
 
-  // compare results
+  auto os = out->dims();
+  out_tmp.Resize(os);
   auto* out_data = out->mutable_data<float>();
+  //  transpose(out_data,
+  //            out_tmp.mutable_data<float>(),
+  //            {static_cast<int>(os[0]),
+  //             static_cast<int>(os[2]),
+  //             static_cast<int>(os[3]),
+  //             static_cast<int>(os[1])},
+  //            {0, 3, 1, 2});
+  //
+  //  out_data = out_tmp.mutable_data<float>();
+
+  // compare results
   auto* out_ref_data = out_ref->mutable_data<float>();
   for (int i = 0; i < out->dims().production(); i++) {
     EXPECT_NEAR(out_data[i], out_ref_data[i], 1e-5);

lite/kernels/mlu/bridges/interpolate_op_test.cc

@@ -237,7 +237,6 @@ class InterpComputeTester {
     /* printf("----output tensor dims: %ld, %d, %d, %ld\n", dims_[0], out_h,
      * out_w, dims_[1]); */
     std::vector<int64_t> out_shape_nchw = {dims_[0], dims_[1], out_h, out_w};
-    out->Resize(DimNCHW2NHWC(out_shape_nchw));
     outref->Resize(out_shape_nchw);
     outsize->Resize({2});
 
@@ -283,7 +282,6 @@ class InterpComputeTester {
               {in, ic, ih, iw},
               {0, 2, 3, 1});
     x->CopyDataFrom(input_trans);
-    x->Resize(DimNCHW2NHWC(dims_.Vectorize()));
     if (use_outsize_) {
       LaunchOp(op, {x_var_name, outsize_var_name}, {out_var_name});
     } else {

lite/kernels/mlu/bridges/pool_op_test.cc

@@ -180,12 +180,7 @@ void test_pool(int bs,
             {0, 2, 3, 1});
 
   auto os = out->dims();
-  out->Resize({static_cast<int>(os[0]),
-               static_cast<int>(os[2]),
-               static_cast<int>(os[3]),
-               static_cast<int>(os[1])});
   x->CopyDataFrom(input_trans);
-  x->Resize({bs, ih, iw, ic});
 
   LaunchOp(op, {x_var_name}, {out_var_name});
 

lite/kernels/mlu/bridges/softmax_op_test.cc

@@ -110,9 +110,7 @@ void test_softmax(const std::vector<int64_t>& input_shape, int axis) {
             {bs, ic, ih, iw},
             {0, 2, 3, 1});
 
-  out->Resize({bs, ih, iw, ic});
   x->CopyDataFrom(input_trans);
-  x->Resize({bs, ih, iw, ic});
 
   LaunchOp(op, {x_var_name}, {out_var_name});
 

lite/kernels/mlu/bridges/test_helper.cc

@@ -58,7 +58,7 @@ void LaunchOp(const std::shared_ptr<lite::OpLite> op,
         graph.AddNode(input_name,
                       input_tensor->dims().Vectorize(),
                       CNML_TENSOR,
-                      CNML_NHWC,
+                      CNML_NCHW,
                       graph.FPType(),
                       reinterpret_cast<void*>(
                           input_tensor->mutable_data<float>(TARGET(kMLU))));
@@ -68,6 +68,8 @@ void LaunchOp(const std::shared_ptr<lite::OpLite> op,
                           sizeof(float) * input_tensor->dims().production(),
                           CNRT_MEM_TRANS_DIR_HOST2DEV));
   }
+  op->CheckShape();
+  op->InferShape();
   bridges.Select(op_type, TARGET(kMLU))(
       reinterpret_cast<void*>(&graph), const_cast<OpLite*>(op.get()), nullptr);
 

lite/kernels/mlu/bridges/transpose_op.cc

@@ -21,28 +21,6 @@ namespace lite {
 namespace subgraph {
 namespace mlu {
 
-// std::vector<int> axis_to_nhwc4d(const std::vector<int>& axis) {
-//  CHECK_EQ(axis.size(), 4);
-//  std::vector<int> new_axis(4, 0);
-//  const std::vector<int> axis_map1 = {0, 2, 3, 1};
-//  const std::vector<int> axis_map2 = {0, 3, 1, 2};
-//  for (size_t i = 0; i < new_axis.size(); ++i) {
-//    new_axis[i] = axis_map2[axis[axis_map1[i]]];
-//  }
-//  return new_axis;
-//}
-//
-// std::vector<int> axis_to_nhw3d(const std::vector<int>& axis) {
-//  CHECK_EQ(axis.size(), 3);
-//  std::vector<int> new_axis(3, 0);
-//  const std::vector<int> axis_map = {0, 2, 1};
-//  for (size_t i = 0; i < new_axis.size(); ++i) {
-//    new_axis[i] = axis_map[axis[axis_map[i]]];
-//  }
-//  new_axis.push_back(3);
-//  return new_axis;
-//}
-
 std::vector<int> axis_to_nhwc(const std::vector<int>& axis) {
   CHECK_EQ(axis.size(), 4) << "Unsupport dim in mlu transpose";
   std::vector<int> new_axis(4, 0);

lite/kernels/mlu/bridges/transpose_op_test.cc

@@ -115,6 +115,7 @@ void test_transpose(const std::vector<int64_t>& input_shape,
   }
 }
 
+// TODO(pmshst): fix the transpose test
 TEST(MLUBridges, transpose) {
   std::vector<int64_t> input_shape = {2, 3, 4, 5};
   test_transpose(input_shape, std::vector<int>{0, 1, 3, 2});