[Cherry-pick Fleety_12] Bigtensor and api precision (#76028)

* CallScalarFunction uses the dtype of 'self' as the type of 'other' when opotype is 'div'(#75237)

* LinspaceKernel uses the dtype of 'self' as the type of 'step' when tensor is floating (#75238)

* align LinspaceKernel

* update meta

* update gpu kernel

* fix LinspaceKernelInner

* improve kernel

* fix CudaSigmoidGradFunctor and CudaSiluGradFunctor (#75341)

* Softplus accuracy and torch alignment 1 (#75363)

* [Precision Depth Alignment] paddle.tan reverse calculation: dx = dout *(1 + tan(x)^2) (#75335)

* Tan reverse calculation: dx = dout *(1 + tan(x)^2)

* [Precision Depth Alignment] Add support for CUDNN to paddle.nn.functional.grid_sample to align with torch accuracy.  (#75355)

* accuracy_stable_grid_sample

* fix

* correlation supports big tensor (#75383)

* fix

* fix test

* fix

* paddle.tanh Grad and torch alignment (float16) (#75454)

* [Precision Depth Alignment] paddle.sin and paddle.cos aligns with torch precision. (#75503)

* accuracy_stable_sin

* accuracy_stable_cos

* [深度对齐]Divide (#75379)

* fix

* fix

* fix

* fix

* fix

* [Precision Depth Alignment] fix precision for float16 of paddle.tan backward (#75525)

* fix precision for float16 of paddle.tan backward

* fix else branch of CudaTanGradFunctor

* [Precision Depth Alignment] fix precision for  paddle.expm1 (#75549)

* accuracy_stable_expm1

* fix

* Bigtensor排查修复[Paddle/paddle/phi/kernels/funcs] (#75523)

* fix

* fix

* [Precision Depth Alignment]  fix beta and threshold of paddle.nn.functional.softplus  to double (#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

* fix (#75605)

* [深度对齐] dot (#75717)

* fix

* fix

* fix dcu

* [Precision Depth Alignment]  paddle.log aligns with torch precision (#75799)

* accuracy_stable_log

* accuracy_stable_log

* fix

* fix

* fix

* fix

* fix5

* [Precision Depth Alignment] fix eps of paddle.logit from float to double (#75816)

* accuracy_stable_logit

* add LogitOpTranscriber

* fix coverage

* fix 0yaml

* [Precision Depth Alignment] paddle.log_sigmoid (#75898)

* accuracy_stable_log_sigmoid

* fix test_activation_stride_op.py

* [Precision Depth Alignment] Modify the negative_slope parameter of the paddle.nn.functional.leaky_relu API to double (#75547)

* [big tensor] Paddle/paddle/phi/kernels/funcs gpuBigtensor (#75856)

* fix funcs

* gpu

* fix

* fix

* 修改PADDLE_ENFORCE信息

* fix cpu error

* fix dcu

* fix dcu

* fix

* [Fix] log sigmoid complex (#75953)

* feature: Add specialized LogSigmoidFunctor and CudaLogSigmoidFunctor for complex numbers

This commit introduces specialized implementations of LogSigmoidFunctor and CudaLogSigmoidFunctor to handle complex number inputs. The new implementations utilize direct formulas for improved accuracy and stability in calculations involving complex types.

* refactor: Optimize LogSigmoidFunctor and CudaLogSigmoidFunctor for complex types by caching exp(-x) to reduce redundant computations. This change enhances performance while maintaining accuracy in calculations.

* refactor: modified the formula in LogSigmoidFunctor to make it numerical stable

---------

Co-authored-by: Zhan Rongrui <[email protected]>
Co-authored-by: 正在学习 <[email protected]>
Co-authored-by: Bvicii <[email protected]>

Author: 4 people

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

@@ -3494,6 +3494,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

@@ -1085,6 +1085,42 @@ struct CastOpTranscriber : public OpTranscriber {
   }
 };
 
+struct LeakyReLUOpTranscriber : 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 == "alpha") {
+          new_attr = pir::DoubleAttribute::get(
+              ctx,
+              static_cast<double>(
+                  new_attr.dyn_cast<pir::FloatAttribute>().data()));
+        }
+        attribute_map[info.name] = new_attr;
+      }
+    }
+
+    return attribute_map;
+  }
+};
+
 struct Conv2dOpTranscriber : public OpTranscriber {
   void HandleNonexistentAttribute(pir::IrContext* ctx,
                                   pir::AttributeMap* attribute_map,
@@ -3921,6 +3957,80 @@ 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;
+  }
+};
+
+struct LogitOpTranscriber : 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 == "eps") {
+          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>();
@@ -3933,6 +4043,8 @@ OpTranslator::OpTranslator() {
   special_handlers["batch_norm"] = BatchNormOpTranscriber();
   special_handlers["range"] = ArangeOpTranscriber();
   special_handlers["cast"] = CastOpTranscriber();
+  special_handlers["leaky_relu"] = LeakyReLUOpTranscriber();
+  special_handlers["leaky_relu_grad"] = LeakyReLUOpTranscriber();
   special_handlers["conv2d"] = Conv2dOpTranscriber();
   special_handlers["conv3d"] = Conv3dOpTranscriber();
   special_handlers["cross_entropy_with_softmax"] =
@@ -4033,5 +4145,9 @@ OpTranslator::OpTranslator() {
       WithXShapeAndAxisGradOpTranscriber<dialect::UnsqueezeGradOp>();
 
   special_handlers["c_sync_comm_stream"] = SyncCommStreamOpTranscriber();
+  special_handlers["softplus"] = SoftPlusOpTranscriber();
+  special_handlers["softplus_grad"] = SoftPlusOpTranscriber();
+  special_handlers["logit"] = LogitOpTranscriber();
+  special_handlers["logit_grad"] = LogitOpTranscriber();
 }
 }  // 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/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/serialize_deserialize/patch/0.yaml

@@ -0,0 +1,33 @@
+op_patches:
+  - op_name : pd_op.leaky_relu
+    actions:
+      - action : modify_attr
+        object : negative_slope
+        type : pir::DoubleAttribute
+  - op_name : pd_op.softplus
+    actions:
+      - action : modify_attr
+        object : beta
+        type : pir::DoubleAttribute
+      - action : modify_attr
+        object : threshold
+        type : pir::DoubleAttribute
+  - op_name : onednn_op.fused_softplus
+    actions:
+      - action : modify_attr
+        object : beta
+        type : pir::DoubleAttribute
+      - action : modify_attr
+        object : threshold
+        type : pir::DoubleAttribute
+      - action : modify_attr
+        object : fuse_alpha
+        type : pir::DoubleAttribute
+      - action : modify_attr
+        object : fuse_beta
+        type : pir::DoubleAttribute
+  - op_name : pd_op.logit
+    actions:
+      - action : modify_attr
+        object : eps
+        type : pir::DoubleAttribute

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

@@ -136,7 +136,7 @@ class ConvActivationFusePattern : public paddle::drr::DrrPatternBase {
     pat.AddConstraint([&](const paddle::drr::MatchContext &match_ctx) {
       if (activation_name_ == "leaky_relu_" ||
           activation_name_ == "leaky_relu") {
-        float negative_slope = match_ctx.Attr<float>("negative_slope");
+        auto negative_slope = match_ctx.Attr<double>("negative_slope");
         // leaky relu alpha is a positive number
         if (negative_slope <= 0.0) {
           return false;

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

@@ -160,7 +160,7 @@ class NConvConcatActivationFusePattern : public paddle::drr::DrrPatternBase {
     }
     pat.AddConstraint([&](const paddle::drr::MatchContext &match_ctx) {
       if (activation_name_ == "leaky_relu") {
-        float negative_slope = match_ctx.Attr<float>("negative_slope");
+        double negative_slope = match_ctx.Attr<double>("negative_slope");
         // leaky relu alpha is a positive number
         if (negative_slope <= 0.0) {
           return false;