support auto generate for static op elementwise_min (#55008)

RedContritio · web-flow · commit 36eb5cde3140 · 2023-07-14T17:18:20.000+08:00
diff --git a/paddle/fluid/operators/elementwise/elementwise_min_op.cc b/paddle/fluid/operators/elementwise/elementwise_min_op.cc
diff --git a/paddle/fluid/operators/elementwise/unity_build_rule.cmake b/paddle/fluid/operators/elementwise/unity_build_rule.cmake
@@ -4,9 +4,8 @@
 # Generally, the combination rules in this file do not need to be modified.
 # If there are some redefined error in compiling with the source file which
 # in combination rule, you can remove the source file from the following rules.
-register_unity_group(
-  cc elementwise_add_op.cc elementwise_div_op.cc elementwise_min_op.cc
-  elementwise_mul_op.cc elementwise_sub_op.cc)
+register_unity_group(cc elementwise_add_op.cc elementwise_div_op.cc
+                     elementwise_mul_op.cc elementwise_sub_op.cc)
 register_unity_group(
   cu
   elementwise_add_op.cu
diff --git a/paddle/phi/api/yaml/backward.yaml b/paddle/phi/api/yaml/backward.yaml
@@ -870,6 +870,17 @@
     func : fmax_grad
     data_type : out_grad
 
+- backward_op : fmin_grad
+  forward : fmin(Tensor x, Tensor y) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param: [x, y]
+  kernel :
+    func : fmin_grad
+    data_type : out_grad
+
 - backward_op : fold_grad
   forward: fold (Tensor x, int[] output_sizes, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations) -> Tensor(out)
   args: (Tensor x, Tensor out_grad, int[] output_sizes, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations)
diff --git a/paddle/phi/api/yaml/legacy_backward.yaml b/paddle/phi/api/yaml/legacy_backward.yaml
@@ -232,16 +232,6 @@
     func : UnchangedInferMeta
   invoke : zeros_like(out_grad)
 
-- backward_op : fmin_grad
-  forward : fmin(Tensor x, Tensor y) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad)
-  output : Tensor(x_grad), Tensor(y_grad)
-  infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param: [x, y]
-  kernel :
-    func : fmin_grad
-
 - backward_op : frobenius_norm_grad
   forward : frobenius_norm(Tensor x, int64_t[] axis,  bool keep_dim,  bool reduce_all) -> Tensor(out)
   args : (Tensor x, Tensor out, Tensor out_grad, int64_t[] axis,  bool keep_dim,  bool reduce_all)
diff --git a/paddle/phi/api/yaml/legacy_ops.yaml b/paddle/phi/api/yaml/legacy_ops.yaml
@@ -326,16 +326,6 @@
   kernel :
     func : floor_divide
 
-- op : fmin
-  args : (Tensor x, Tensor y)
-  output : Tensor(out)
-  infer_meta :
-    param: [x, y]
-    func : ElementwiseInferMeta
-  kernel :
-    func : fmin
-  backward : fmin_grad
-
 - op : frobenius_norm
   args : (Tensor x, int64_t[] axis,  bool keep_dim,  bool reduce_all)
   output : Tensor(out)
diff --git a/paddle/phi/api/yaml/op_compat.yaml b/paddle/phi/api/yaml/op_compat.yaml
@@ -1107,9 +1107,15 @@
 
 - op : fmin (elementwise_fmin)
   backward : fmin_grad (elementwise_fmin_grad)
+  inputs :
+    {x : X, y : Y}
+  outputs :
+    {out : Out}
   extra :
     attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32",
              bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
+  complex_promote : [X, Y]
+  manual_signature : [fmin]
 
 - op : fold
   inputs :
@@ -1839,9 +1845,15 @@
 
 - op : minimum (elementwise_min)
   backward : minimum_grad (elementwise_min_grad)
+  inputs :
+    {x : X, y : Y}
+  outputs :
+    {out : Out}
   extra :
     attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
              bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
+  complex_promote : [X, Y]
+  manual_signature : [minimum]
 
 - op : mish
   backward : mish_grad
diff --git a/paddle/phi/api/yaml/op_version.yaml b/paddle/phi/api/yaml/op_version.yaml
@@ -181,6 +181,14 @@
           comment : In order to support the function of scaling the input Y when using the operator of elementwise_max.
           default : 1.0
 
+- op : elementwise_min
+  version :
+    - checkpoint : Register elementwise_min for adding the attribute of Scale_y.
+      action :
+        - add_attr : Scale_y
+          comment : In order to support the function of scaling the input Y when using the operator of elementwise_min.
+          default : 1.0
+
 - op : elementwise_mod
   version :
     - checkpoint : Register elementwise_mod for adding the attribute of Scale_y
diff --git a/paddle/phi/api/yaml/ops.yaml b/paddle/phi/api/yaml/ops.yaml
@@ -941,6 +941,16 @@
     func : fmax
   backward : fmax_grad
 
+- op : fmin
+  args : (Tensor x, Tensor y)
+  output : Tensor(out)
+  infer_meta :
+    func : ElementwiseInferMeta
+    param: [x, y]
+  kernel :
+    func : fmin
+  backward : fmin_grad
+
 - op : fold
   args: (Tensor x, int[] output_sizes, int[] kernel_sizes,  int[] strides, int[] paddings, int[] dilations)
   output: Tensor(out)
diff --git a/paddle/phi/api/yaml/static_backward.yaml b/paddle/phi/api/yaml/static_backward.yaml
@@ -211,6 +211,18 @@
   kernel :
     func : min_grad
 
+- backward_op : minimum_grad
+  forward : minimum(Tensor x, Tensor y, int axis = -1) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param: [x, y]
+  kernel :
+    func : minimum_grad
+    data_type : out_grad
+  composite : minimum_grad(x, y, out_grad, x_grad, y_grad)
+
 - backward_op : norm_grad
   forward : norm (Tensor x, int axis, float epsilon=1.0e-10f, bool is_test=false) -> Tensor(out), Tensor(norm)
   args : (Tensor x, Tensor norm, Tensor out_grad, int axis, float epsilon, bool is_test)
diff --git a/paddle/phi/api/yaml/static_ops.yaml b/paddle/phi/api/yaml/static_ops.yaml
@@ -407,6 +407,15 @@
     param : [x, axis, keepdim, reduce_all]
   backward : min_grad
 
+- op : minimum
+  args : (Tensor x, Tensor y, int axis = -1)
+  output : Tensor(out)
+  infer_meta :
+    func : ElementwiseRawInferMeta
+  kernel :
+    func : minimum
+  backward : minimum_grad
+
 - op : norm
   args : (Tensor x, int axis, float epsilon=1.0e-10f, bool is_test=false)
   output : Tensor(out), Tensor(norm)
diff --git a/paddle/phi/ops/compat/elementwise_sig.cc b/paddle/phi/ops/compat/elementwise_sig.cc
@@ -78,6 +78,9 @@ KernelSignature ElementwiseMaxOpArgumentMapping(
 
 KernelSignature ElementwiseMinOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
+  if (ctx.IsForInferShape()) {
+    return KernelSignature("minimum_raw", {"X", "Y"}, {"axis"}, {"Out"});
+  }
   int axis = paddle::any_cast<int>(ctx.Attr("axis"));
   if (axis == -1) {
     return KernelSignature("minimum", {"X", "Y"}, {}, {"Out"});
@@ -162,12 +165,6 @@ KernelSignature ElementwiseDivGradOpArgumentMapping(
                          {"X@GRAD", "Y@GRAD"});
 }
 
-KernelSignature ElementwiseFMinGradOpArgumentMapping(
-    const ArgumentMappingContext& ctx UNUSED) {
-  return KernelSignature(
-      "fmin_grad", {"X", "Y", "Out@GRAD"}, {}, {"X@GRAD", "Y@GRAD"});
-}
-
 KernelSignature ElementwiseDivDoubleGradOpArgumentMapping(
     const ArgumentMappingContext& ctx UNUSED) {
   return KernelSignature("divide_double_grad",
@@ -209,12 +206,6 @@ KernelSignature ElementwiseMulTripleGradOpArgumentMapping(
       {"D_X", "D_Y", "D_DOut", "D_DDX", "D_DDY"});
 }
 
-KernelSignature ElementwiseMinGradOpArgumentMapping(
-    const ArgumentMappingContext& ctx UNUSED) {
-  return KernelSignature(
-      "minimum_grad", {"X", "Y", "Out@GRAD"}, {}, {"X@GRAD", "Y@GRAD"});
-}
-
 }  // namespace phi
 
 PD_REGISTER_BASE_KERNEL_NAME(elementwise_add, add);
@@ -237,8 +228,6 @@ PD_REGISTER_BASE_KERNEL_NAME(elementwise_mul_grad_grad, multiply_double_grad);
 PD_REGISTER_BASE_KERNEL_NAME(elementwise_mul_triple_grad, multiply_triple_grad);
 PD_REGISTER_BASE_KERNEL_NAME(elementwise_fmax, fmax);
 PD_REGISTER_BASE_KERNEL_NAME(elementwise_fmin, fmin);
-PD_REGISTER_BASE_KERNEL_NAME(elementwise_fmin_grad, fmin_grad);
-PD_REGISTER_BASE_KERNEL_NAME(elementwise_min_grad, minimum_grad);
 
 PD_REGISTER_ARG_MAPPING_FN(elementwise_add,
                            phi::ElementwiseAddOpArgumentMapping);
@@ -282,8 +271,4 @@ PD_REGISTER_ARG_MAPPING_FN(elementwise_fmax,
                            phi::ElementwiseFMaxOpArgumentMapping);
 PD_REGISTER_ARG_MAPPING_FN(elementwise_fmin,
                            phi::ElementwiseFMinOpArgumentMapping);
-PD_REGISTER_ARG_MAPPING_FN(elementwise_fmin_grad,
-                           phi::ElementwiseFMinGradOpArgumentMapping);
-PD_REGISTER_ARG_MAPPING_FN(elementwise_min_grad,
-                           phi::ElementwiseMinGradOpArgumentMapping);
 PD_REGISTER_ARG_MAPPING_FN(grad_add, phi::ElementwiseGradAddOpArgumentMapping);
