[0-size Tensor No.1、275、283] Add 0-size Tensor support for paddle.abs、paddle.Tensor.__abs__、paddle.Tensor.abs API. (#72887)

DanielSun11 · web-flow · commit cedb8ca5867e · 2025-05-27T11:34:18.000+08:00
diff --git a/paddle/phi/kernels/onednn/activation_grad_kernel.cc b/paddle/phi/kernels/onednn/activation_grad_kernel.cc
@@ -116,6 +116,10 @@ struct OneDNNActivationGradFunc : public funcs::BaseActivationFunctor<T> {
                   float alpha,
                   float beta,
                   DenseTensor* dx) const {
+    if (dx && dx->numel() == 0) {
+      dev_ctx.template Alloc<T>(dx);
+      return;
+    }
     eltwise_grad<T>(dev_ctx, x, dout, alpha, beta, dx, algorithm);
   }
 };
@@ -128,6 +132,10 @@ struct OneDNNActivationGradUseOutFunc : public funcs::BaseActivationFunctor<T> {
                   float alpha,
                   float beta,
                   DenseTensor* dx) const {
+    if (dx && dx->numel() == 0) {
+      dev_ctx.template Alloc<T>(dx);
+      return;
+    }
     eltwise_grad_use_out<T>(dev_ctx, out, dout, alpha, beta, dx, algorithm);
   }
 };
diff --git a/paddle/phi/kernels/onednn/activation_kernel.cc b/paddle/phi/kernels/onednn/activation_kernel.cc
@@ -83,6 +83,10 @@ struct OneDNNActivationFunc : public funcs::BaseActivationFunctor<T> {
                   float alpha,
                   float beta,
                   DenseTensor* out) const {
+    if (out && out->numel() == 0) {
+      dev_ctx.template Alloc<T>(out);
+      return;
+    }
     EltwiseForward<T>(dev_ctx, x, alpha, beta, out, algorithm);
   }
 };
diff --git a/paddle/phi/kernels/xpu/abs_grad_kernel.cc b/paddle/phi/kernels/xpu/abs_grad_kernel.cc
@@ -26,6 +26,9 @@ void AbsGradKernel(const Context& ctx,
                    const DenseTensor& dout,
                    DenseTensor* dx) {
   ctx.template Alloc<T>(dx);
+  if (dx && dx->numel() == 0) {
+    return;
+  }
   using XPUType = typename XPUTypeTrait<T>::Type;
   int r = xpu::abs_grad(ctx.x_context(),
                         reinterpret_cast<const XPUType*>(x.data<T>()),
diff --git a/paddle/phi/kernels/xpu/abs_kernel.cc b/paddle/phi/kernels/xpu/abs_kernel.cc
@@ -22,6 +22,9 @@ namespace phi {
 template <typename T, typename Context>
 void AbsKernel(const Context& ctx, const DenseTensor& x, DenseTensor* out) {
   ctx.template Alloc<T>(out);
+  if (out->numel() == 0) {
+    return;
+  }
   using XPUType = typename XPUTypeTrait<T>::Type;
   int r = xpu::abs<XPUType>(ctx.x_context(),
                             reinterpret_cast<const XPUType*>(x.data<T>()),
diff --git a/test/deprecated/mkldnn/test_activation_mkldnn_op_deprecated.py b/test/deprecated/mkldnn/test_activation_mkldnn_op_deprecated.py
@@ -222,6 +222,26 @@ def init_dtype(self):
         self.dtype = np.float32
 
 
+class TestMKLDNNAbsZeroSize(TestAbs):
+    def setUp(self):
+        super().setUp()
+        self.check_pir_onednn = True
+        self.attrs = {"use_mkldnn": True}
+
+    def init_shape(self):
+        self.shape = [0, 12, 0]
+
+
+class TestMKLDNNAbsZeroSize1(TestMKLDNNAbsZeroSize):
+    def setUp(self):
+        super().setUp()
+        self.check_pir_onednn = True
+        self.attrs = {"use_mkldnn": True}
+
+    def init_shape(self):
+        self.shape = [0, 12, 0]
+
+
 class TestMKLDNNAbs_ZeroDim(TestAbs_ZeroDim):
     def setUp(self):
         super().setUp()
diff --git a/test/xpu/test_activation_op_xpu.py b/test/xpu/test_activation_op_xpu.py
@@ -450,6 +450,34 @@ def set_case(self):
     create_test_class(globals(), XPUTestAbsOP, stype)
 
 
+class XPUTestAbsOPZeroSize(XPUOpTestWrapper):
+    def __init__(self):
+        self.op_name = 'abs'
+        self.use_dynamic_create_class = False
+
+    class XPUTestAbsZeroSize(TestActivationOPBase):
+        def set_case(self):
+            self.op_type = "abs"
+            self.dtype = self.in_type
+
+            x = np.random.uniform(-1, 1, [0, 25]).astype(self.dtype)
+            # Because we set delta = 0.005 in calculating numeric gradient,
+            # if x is too small, such as 0.002, x_neg will be -0.003
+            # x_pos will be 0.007, so the numeric gradient is inaccurate.
+            # we should avoid this
+            x[np.abs(x) < 0.005] = 0.02
+            out = np.abs(x)
+
+            self.attrs = {'use_xpu': True}
+            self.inputs = {'X': OpTest.np_dtype_to_base_dtype(x)}
+            self.outputs = {'Out': out}
+
+
+support_types = get_xpu_op_support_types('abs')
+for stype in support_types:
+    create_test_class(globals(), XPUTestAbsOPZeroSize, stype)
+
+
 class XPUTestReluOP(XPUOpTestWrapper):
     def __init__(self):
         self.op_name = 'relu'
