[Precision Depth Alignment] fix beta and threshold of paddle.nn.functional.softplus to double (PaddlePaddle#75426)

* fix beta and threshold of Softplus to double

* fix test_softplus_activation_fuse_pass v1

* fix test_activation_zero

* fix flaot of SoftplusDoubleGradKernel to double

* add op_patches for softplus

* add yaml for ops/yaml/legacy

* fix infershape/operator for FLOAT64

* fix

* add SoftPlusOpTranscriber

* fix

* fix

* fix1

* fix2

* fix coverage

* fix coverage2

Author: zhengshengning

paddle/fluid/framework/infershape_utils.cc

@@ -795,6 +795,11 @@ CompatInferMetaContext BuildInferMetaContext(InferShapeContext* ctx,
               infer_meta_context.EmplaceBackAttr(PADDLE_GET_CONST(float, attr));
               break;
             case phi::AttributeType::FLOAT64:
+              if (AttrTypeID(attr) == framework::proto::AttrType::FLOAT) {
+                const auto val = PADDLE_GET_CONST(float, attr);
+                infer_meta_context.EmplaceBackAttr(static_cast<double>(val));
+                break;
+              }
               infer_meta_context.EmplaceBackAttr(
                   PADDLE_GET_CONST(double, attr));
               break;

paddle/fluid/framework/new_executor/instruction/onednn/onednn_instruction.cc

@@ -53,6 +53,8 @@ static phi::Attribute ConvertPirAttribute2RuntimeAttribute(
     return attr.dyn_cast<pir::Int32Attribute>().data();
   } else if (attr_type_name == "pir::FloatAttribute") {
     return attr.dyn_cast<pir::FloatAttribute>().data();
+  } else if (attr_type_name == "pir::DoubleAttribute") {
+    return attr.dyn_cast<pir::DoubleAttribute>().data();
   } else if (attr_type_name == "pir::BoolAttribute") {
     return attr.dyn_cast<pir::BoolAttribute>().data();
   } else if (attr_type_name == "pir::StrAttribute") {

paddle/fluid/framework/operator.cc

@@ -3514,6 +3514,12 @@ void OperatorWithKernel::BuildPhiKernelContext(
                 PADDLE_GET_CONST(float, attr_iter->second));
             break;
           case phi::AttributeType::FLOAT64:
+            if (AttrTypeID(attr_iter->second) ==
+                framework::proto::AttrType::FLOAT) {
+              const auto val = PADDLE_GET_CONST(float, attr_iter->second);
+              phi_kernel_context->EmplaceBackAttr(static_cast<double>(val));
+              break;
+            }
             phi_kernel_context->EmplaceBackAttr(
                 PADDLE_GET_CONST(double, attr_iter->second));
             break;

paddle/fluid/ir_adaptor/translator/op_translator.cc

@@ -3921,6 +3921,43 @@ struct SyncCommStreamOpTranscriber : public OpTranscriber {
   }
 };
 
+struct SoftPlusOpTranscriber : public OpTranscriber {
+  pir::AttributeMap TranslateOpAttribute(
+      pir::IrContext* ctx,
+      const std::string& normalized_op_name,
+      const OpAttributeInfoList& op_attr_infos,
+      const OpDesc& op_desc) override {
+    auto& attribute_translator = AttributeTranslator::instance();
+    auto& op_normalizer = OpNameNormalizer::instance();
+    pir::AttributeMap attribute_map = {};
+
+    for (const auto& info : op_attr_infos) {
+      auto legacy_attr_name =
+          op_normalizer.GetLegacyAttrName(op_desc.Type(), info.name);
+      VLOG(10) << "[op: " << op_desc.Type()
+               << "][attr] from: " << legacy_attr_name << " to: " << info.name;
+      if (op_desc.HasAttr(legacy_attr_name)) {
+        paddle::framework::Attribute legacy_attr =
+            op_desc.GetAttr(legacy_attr_name);
+        VLOG(10) << "attribute in " << op_desc.Type()
+                 << " name: " << legacy_attr_name << " " << legacy_attr.index();
+        pir::Attribute new_attr =
+            attribute_translator(info.type_name, legacy_attr);
+        if (legacy_attr_name == "beta" || legacy_attr_name == "threshold") {
+          new_attr = pir::DoubleAttribute::get(
+              ctx,
+              static_cast<double>(
+                  new_attr.dyn_cast<pir::FloatAttribute>().data()));
+        }
+        attribute_map[info.name] = new_attr;
+      } else {
+        this->HandleNonexistentAttribute(ctx, &attribute_map, info);
+      }
+    }
+    return attribute_map;
+  }
+};
+
 OpTranslator::OpTranslator() {
   pir::IrContext* ctx = pir::IrContext::Instance();
   ctx->GetOrRegisterDialect<paddle::dialect::OperatorDialect>();
@@ -4033,5 +4070,7 @@ OpTranslator::OpTranslator() {
       WithXShapeAndAxisGradOpTranscriber<dialect::UnsqueezeGradOp>();
 
   special_handlers["c_sync_comm_stream"] = SyncCommStreamOpTranscriber();
+  special_handlers["softplus"] = SoftPlusOpTranscriber();
+  special_handlers["softplus_grad"] = SoftPlusOpTranscriber();
 }
 }  // namespace paddle::translator

paddle/fluid/pir/drr/include/drr_pattern_context.h

@@ -297,6 +297,8 @@ class TEST_API ResultPattern {
 
   Attribute Float32Attr(float value) const;
 
+  Attribute DoubleAttr(double value) const;
+
   Attribute VectorInt64Attr(const std::vector<int64_t>& value) const;
 
   Attribute VectorInt32Attr(const std::vector<int32_t>& value) const;

paddle/fluid/pir/drr/src/pattern_context.cc

@@ -205,6 +205,11 @@ Attribute ResultPattern::Float32Attr(float value) const {
       [=](const MatchContext& match_ctx) -> float { return value; });
 }
 
+Attribute ResultPattern::DoubleAttr(double value) const {
+  return ComputeAttr(
+      [=](const MatchContext& match_ctx) -> double { return value; });
+}
+
 Attribute ResultPattern::VectorInt64Attr(
     const std::vector<int64_t>& value) const {
   return ComputeAttr(

paddle/fluid/pir/serialize_deserialize/0.yaml

@@ -0,0 +1,29 @@
+op_patches:
+  - op_name : pd_op.softplus
+    actions:
+      - action : modify_attr
+        object : beta
+        type : pir::DoubleAttribute
+        data : 1.0
+      - action : modify_attr
+        object : threshold
+        type : pir::DoubleAttribute
+        data : 20.0
+  - op_name : onednn_op.fused_softplus
+    actions:
+      - action : modify_attr
+        object : beta
+        type : pir::DoubleAttribute
+        data : 1.0
+      - action : modify_attr
+        object : threshold
+        type : pir::DoubleAttribute
+        data : 20.0
+      - action : modify_attr
+        object : fuse_alpha
+        type : pir::DoubleAttribute
+        data : 0.0
+      - action : modify_attr
+        object : fuse_beta
+        type : pir::DoubleAttribute
+        data : 0.0

paddle/fluid/pir/serialize_deserialize/CMakeLists.txt

@@ -13,7 +13,7 @@ endif()
 
 file(GLOB_RECURSE YAML_PATCH_FILES "*.yaml")
 # change pir version when new patches are added
-add_definitions(-DDEVELOP_VERSION=3)
+add_definitions(-DDEVELOP_VERSION=0)
 add_definitions(-DRELEASE_VERSION=3)
 set(TEMPLATE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/patch/template.h.in)
 set(PATCH_HEADER ${CMAKE_CURRENT_BINARY_DIR}/patch/patch.h)

paddle/fluid/pir/transforms/onednn/softplus_activation_fuse_pass.cc

@@ -120,24 +120,36 @@ class SoftplusActivationFusePattern : public paddle::drr::DrrPatternBase {
         {"beta", pat.Attr("beta")}, {"threshold", pat.Attr("threshold")}};
 
     if (act_type_ == paddle::dialect::HardswishOp::name()) {
-      fused_attrs.emplace("fuse_alpha", res.Float32Attr(1.0f / 6.0f));
-      fused_attrs.emplace("fuse_beta", res.Float32Attr(1.0f / 2.0f));
+      fused_attrs.emplace("fuse_alpha", res.DoubleAttr(1.0 / 6.0));
+      fused_attrs.emplace("fuse_beta", res.DoubleAttr(1.0 / 2.0));
     } else if (act_type_ == paddle::dialect::HardsigmoidOp::name()) {
-      fused_attrs.emplace("fuse_alpha", pat.Attr("fuse_alpha"));
-      fused_attrs.emplace("fuse_beta", pat.Attr("fuse_beta"));
+      const auto &fuse_alpha = res.ComputeAttr(
+          [](const paddle::drr::MatchContext &match_ctx) -> double {
+            return static_cast<double>(match_ctx.Attr<float>("fuse_alpha"));
+          });
+      const auto &fuse_beta = res.ComputeAttr(
+          [](const paddle::drr::MatchContext &match_ctx) -> double {
+            return static_cast<double>(match_ctx.Attr<float>("fuse_beta"));
+          });
+      fused_attrs.emplace("fuse_alpha", fuse_alpha);
+      fused_attrs.emplace("fuse_beta", fuse_beta);
     } else if (act_type_ == paddle::dialect::LeakyRelu_Op::name() ||
                act_type_ == paddle::dialect::LeakyReluOp::name()) {
-      fused_attrs.emplace("fuse_alpha", pat.Attr("fuse_alpha"));
+      const auto &fuse_alpha = res.ComputeAttr(
+          [](const paddle::drr::MatchContext &match_ctx) -> double {
+            return static_cast<double>(match_ctx.Attr<float>("fuse_alpha"));
+          });
+      fused_attrs.emplace("fuse_alpha", fuse_alpha);
     } else if (act_type_ == paddle::dialect::SwishOp::name()) {
-      fused_attrs.emplace("fuse_alpha", res.Float32Attr(1.0f));
+      fused_attrs.emplace("fuse_alpha", res.DoubleAttr(1.0));
     } else if (act_type_ == paddle::dialect::Relu6Op::name()) {
-      fused_attrs.emplace("fuse_beta", res.Float32Attr(6.0f));
+      fused_attrs.emplace("fuse_beta", res.DoubleAttr(6.0));
     }
 
     fused_attrs.insert(std::make_pair("fuse_activation",
                                       res.StrAttr(activation_type[act_type_])));
-    fused_attrs.insert(std::make_pair("fuse_alpha", res.Float32Attr(0.0f)));
-    fused_attrs.insert(std::make_pair("fuse_beta", res.Float32Attr(0.0f)));
+    fused_attrs.insert(std::make_pair("fuse_alpha", res.DoubleAttr(0.0)));
+    fused_attrs.insert(std::make_pair("fuse_beta", res.DoubleAttr(0.0)));
 
     const auto &fused_softplus = res.Op(fused_softplus_name_, fused_attrs);
 
@@ -188,8 +200,8 @@ class SoftplusGeluTanhFusePattern : public paddle::drr::DrrPatternBase {
         {"beta", pat.Attr("beta")},
         {"threshold", pat.Attr("threshold")},
         {"fuse_activation", res.StrAttr("gelu_tanh")},
-        {"fuse_alpha", res.Float32Attr(0.0f)},
-        {"fuse_beta", res.Float32Attr(0.0f)}};
+        {"fuse_alpha", res.DoubleAttr(0.0)},
+        {"fuse_beta", res.DoubleAttr(0.0)}};
 
     const auto &fused_softplus = res.Op(fused_softplus_name_, fused_attrs);
 
@@ -244,11 +256,11 @@ class SoftplusClipFusePattern : public paddle::drr::DrrPatternBase {
     paddle::drr::ResultPattern res = pat.ResultPattern();
 
     const auto &fuse_alpha = res.ComputeAttr(
-        [](const paddle::drr::MatchContext &match_ctx) -> float {
+        [](const paddle::drr::MatchContext &match_ctx) -> double {
           return match_ctx.Attr<double>("value1");
         });
     const auto &fuse_beta = res.ComputeAttr(
-        [](const paddle::drr::MatchContext &match_ctx) -> float {
+        [](const paddle::drr::MatchContext &match_ctx) -> double {
           return match_ctx.Attr<double>("value2");
         });
 

paddle/fluid/pybind/pir.cc

@@ -3286,6 +3286,12 @@ void BindDrrPatternContext(pybind11::module *m) {
             return self.Float32Attr(value);
           },
           pybind11::arg("value"))
+      .def(
+          "DoubleAttr",
+          [](drr::ResultPattern &self, double value) {
+            return self.DoubleAttr(value);
+          },
+          pybind11::arg("value"))
       .def(
           "VectorInt32Attr",
           [](drr::ResultPattern &self, const std::vector<int32_t> &value) {