Merge pull request #16807 from Shixiaowei02/engine2-interface

update fc convert

Author: Shixiaowei02

paddle/fluid/inference/anakin/convert/fc.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "paddle/fluid/inference/anakin/convert/fc.h"
+#include "paddle/fluid/inference/anakin/convert/helper.h"
 #include <algorithm>
 #include <string>
 #include <vector>
@@ -45,72 +46,39 @@ void FcBaseOpConverter<TargetT>::operator()(
   // get weights
   auto *y_v = scope.FindVar(op_desc.Input(w_name).front());
   PADDLE_ENFORCE_NOT_NULL(y_v);
-  auto *y_t = y_v->GetMutable<framework::LoDTensor>();
+  auto weight_tensor = tensor_from_var(*y_v, platform::CPUPlace());
+  auto weight_shape = framework::vectorize2int(weight_tensor->dims());
+
+  int out_dim = weight_shape[1];
+  const int w_m = weight_shape[0];
+  const int w_k = weight_shape[1];
 
   auto input_name = op_desc.Input(i_name).front();
   auto output_name = op_desc.Output("Out").front();
 
   this->engine_->AddOp(op_name, "Dense", {input_name}, {output_name});
   this->engine_->AddOpAttr(op_name, "bias_term", with_bias);
   this->engine_->AddOpAttr(op_name, "axis", 1);
-
-  auto weight_shape = framework::vectorize2int(y_t->dims());
-  int out_dim = weight_shape[1];
   this->engine_->AddOpAttr(op_name, "out_dim", out_dim);
-  const int w_m = weight_shape[0];
-  const int w_k = weight_shape[1];
 
-  if (weight_shape.size() < 4UL) {
-    weight_shape.insert(weight_shape.begin(), 4UL - weight_shape.size(), 1);
-  }
-  Shape anakin_shape(weight_shape);
+  auto *weight_data = weight_tensor->data<float>();
+  PADDLE_ENFORCE(w_m * w_k == weight_tensor->numel());
 
-  framework::LoDTensor weight_tensor;
-  weight_tensor.Resize(y_t->dims());
-  TensorCopySync((*y_t), platform::CPUPlace(), &weight_tensor);
-  auto *weight_data = weight_tensor.data<float>();
-  PADDLE_ENFORCE(w_m * w_k == weight_tensor.numel());
-
-  std::vector<float> trans_weight_data(weight_tensor.numel());
+  std::vector<float> trans_weight_data(weight_tensor->numel());
   for (int i = 0; i < w_m; i++) {
     for (int j = 0; j < w_k; j++) {
       trans_weight_data[i + j * w_m] = weight_data[i * w_k + j];
     }
   }
-  auto *weight1 =
-      GraphGlobalMem<TargetT>::Global().template new_block<AK_FLOAT>(
-          anakin_shape);
-  float *cpu_data = static_cast<float *>(weight1->h_tensor().mutable_data());
-  std::copy_n(trans_weight_data.data(), weight_tensor.numel(), cpu_data);
-  weight1->d_tensor().set_shape(anakin_shape);
-  weight1->d_tensor().copy_from(weight1->h_tensor());
+
+  auto *weight1 = pblock_from_vector<TargetT>(trans_weight_data);
   this->engine_->AddOpAttr(op_name, "weight_1", *weight1);
 
   // get bias
   if (with_bias) {
     auto *b_v = scope.FindVar(op_desc.Input("Bias").front());
     PADDLE_ENFORCE_NOT_NULL(b_v);
-    auto *b_t = b_v->GetMutable<framework::LoDTensor>();
-
-    auto bias_shape = framework::vectorize2int(b_t->dims());
-    framework::LoDTensor bias_tensor;
-    bias_tensor.Resize(b_t->dims());
-    TensorCopySync((*b_t), platform::CPUPlace(), &bias_tensor);
-    auto *bias_data = bias_tensor.data<float>();
-    bias_shape.insert(bias_shape.begin(), 1);
-    bias_shape.insert(bias_shape.begin(), 1);
-    bias_shape.insert(bias_shape.begin(), 1);
-    // bias_shape.push_back(1);
-    // bias_shape.push_back(1);
-    Shape anakin_bias_shape(bias_shape);
-
-    auto *weight2 =
-        GraphGlobalMem<TargetT>::Global().template new_block<AK_FLOAT>(
-            anakin_bias_shape);
-    float *cpu_data2 = static_cast<float *>(weight2->h_tensor().mutable_data());
-    std::copy_n(bias_data, bias_tensor.numel(), cpu_data2);
-    weight2->d_tensor().set_shape(anakin_bias_shape);
-    weight2->d_tensor().copy_from(weight2->h_tensor());
+    auto weight2 = pblock_from_var<TargetT>(*b_v);
     this->engine_->AddOpAttr(op_name, "weight_2", *weight2);
   }
 }

paddle/fluid/inference/anakin/convert/helper.h

@@ -55,12 +55,17 @@ PBlock<T>* pblock_from_tensor(const framework::LoDTensor& tensor,
 
 template <typename T>
 PBlock<T>* pblock_from_vector(const std::vector<float>& vec,
-               const std::vector<int>& shape_vec) {
+               std::vector<int> shape_vec) {
+  while (shape_vec.size() < 4) {
+    shape_vec.insert(shape_vec.begin(), 1);
+  }
   Shape shape(shape_vec);
   auto *weight =
       GraphGlobalMem<T>::Global().template new_block<AK_FLOAT>(shape);
   auto *weight_data = static_cast<float *>(weight->h_tensor().mutable_data());
   std::copy(std::begin(vec), std::end(vec), weight_data);
+  weight->d_tensor().set_shape(shape);
+  weight->d_tensor().copy_from(weight->h_tensor());
   return weight;
 }