[PIR] fix translation for inference model: cascade_rcnn_r50_fpn_1x_coco (#59936)

kangguangli · web-flow · commit 8f81daf0bc3b · 2023-12-20T21:28:34.000+08:00
* fix translation for inference model: cascade_rcnn_r50_fpn_1x_coco

* fix

* fix MobileNetV1_ssld

* resolve conflicts

* resolve conflicts

* resolve conflicts

* test

* fix CI

* fix CI

* fix

* fix

* test

* resolve comments

* fix bug: _c_ops.dropout no longer return mask

* revert
diff --git a/paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.cc b/paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.cc
@@ -14,6 +14,7 @@
 
 #include "paddle/fluid/framework/new_executor/pir_adaptor/pir_adaptor_util.h"
 
+#include "paddle/common/ddim.h"
 #include "paddle/fluid/framework/op_info.h"
 #include "paddle/fluid/framework/operator.h"
 #include "paddle/fluid/framework/scope.h"
@@ -415,7 +416,25 @@ void HandleForSpecialOp(pir::Operation* op,
     Variable* var = value_exe_info->GetScope()->FindVar(name);
     if (var == nullptr) {
       var = value_exe_info->GetScope()->Var(name);
-      var->GetMutable<phi::DenseTensor>();
+      auto* t = var->GetMutable<phi::DenseTensor>();
+      if (op_name == paddle::dialect::DataOp::name()) {
+        auto shape = op->attribute<dialect::IntArrayAttribute>("shape");
+        auto dim = phi::make_ddim(shape.data().GetData());
+        auto dtype = op->attribute<dialect::DataTypeAttribute>("dtype");
+        auto place = op->attribute<dialect::PlaceAttribute>("place").data();
+        if (place.GetType() == phi::AllocationType::UNDEFINED) {
+          place = phi::CPUPlace();
+        }
+        if (phi::product(dim) >= 0) {
+          phi::DenseTensorMeta meta(dtype.data(), dim);
+          t->set_meta(meta);
+          auto* dev_ctx = platform::DeviceContextPool::Instance().Get(place);
+          dev_ctx->Alloc(t, dtype.data());
+          VLOG(10) << "[Alloc var]: "
+                   << op->attribute<pir::StrAttribute>("name") << " "
+                   << t->initialized();
+        }
+      }
     }
     PADDLE_ENFORCE(var,
                    paddle::platform::errors::InvalidArgument(
diff --git a/paddle/fluid/ir_adaptor/translator/op_compat_gen.py b/paddle/fluid/ir_adaptor/translator/op_compat_gen.py
@@ -147,6 +147,7 @@ def insert_new_mutable_attributes(
         "grad_bias_grad": "DDBias",
         "grad_out": "DY",
     }
+    op_arg_name_mappings["matmul"] = {"x": "X", "y": "Y", "out": "Out"}
 
     op_name_normailzer_template = env.get_template("op_compat_info.cc.j2")
     with open(output_source_file, 'wt') as f:
diff --git a/paddle/fluid/ir_adaptor/translator/op_translator.cc b/paddle/fluid/ir_adaptor/translator/op_translator.cc
@@ -1939,18 +1939,55 @@ struct SelectInputOpTranscriber : public OpTranscriber {
           tensor1.data_layout() != tensor2.data_layout() ||
           tensor1.lod() != tensor2.lod() ||
           tensor1.offset() != tensor2.offset()) {
-        IR_THROW(
-            "select_input only support same type or DenseTensorType with "
-            "only different dim, but get dtype:[%s, %s], layout:[%s, %s], "
-            "lod:[%s, %s], offset:[%s, %s].",
-            tensor1.dtype(),
-            tensor2.dtype(),
-            tensor1.data_layout(),
-            tensor2.data_layout(),
-            tensor1.lod(),
-            tensor2.lod(),
-            tensor1.offset(),
-            tensor2.offset());
+        const std::string undefined_prefix = "undefined_var_";
+
+        size_t undefined_var_index = 0;
+        size_t target_var_index = 1;
+        if (Input_name[undefined_var_index].substr(
+                0, undefined_prefix.size()) != undefined_prefix &&
+            Input_name[target_var_index].substr(0, undefined_prefix.size()) ==
+                undefined_prefix) {
+          std::swap(undefined_var_index, target_var_index);
+        } else if (Input_name[undefined_var_index].substr(
+                       0, undefined_prefix.size()) == undefined_prefix) {
+          // do nothing
+        } else {
+          IR_THROW(
+              "select_input only support same type or DenseTensorType with "
+              "only different dim, but get dtype:[%s, %s], layout:[%s, %s], "
+              "lod:[%s, %s], offset:[%s, %s].",
+              tensor1.dtype(),
+              tensor2.dtype(),
+              tensor1.data_layout(),
+              tensor2.data_layout(),
+              tensor1.lod(),
+              tensor2.lod(),
+              tensor1.offset(),
+              tensor2.offset());
+        }
+
+        auto undefined_var_type = tensor1;
+        auto target_var_type = tensor2;
+        if (undefined_var_index == 1) {
+          std::swap(undefined_var_type, target_var_type);
+        }
+
+        auto undefine_value = op_inputs[1 + undefined_var_index];
+        IR_ENFORCE(
+            undefine_value.defining_op()->isa<dialect::AssignValueOp>(),
+            "undefined_var %s should be generated by assign_value, but got %s",
+            Input_name[undefined_var_index],
+            undefine_value.defining_op());
+
+        undefine_value.set_type(target_var_type);
+        undefine_value.defining_op()->set_attribute(
+            "dtype",
+            dialect::DataTypeAttribute::get(
+                ctx, PirTypeToPhiDType(undefined_var_type.dtype())));
+        auto& attribute_translator = AttributeTranslator::instance();
+        undefine_value.defining_op()->set_attribute(
+            "shape",
+            attribute_translator(common::vectorize(undefined_var_type.dims())));
       }
       auto dim1 = input1.dyn_cast<paddle::dialect::DenseTensorType>().dims();
       auto dim2 = input2.dyn_cast<paddle::dialect::DenseTensorType>().dims();
@@ -2801,6 +2838,74 @@ struct SliceOpTranscriber : public OpTranscriber {
   }
 };
 
+struct LegacyMatmulOpTranscriber : public OpTranscriber {
+  pir::OpInfo LoopkUpOpInfo(pir::IrContext* ctx,
+                            const OpDesc& op_desc) override {
+    auto enforce_not_occur = [&](const std::string& attr_name,
+                                 float expected_value) -> void {
+      if (!op_desc.HasAttr(attr_name)) {
+        return;
+      }
+      float v = PADDLE_GET_CONST(float, op_desc.GetAttr(attr_name));
+      if (abs(v - expected_value) > 1e-6f) {
+        IR_THROW("Expected op[%s]'s attr %s is not %f",
+                 op_desc.Type(),
+                 attr_name,
+                 v);
+      }
+    };
+
+    enforce_not_occur("Scale_x", 1.0f);
+    enforce_not_occur("Scale_y", 1.0f);
+    enforce_not_occur("Scale_out", 1.0f);
+
+    std::string target_op_name = dialect::MatmulOp::name();
+    const auto& op_info = ctx->GetRegisteredOpInfo(target_op_name);
+    if (!op_info) {
+      IR_THROW(
+          "Op read_from_array should have corresponding OpInfo "
+          "pd_op.read_array");
+    }
+
+    return op_info;
+  }
+
+  void RecordOpResultMapping(pir::IrContext* ctx,
+                             TranslationContext* param_map,
+                             const OpDesc& op_desc,
+                             pir::Operation* operation,
+                             const OpOutputMapping& arg_to_idx) override {
+    OpTranscriber::RecordOpResultMapping(
+        ctx, param_map, op_desc, operation, arg_to_idx);
+
+    float alpha = PADDLE_GET_CONST(float, op_desc.GetAttr("alpha"));
+    if (abs(alpha - 1.0f) < 1e-6f) {
+      return;
+    }
+
+    const auto& output_vars = op_desc.Output("Out");
+    IR_ENFORCE(output_vars.size() == 1,
+               "Expected op[%s]'s output `Out` has only 1 variable, but got %d",
+               op_desc.Type(),
+               output_vars.size());
+
+    auto idx_iter = arg_to_idx.find(output_vars[0]);
+    if (idx_iter == arg_to_idx.end()) {
+      IR_THROW("op[%s] should have got its `Out`", op_desc.Type());
+    }
+    auto [idx_in_op, idx_in_vec] = idx_iter->second;
+    VLOG(10) << "[output recording]"
+             << "[" << op_desc.Type() << "]" << output_vars[0] << " "
+             << idx_in_op << " " << idx_in_vec;
+
+    pir::Builder builder(ctx, operation->GetParent());
+    pir::OpResult value = operation->result(idx_in_op);
+    auto scale_op = builder.Build<dialect::ScaleOp>(value, alpha);
+    param_map->PushValue(output_vars[0],
+                         VariableDefiningInfo(scale_op.out(), false, -1));
+  }
+};
+
 struct CEmbeddingOpTranscriber : public OpTranscriber {
   void HandleNonexistentAttribute(pir::IrContext* ctx,
                                   pir::AttributeMap* attribute_map,
diff --git a/paddle/fluid/ir_adaptor/translator/program_translator.cc b/paddle/fluid/ir_adaptor/translator/program_translator.cc
@@ -14,6 +14,7 @@
 
 #include "paddle/fluid/ir_adaptor/translator/program_translator.h"
 
+#include <chrono>
 #include <unordered_map>
 
 #include "glog/logging.h"
@@ -60,6 +61,12 @@ const std::unordered_set<std::string> ProgramTranslator::unsupported_ops = {
     "while_grad",
 };
 
+std::string nano_timestamp() {
+  auto ts =
+      std::chrono::high_resolution_clock::now().time_since_epoch().count();
+  return std::to_string(ts);
+}
+
 const TCValue& TranslationContext::operator[](const TCKey& key) const {
   return at(key);
 }
@@ -178,19 +185,19 @@ void ProgramTranslator::TranslateBlock(const BlockDesc& src_block,
   }
 }
 
-pir::Operation* ProgramTranslator::InsertFullOrDataOpToBlock(
+pir::Operation* ProgramTranslator::InsertDataOpOrCreateArrayToBlock(
     pir::Block* insert_block, pir::Type type) {
   pir::Builder builder(ctx_, insert_block, insert_block->begin());
   if (type.isa<paddle::dialect::DenseTensorType>()) {
     auto tensor_type = type.dyn_cast<paddle::dialect::DenseTensorType>();
     std::vector<int64_t> shape = common::vectorize(tensor_type.dims());
-    paddle::dialect::FullOp full_op = builder.Build<paddle::dialect::FullOp>(
+    auto data_op = builder.Build<paddle::dialect::DataOp>(
+        "data_" + nano_timestamp(),
         shape,
-        0,
         paddle::dialect::TransToPhiDataType(tensor_type.dtype()),
         phi::CPUPlace());
-    full_op.out().set_type(type);
-    return full_op.operation();
+    data_op.out().set_type(type);
+    return data_op.operation();
   } else if (type.isa<paddle::dialect::DenseTensorArrayType>()) {
     auto array_type = type.dyn_cast<paddle::dialect::DenseTensorArrayType>();
     paddle::dialect::CreateArrayOp array_op =
@@ -273,7 +280,7 @@ void ProgramTranslator::TranslateIfOperation(
       if (false_block_context->count(cond_op_outputs[id]) == 0) {
         auto true_type = true_yeild_inputs[id].type();
         pir::Operation* init_op =
-            InsertFullOrDataOpToBlock(&false_region.front(), true_type);
+            InsertDataOpOrCreateArrayToBlock(&false_region.front(), true_type);
         PADDLE_ENFORCE_NOT_NULL(
             init_op,
             phi::errors::PreconditionNotMet(
diff --git a/paddle/fluid/ir_adaptor/translator/program_translator.h b/paddle/fluid/ir_adaptor/translator/program_translator.h
@@ -131,8 +131,8 @@ class ProgramTranslator {
   const VariableDefiningInfo& CreateUndefinedVariable(
       const std::string& var_name, const BlockDesc& block);
 
-  pir::Operation* InsertFullOrDataOpToBlock(pir::Block* insert_block,
-                                            pir::Type type);
+  pir::Operation* InsertDataOpOrCreateArrayToBlock(pir::Block* insert_block,
+                                                   pir::Type type);
 
   void TranslateIfOperation(const OpDesc* op,
                             TranslationContext* translation_ctx,
diff --git a/paddle/fluid/ir_adaptor/translator/utils.cc b/paddle/fluid/ir_adaptor/translator/utils.cc
@@ -105,5 +105,36 @@ std::vector<std::string> CheckUnregisteredOperation(
   return unregistered_ops;
 }
 
+phi::DataType PirTypeToPhiDType(pir::Type type) {
+  if (type.isa<pir::UInt8Type>()) {
+    return phi::DataType::UINT8;
+  } else if (type.isa<pir::Int8Type>()) {
+    return phi::DataType::INT8;
+  } else if (type.isa<pir::Int16Type>()) {
+    return phi::DataType::INT16;
+  } else if (type.isa<pir::Int32Type>()) {
+    return phi::DataType::INT32;
+  } else if (type.isa<pir::Int64Type>()) {
+    return phi::DataType::INT64;
+  } else if (type.isa<pir::Float32Type>()) {
+    return phi::DataType::FLOAT32;
+  } else if (type.isa<pir::Float64Type>()) {
+    return phi::DataType::FLOAT64;
+  } else if (type.isa<pir::BoolType>()) {
+    return phi::DataType::BOOL;
+  } else if (type.isa<pir::Float16Type>()) {
+    return phi::DataType::FLOAT16;
+  } else if (type.isa<pir::BFloat16Type>()) {
+    return phi::DataType::BFLOAT16;
+  } else if (type.isa<pir::Complex64Type>()) {
+    return phi::DataType::COMPLEX64;
+  } else if (type.isa<pir::Complex128Type>()) {
+    return phi::DataType::COMPLEX128;
+  } else {
+    PADDLE_THROW(phi::errors::Unimplemented(
+        "Unsupported pirType `%s` when casting it into phi::DataType.", type));
+  }
+}
+
 }  // namespace translator
 }  // namespace paddle
diff --git a/paddle/fluid/ir_adaptor/translator/utils.h b/paddle/fluid/ir_adaptor/translator/utils.h
@@ -100,5 +100,7 @@ inline DataType VarTypeToDataType(
   }
 }
 
+phi::DataType PirTypeToPhiDType(pir::Type type);
+
 }  // namespace translator
 }  // namespace paddle
diff --git a/paddle/fluid/pir/dialect/operator/ir/ops.yaml b/paddle/fluid/pir/dialect/operator/ir/ops.yaml
@@ -371,7 +371,7 @@
   kernel :
     func : dropout
     data_type : x
-  optional : seed_tensor
+  optional : seed_tensor, mask
   backward : dropout_grad
 
 - op : einsum
diff --git a/paddle/phi/api/yaml/op_compat.yaml b/paddle/phi/api/yaml/op_compat.yaml
@@ -3400,6 +3400,14 @@
   outputs:
     {param_out : ParamOut, moment_out : MomentOut}
 
+- op: distribute_fpn_proposals
+  inputs :
+    {fpn_rois: FpnRois, rois_num: RoisNum}
+  outputs :
+    multi_fpn_rois : MultiFpnRois
+    multi_level_rois_num: MultiLevelRoIsNum
+    restore_index: RestoreIndex
+
 - op: dpsgd
   inputs:
     {param: Param,grad: Grad,learning_rate: LearningRate}

Original file line number	Diff line number	Diff line change
`@@ -147,6 +147,7 @@ def insert_new_mutable_attributes(`
`147`	`147`	`"grad_bias_grad": "DDBias",`
`148`	`148`	`"grad_out": "DY",`
`149`	`149`	`}`
	`150`	`+ op_arg_name_mappings["matmul"] = {"x": "X", "y": "Y", "out": "Out"}`
`150`	`151`
`151`	`152`	`op_name_normailzer_template = env.get_template("op_compat_info.cc.j2")`
`152`	`153`	`with open(output_source_file, 'wt') as f:`
Original file line number	Diff line number	Diff line change
`@@ -100,5 +100,7 @@ inline DataType VarTypeToDataType(`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
	`103`	`+phi::DataType PirTypeToPhiDType(pir::Type type);`
	`104`	`+`
`103`	`105`	`} // namespace translator`
`104`	`106`	`} // namespace paddle`