PaddlePaddle
diff --git a/‎paddle/fluid/prim/api/composite_backward/composite_backward_api.h
Copy file name to clipboard
+18Lines changed: 18 additions & 0 deletions b/‎paddle/fluid/prim/api/composite_backward/composite_backward_api.h
Copy file name to clipboard
+18Lines changed: 18 additions & 0 deletions
diff --git a/‎paddle/fluid/primitive/decomp_rule/decomp_vjp/details.h
Copy file name to clipboard
+18Lines changed: 18 additions & 0 deletions b/‎paddle/fluid/primitive/decomp_rule/decomp_vjp/details.h
Copy file name to clipboard
+18Lines changed: 18 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/cpu/elementwise_grad_kernel.cc
Copy file name to clipboard
+39Lines changed: 39 additions & 0 deletions b/‎paddle/phi/kernels/cpu/elementwise_grad_kernel.cc
Copy file name to clipboard
+39Lines changed: 39 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/cpu/mean_all_grad_kernel.cc
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions b/‎paddle/phi/kernels/cpu/mean_all_grad_kernel.cc
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/cpu/mean_all_kernel.cc
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions b/‎paddle/phi/kernels/cpu/mean_all_kernel.cc
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/cpu/reduce_mean_grad_kernel.cc
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎paddle/phi/kernels/cpu/reduce_mean_grad_kernel.cc
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/cpu/reduce_mean_kernel.cc
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions b/‎paddle/phi/kernels/cpu/reduce_mean_kernel.cc
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/gpu/elementwise_grad_kernel.cu
Copy file name to clipboard
+40Lines changed: 40 additions & 0 deletions b/‎paddle/phi/kernels/gpu/elementwise_grad_kernel.cu
Copy file name to clipboard
+40Lines changed: 40 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/gpu/mean_all_grad_kernel.cu
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions b/‎paddle/phi/kernels/gpu/mean_all_grad_kernel.cu
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions
diff --git a/‎paddle/phi/kernels/gpu/mean_all_kernel.cu
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions b/‎paddle/phi/kernels/gpu/mean_all_kernel.cu
Copy file name to clipboard
+6Lines changed: 6 additions & 0 deletions
@@ -1413,6 +1413,15 @@ void maximum_grad(const Tensor& x,
                   const Tensor& out_grad,
                   Tensor* x_grad,
                   Tensor* y_grad) {
+  if (out_grad.numel() == 0) {
+    if (x_grad) {
+      set_output<T>(full<T>(x.shape(), 0, x.dtype(), x.place()), x_grad);
+    }
+    if (y_grad) {
+      set_output<T>(full<T>(y.shape(), 0, y.dtype(), y.place()), y_grad);
+    }
+    return;
+  }
   Tensor half_tensor;
   Tensor out_grad_copy = out_grad;
   if (x_grad || y_grad) {
@@ -1920,6 +1929,15 @@ void minimum_grad(const Tensor& x,
                   const Tensor& out_grad,
                   Tensor* x_grad,
                   Tensor* y_grad) {
+  if (out_grad.numel() == 0) {
+    if (x_grad) {
+      set_output<T>(full<T>(x.shape(), 0, x.dtype(), x.place()), x_grad);
+    }
+    if (y_grad) {
+      set_output<T>(full<T>(y.shape(), 0, y.dtype(), y.place()), y_grad);
+    }
+    return;
+  }
   Tensor half_tensor;
   Tensor out_grad_copy = out_grad;
   if (x_grad || y_grad) {
 
@@ -1217,6 +1217,15 @@ void maximum_grad(const Tensor& x,
                   const Tensor& out_grad,
                   Tensor* x_grad,
                   Tensor* y_grad) {
+  if (out_grad.numel() == 0) {
+    if (x_grad) {
+      set_output<T>(full<T>(x.shape(), 0, x.dtype(), x.place()), x_grad);
+    }
+    if (y_grad) {
+      set_output<T>(full<T>(y.shape(), 0, y.dtype(), y.place()), y_grad);
+    }
+    return;
+  }
   Tensor half_tensor;
   Tensor out_grad_copy = out_grad;
   if (x_grad || y_grad) {
@@ -2265,6 +2274,15 @@ void minimum_grad(const Tensor& x,
                   const Tensor& out_grad,
                   Tensor* x_grad,
                   Tensor* y_grad) {
+  if (out_grad.numel() == 0) {
+    if (x_grad) {
+      set_output<T>(full<T>(x.shape(), 0, x.dtype(), x.place()), x_grad);
+    }
+    if (y_grad) {
+      set_output<T>(full<T>(y.shape(), 0, y.dtype(), y.place()), y_grad);
+    }
+    return;
+  }
   Tensor half_tensor;
   Tensor out_grad_copy = out_grad;
   if (x_grad || y_grad) {
 
@@ -18,6 +18,7 @@
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/core/tensor_utils.h"
 #include "paddle/phi/kernels/cpu/elementwise_grad.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/elementwise_functor.h"
 #include "paddle/phi/kernels/impl/elementwise_grad_kernel_impl.h"
 
@@ -30,6 +31,25 @@ void MaximumGradKernel(const Context& dev_ctx,
                        const DenseTensor& dout,
                        DenseTensor* dx,
                        DenseTensor* dy) {
+  if (dout.numel() == 0) {
+    if (dx) {
+      if (dx->numel() == 0) {
+        dev_ctx.template Alloc<T>(dx);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dx->dims())), 0, dx);
+      }
+    }
+    if (dy) {
+      if (dy->numel() == 0) {
+        dev_ctx.template Alloc<T>(dy);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dy->dims())), 0, dy);
+      }
+    }
+    return;
+  }
   funcs::ElementwiseGradPreProcess(dout, dx);
   int axis = -1;
   phi::funcs::ElemwiseGradCompute<Context, T, MaxGradDx<T>, MaxGradDy<T>>(
@@ -43,6 +63,25 @@ void MinimumGradKernel(const Context& dev_ctx,
                        const DenseTensor& dout,
                        DenseTensor* dx,
                        DenseTensor* dy) {
+  if (dout.numel() == 0) {
+    if (dx) {
+      if (dx->numel() == 0) {
+        dev_ctx.template Alloc<T>(dx);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dx->dims())), 0, dx);
+      }
+    }
+    if (dy) {
+      if (dy->numel() == 0) {
+        dev_ctx.template Alloc<T>(dy);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dy->dims())), 0, dy);
+      }
+    }
+    return;
+  }
   funcs::ElementwiseGradPreProcess(dout, dx);
   int axis = -1;
   phi::funcs::ElemwiseGradCompute<Context, T, MinGradDx<T>, MinGradDy<T>>(
 
@@ -24,6 +24,11 @@ void MeanAllGradKernel(const Context& dev_ctx,
                        const DenseTensor& x UNUSED,
                        const DenseTensor& out_grad,
                        DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
+
   PADDLE_ENFORCE_EQ(out_grad.numel(),
                     1UL,
                     common::errors::InvalidArgument(
 
@@ -15,6 +15,7 @@
 #include "paddle/phi/kernels/mean_all_kernel.h"
 
 #include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/eigen/common.h"
 
 namespace phi {
@@ -23,6 +24,11 @@ template <typename T, typename Context>
 void MeanAllKernel(const Context& dev_ctx,
                    const DenseTensor& x,
                    DenseTensor* out) {
+  if (x.numel() == 0) {
+    phi::Full<T, Context>(
+        dev_ctx, phi::IntArray(common::vectorize(out->dims())), NAN, out);
+    return;
+  }
   dev_ctx.template Alloc<T>(out);
 
   auto X = EigenVector<T>::Flatten(x);
 
@@ -28,6 +28,10 @@ void ReduceMeanGradKernel(const Context& dev_ctx,
                           bool keep_dim,
                           bool reduce_all,
                           DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
   reduce_all = recompute_reduce_all(x, dims, reduce_all);
   ReduceGradKernel<Context, T, funcs::MeanGradFunctor, true>(dev_ctx,
                                                              x,
 
@@ -17,6 +17,7 @@
 #include "paddle/phi/backends/cpu/cpu_context.h"
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/kernels/cpu/reduce.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/reduce_functor.h"
 
 namespace phi {
@@ -28,6 +29,17 @@ void MeanRawKernel(const Context& dev_ctx,
                    bool keep_dim,
                    bool reduce_all,
                    DenseTensor* out) {
+  if (out && out->numel() == 0) {
+    dev_ctx.template Alloc<T>(out);
+    return;
+  }
+
+  if (x.numel() == 0 && out && out->dims().size() == 0) {
+    phi::Full<T, Context>(
+        dev_ctx, phi::IntArray(common::vectorize(out->dims())), NAN, out);
+    return;
+  }
+
   reduce_all = recompute_reduce_all(x, dims, reduce_all);
   auto out_dtype = x.dtype();
   phi::Reduce<CPUContext, T, phi::funcs::MeanFunctor>(
 
@@ -23,6 +23,7 @@
 #include "paddle/phi/common/float16.h"
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/core/tensor_utils.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/elementwise_functor.h"
 #include "paddle/phi/kernels/gpu/elementwise_grad.h"
 #include "paddle/phi/kernels/impl/elementwise_grad_kernel_impl.h"
@@ -157,6 +158,25 @@ void MaximumGradKernel(const Context& dev_ctx,
                        const DenseTensor& dout,
                        DenseTensor* dx,
                        DenseTensor* dy) {
+  if (dout.numel() == 0) {
+    if (dx) {
+      if (dx->numel() == 0) {
+        dev_ctx.template Alloc<T>(dx);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dx->dims())), 0, dx);
+      }
+    }
+    if (dy) {
+      if (dy->numel() == 0) {
+        dev_ctx.template Alloc<T>(dy);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dy->dims())), 0, dy);
+      }
+    }
+    return;
+  }
   const auto place = dev_ctx.GetPlace();
   int axis = -1;
   if (dx != nullptr && dy != nullptr) {
@@ -187,6 +207,26 @@ void MinimumGradKernel(const Context& dev_ctx,
                        const DenseTensor& dout,
                        DenseTensor* dx,
                        DenseTensor* dy) {
+  if (dout.numel() == 0) {
+    if (dx) {
+      if (dx->numel() == 0) {
+        dev_ctx.template Alloc<T>(dx);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dx->dims())), 0, dx);
+      }
+    }
+    if (dy) {
+      if (dy->numel() == 0) {
+        dev_ctx.template Alloc<T>(dy);
+      } else {
+        phi::Full<T, Context>(
+            dev_ctx, phi::IntArray(common::vectorize(dy->dims())), 0, dy);
+      }
+    }
+    return;
+  }
+
   const auto place = dev_ctx.GetPlace();
   int axis = -1;
   if (dx != nullptr && dy != nullptr) {
 
@@ -33,6 +33,11 @@ void MeanAllGradKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& out_grad,
                        DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
+
   PADDLE_ENFORCE_EQ(out_grad.numel(),
                     1,
                     common::errors::InvalidArgument(
 
@@ -16,6 +16,7 @@
 
 #include "paddle/phi/common/memory_utils.h"
 #include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/reduce_function.h"
 #include "paddle/phi/kernels/primitive/functor_primitives.h"
 
@@ -25,6 +26,11 @@ template <typename T, typename Context>
 void MeanAllKernel(const Context& dev_ctx,
                    const DenseTensor& x,
                    DenseTensor* out) {
+  if (x.numel() == 0) {
+    phi::Full<T, Context>(
+        dev_ctx, phi::IntArray(common::vectorize(out->dims())), NAN, out);
+    return;
+  }
   const T* in_data = x.data<T>();
   T* out_data = dev_ctx.template Alloc<T>(out);
   auto numel = x.numel();