Delete axis of fmin kernel (#50358)

* delete axis of fmin

* fix bug

paddle/phi/api/yaml/legacy_backward.yaml

@@ -515,7 +515,7 @@
 
 - backward_op : fmin_grad
   forward : fmin(Tensor x, Tensor y) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
+  args : (Tensor x, Tensor y, Tensor out_grad)
   output : Tensor(x_grad), Tensor(y_grad)
   infer_meta :
     func : GeneralBinaryGradInferMeta

paddle/phi/kernels/cpu/elementwise_kernel.cc

@@ -131,14 +131,8 @@ PD_REGISTER_KERNEL(fmax_raw,
                    int,
                    int64_t) {}
 
-PD_REGISTER_KERNEL(fmin_raw,
-                   CPU,
-                   ALL_LAYOUT,
-                   phi::FMinRawKernel,
-                   float,
-                   double,
-                   int,
-                   int64_t) {}
+PD_REGISTER_KERNEL(
+    fmin, CPU, ALL_LAYOUT, phi::FMinKernel, float, double, int, int64_t) {}
 
 PD_REGISTER_KERNEL(maximum_raw,
                    CPU,

paddle/phi/kernels/elementwise_grad_kernel.h

@@ -33,7 +33,6 @@ void ElementwiseFMinGradKernel(const Context& dev_ctx,
                                const DenseTensor& x,
                                const DenseTensor& y,
                                const DenseTensor& out_grad,
-                               int axis,
                                DenseTensor* x_grad,
                                DenseTensor* y_grad);
 

paddle/phi/kernels/elementwise_kernel.cc

@@ -118,14 +118,6 @@ void FMaxKernel(const Context& dev_ctx,
   FMaxRawKernel<T, Context>(dev_ctx, x, y, -1, out);
 }
 
-template <typename T, typename Context>
-void FMinKernel(const Context& dev_ctx,
-                const DenseTensor& x,
-                const DenseTensor& y,
-                DenseTensor* out) {
-  FMinRawKernel<T, Context>(dev_ctx, x, y, -1, out);
-}
-
 }  // namespace phi
 using complex64 = ::phi::dtype::complex<float>;
 using complex128 = ::phi::dtype::complex<double>;
@@ -133,9 +125,6 @@ using complex128 = ::phi::dtype::complex<double>;
 PD_REGISTER_KERNEL(
     fmax, CPU, ALL_LAYOUT, phi::FMaxKernel, float, double, int, int64_t) {}
 
-PD_REGISTER_KERNEL(
-    fmin, CPU, ALL_LAYOUT, phi::FMinKernel, float, double, int, int64_t) {}
-
 PD_REGISTER_KERNEL(maximum,
                    CPU,
                    ALL_LAYOUT,
@@ -242,16 +231,6 @@ PD_REGISTER_KERNEL(fmax,
                    phi::dtype::float16,
                    int64_t) {}
 
-PD_REGISTER_KERNEL(fmin,
-                   KPS,
-                   ALL_LAYOUT,
-                   phi::FMinKernel,
-                   float,
-                   double,
-                   int,
-                   phi::dtype::float16,
-                   int64_t) {}
-
 PD_REGISTER_KERNEL(maximum,
                    KPS,
                    ALL_LAYOUT,

paddle/phi/kernels/elementwise_kernel.h

@@ -32,13 +32,6 @@ void FMaxKernel(const Context& dev_ctx,
                 const DenseTensor& y,
                 DenseTensor* out);
 
-template <typename T, typename Context>
-void FMinRawKernel(const Context& dev_ctx,
-                   const DenseTensor& x,
-                   const DenseTensor& y,
-                   int axis,
-                   DenseTensor* out);
-
 template <typename T, typename Context>
 void FMinKernel(const Context& dev_ctx,
                 const DenseTensor& x,

paddle/phi/kernels/impl/elementwise_grad_kernel_impl.h

@@ -314,13 +314,13 @@ void ElementwiseFMinGradKernel(const Context& dev_ctx,
                                const DenseTensor& x,
                                const DenseTensor& y,
                                const DenseTensor& out_grad,
-                               int axis,
                                DenseTensor* x_grad,
                                DenseTensor* y_grad) {
   funcs::ElementwiseGradPreProcess(out_grad, x_grad);
   auto out = out_grad;  // Fake out, not used
   auto x_dim = x.dims();
   auto y_dim = y.dims();
+  int axis = -1;
   if (x.dims() == y.dims()) {
     funcs::ElemwiseGradComputeNoBroadcast<Context,
                                           T,

paddle/phi/kernels/impl/elementwise_kernel_impl.h

@@ -78,14 +78,13 @@ void FMaxRawKernel(const Context& dev_ctx,
 }
 
 template <typename T, typename Context>
-void FMinRawKernel(const Context& dev_ctx,
-                   const DenseTensor& x,
-                   const DenseTensor& y,
-                   int axis,
-                   DenseTensor* out) {
+void FMinKernel(const Context& dev_ctx,
+                const DenseTensor& x,
+                const DenseTensor& y,
+                DenseTensor* out) {
   dev_ctx.template Alloc<T>(out);
   funcs::ElementwiseCompute<funcs::FMinFunctor<T>, T, T>(
-      dev_ctx, x, y, axis, funcs::FMinFunctor<T>(), out);
+      dev_ctx, x, y, -1, funcs::FMinFunctor<T>(), out);
 }
 
 }  // namespace phi

paddle/phi/kernels/kps/elementwise_kernel.cu

@@ -103,10 +103,10 @@ PD_REGISTER_KERNEL(fmax_raw,
                    float16,
                    int64_t) {}
 
-PD_REGISTER_KERNEL(fmin_raw,
+PD_REGISTER_KERNEL(fmin,
                    KPS,
                    ALL_LAYOUT,
-                   phi::FMinRawKernel,
+                   phi::FMinKernel,
                    float,
                    double,
                    int,

paddle/phi/ops/compat/elementwise_sig.cc

@@ -162,7 +162,7 @@ KernelSignature ElementwiseDivGradOpArgumentMapping(
 KernelSignature ElementwiseFMinGradOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
   return KernelSignature(
-      "fmin_grad", {"X", "Y", "Out@GRAD"}, {"axis"}, {"X@GRAD", "Y@GRAD"});
+      "fmin_grad", {"X", "Y", "Out@GRAD"}, {}, {"X@GRAD", "Y@GRAD"});
 }
 
 KernelSignature ElementwiseDivDoubleGradOpArgumentMapping(
@@ -186,7 +186,7 @@ KernelSignature ElementwiseFMaxOpArgumentMapping(
 
 KernelSignature ElementwiseFMinOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
-  return KernelSignature("fmin_raw", {"X", "Y"}, {"axis"}, {"Out"});
+  return KernelSignature("fmin", {"X", "Y"}, {}, {"Out"});
 }
 
 KernelSignature ElementwiseFMaxGradOpArgumentMapping(