[0-size Tensor No.200、210、345、356、267、338] Add 0-size Tensor support for prelu/maxout/var (#73044)

co63oc · web-flow · commit db92e25dfe5a · 2025-06-06T11:38:07.000+08:00
diff --git a/paddle/phi/kernels/cpu/prelu_grad_kernel.cc b/paddle/phi/kernels/cpu/prelu_grad_kernel.cc
@@ -16,7 +16,7 @@
 
 #include "paddle/phi/backends/cpu/cpu_context.h"
 #include "paddle/phi/core/kernel_registry.h"
-
+#include "paddle/phi/kernels/full_kernel.h"
 namespace phi {
 
 template <typename T, typename Context>
@@ -28,6 +28,17 @@ void PReluGradKernel(const Context& dev_ctx,
                      const std::string& mode,
                      DenseTensor* x_grad,
                      DenseTensor* alpha_grad) {
+  if (x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    if (alpha_grad) {
+      phi::Full<T, Context>(
+          dev_ctx,
+          phi::IntArray(common::vectorize(alpha_grad->dims())),
+          0,
+          alpha_grad);
+    }
+    return;
+  }
   const T* alpha_ptr = alpha.data<T>();
   const T* x_ptr = x.data<T>();
   const T* out_grad_ptr = out_grad.data<T>();
diff --git a/paddle/phi/kernels/cpu/prelu_kernel.cc b/paddle/phi/kernels/cpu/prelu_kernel.cc
@@ -29,6 +29,9 @@ void PReluKernel(const Context& dev_ctx,
   const T* x_ptr = x.data<T>();
   const T* alpha_ptr = alpha.data<T>();
   T* o_ptr = dev_ctx.template Alloc<T>(out);
+  if (out && out->numel() == 0) {
+    return;
+  }
 
   int numel = static_cast<int>(x.numel());
   auto dim = x.dims();
diff --git a/paddle/phi/kernels/gpu/prelu_grad_kernel.cu b/paddle/phi/kernels/gpu/prelu_grad_kernel.cu
@@ -18,10 +18,10 @@
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/core/tensor_meta.h"
 #include "paddle/phi/kernels/empty_kernel.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/reduce_function.h"
 #include "paddle/phi/kernels/gpu/prelu_funcs.h"
 #include "paddle/phi/kernels/primitive/functor_primitives.h"
-
 namespace phi {
 
 enum PRELU_MODE { Element, ChannelFirst, ChannelLast, PRELU_Scalar };
@@ -117,7 +117,16 @@ void PReluGradKernel(const Context& dev_ctx,
                      DenseTensor* x_grad,
                      DenseTensor* alpha_grad) {
   dev_ctx.template Alloc<T>(x_grad);
-
+  if (x_grad->numel() == 0) {
+    if (alpha_grad) {
+      phi::Full<T, Context>(
+          dev_ctx,
+          phi::IntArray(common::vectorize(alpha_grad->dims())),
+          0,
+          alpha_grad);
+    }
+    return;
+  }
   const T* x_ptr = x.data<T>();
   const T* alpha_ptr = alpha.data<T>();
   const T* out_grad_ptr = out_grad.data<T>();
diff --git a/paddle/phi/kernels/gpu/prelu_kernel.cu b/paddle/phi/kernels/gpu/prelu_kernel.cu
@@ -32,6 +32,9 @@ void PReluKernel(const Context& dev_ctx,
                  const std::string& mode,
                  DenseTensor* out) {
   dev_ctx.template Alloc<T>(out);
+  if (out && out->numel() == 0) {
+    return;
+  }
   const T* x_ptr = x.data<T>();
   const T* alpha_ptr = alpha.data<T>();
 
diff --git a/paddle/phi/kernels/impl/maxout_grad_kernel_impl.h b/paddle/phi/kernels/impl/maxout_grad_kernel_impl.h
@@ -28,6 +28,10 @@ void MaxOutGradKernel(const Context& dev_ctx,
                       int groups,
                       int axis,
                       DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
   if (axis < 0) {
     axis += x.dims().size();
   }
diff --git a/paddle/phi/kernels/impl/maxout_kernel_impl.h b/paddle/phi/kernels/impl/maxout_kernel_impl.h
@@ -25,6 +25,10 @@ void MaxOutKernel(const Context& dev_ctx,
                   int groups,
                   int axis,
                   DenseTensor* out) {
+  if (out && out->numel() == 0) {
+    dev_ctx.template Alloc<T>(out);
+    return;
+  }
   if (axis < 0) {
     axis += x.dims().size();
   }
diff --git a/paddle/phi/kernels/onednn/prelu_grad_kernel.cc b/paddle/phi/kernels/onednn/prelu_grad_kernel.cc
@@ -16,7 +16,7 @@
 
 #include "paddle/phi/backends/onednn/onednn_reuse.h"
 #include "paddle/phi/core/kernel_registry.h"
-
+#include "paddle/phi/kernels/full_kernel.h"
 namespace phi {
 
 template <typename T, typename Context>
@@ -28,6 +28,16 @@ void PReluGradKernel(const Context& dev_ctx,
                      const std::string& mode,
                      DenseTensor* x_grad,
                      DenseTensor* alpha_grad) {
+  if (x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    if (alpha_grad) {
+      phi::Full<T, Context>(
+          dev_ctx,
+          phi::IntArray(common::vectorize(alpha_grad->dims())),
+          0,
+          alpha_grad);
+    }
+  }
   bool is_test = dev_ctx.HasDnnAttr("is_test")
                      ? PADDLE_GET_CONST(bool, dev_ctx.GetDnnAttr("is_test"))
                      : false;
diff --git a/paddle/phi/kernels/onednn/prelu_kernel.cc b/paddle/phi/kernels/onednn/prelu_kernel.cc
@@ -29,6 +29,10 @@ void PReluKernel(const Context& dev_ctx,
                     AllocationType::CPU,
                     common::errors::PreconditionNotMet(
                         "Operator oneDNN PReLU must use CPUPlace"));
+  if (out && out->numel() == 0) {
+    dev_ctx.template Alloc<T>(out);
+    return;
+  }
 
   bool is_test = dev_ctx.HasDnnAttr("is_test")
                      ? PADDLE_GET_CONST(bool, dev_ctx.GetDnnAttr("is_test"))
diff --git a/paddle/phi/kernels/xpu/prelu_grad_kernel.cc b/paddle/phi/kernels/xpu/prelu_grad_kernel.cc
@@ -16,7 +16,7 @@
 
 #include "paddle/phi/backends/xpu/enforce_xpu.h"
 #include "paddle/phi/core/kernel_registry.h"
-
+#include "paddle/phi/kernels/full_kernel.h"
 namespace phi {
 template <typename T, typename Context>
 void PReluGradKernel(const Context& dev_ctx,
@@ -28,7 +28,16 @@ void PReluGradKernel(const Context& dev_ctx,
                      DenseTensor* x_grad,
                      DenseTensor* alpha_grad) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-
+  if (x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    if (alpha_grad) {
+      phi::Full<T, Context>(
+          dev_ctx,
+          phi::IntArray(common::vectorize(alpha_grad->dims())),
+          0,
+          alpha_grad);
+    }
+  }
   const T* x_ptr = x.data<T>();
   const T* alpha_ptr = alpha.data<T>();
   const T* out_grad_ptr = out_grad.data<T>();
diff --git a/paddle/phi/kernels/xpu/prelu_kernel.cc b/paddle/phi/kernels/xpu/prelu_kernel.cc
@@ -31,6 +31,9 @@ void PReluKernel(const Context& dev_ctx,
   const T* alpha_ptr = alpha.data<T>();
 
   T* y_ptr = dev_ctx.template Alloc<T>(out);
+  if (out && out->numel() == 0) {
+    return;
+  }
 
   auto x_dim = x.dims();
   auto x_rank = x_dim.size();
diff --git a/python/paddle/tensor/stat.py b/python/paddle/tensor/stat.py
@@ -209,6 +209,14 @@ def var(
         n = n - 1.0
     n.stop_gradient = True
     out /= n
+
+    def _replace_nan(out):
+        out_nan = paddle.full_like(out, paddle.nan)
+        out_nan.stop_gradient = out.stop_gradient
+        return out_nan
+
+    if 0 in x.shape:
+        out = _replace_nan(out)
     if out.dtype != x.dtype:
         return out.astype(x.dtype)
     return out
diff --git a/test/legacy_test/test_maxout_op.py b/test/legacy_test/test_maxout_op.py
@@ -83,6 +83,11 @@ def set_attrs(self):
         self.groups = 3
 
 
+class TestMaxOutOp_ZeroSize(TestMaxOutOp):
+    def set_attrs(self):
+        self.shape = [3, 0, 2, 4]
+
+
 class TestMaxoutAPI(unittest.TestCase):
     # test paddle.nn.Maxout, paddle.nn.functional.maxout
     def setUp(self):
diff --git a/test/legacy_test/test_prelu_op.py b/test/legacy_test/test_prelu_op.py
@@ -379,6 +379,11 @@ def init_attr(self):
         self.attrs = {'mode': "element", "data_format": "NHWC"}
 
 
+class TestModeElt_ZeroSize(PReluTest):
+    def init_input_shape(self):
+        self.x_shape = [3, 0, 5, 10]
+
+
 def create_test_fp16_class(
     parent, check_grad=True, atol=1e-3, max_relative_error=0.05
 ):
diff --git a/test/legacy_test/test_variance_layer.py b/test/legacy_test/test_variance_layer.py
@@ -126,5 +126,15 @@ def test_error(self):
             self.assertRaises(TypeError, paddle.var, x)
 
 
+class TestVarAPI_ZeroSize(unittest.TestCase):
+    def test_zerosize(self):
+        paddle.disable_static()
+        x = paddle.to_tensor(np.random.random([10, 0]))
+        out1 = paddle.var(x).numpy()
+        out2 = np.var(x.numpy())
+        np.testing.assert_allclose(out1, out2, equal_nan=True)
+        paddle.enable_static()
+
+
 if __name__ == '__main__':
     unittest.main()
