[0-size Tensor No.132、236、240、241、259] Add 0-size Tensor support for masked_select (#73180)

co63oc · web-flow · commit cab6cd26d288 · 2025-06-16T17:23:35.000+08:00
* Fix

* Fix

* Fix

* Fix

* Fix
diff --git a/paddle/phi/kernels/gpu/masked_select_grad_kernel.cu b/paddle/phi/kernels/gpu/masked_select_grad_kernel.cu
@@ -24,10 +24,10 @@
 #include "paddle/phi/kernels/empty_kernel.h"
 #include "paddle/phi/kernels/expand_grad_kernel.h"
 #include "paddle/phi/kernels/expand_kernel.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/common_shape.h"
 #include "paddle/phi/kernels/funcs/reduce_function.h"
 #include "paddle/phi/kernels/funcs/select_impl.cu.h"
-
 namespace phi {
 
 template <typename MT, typename InT, typename OutT>
@@ -55,6 +55,12 @@ void MaskedSelectGradKernel(const Context& dev_ctx,
                             const DenseTensor& mask,
                             const DenseTensor& out_grad,
                             DenseTensor* x_grad) {
+  if (out_grad.numel() == 0 && x_grad) {
+    // x = [1, 2], mask = [False, False], out = [], x_grad = [0, 0]
+    phi::Full<T, Context>(
+        dev_ctx, phi::IntArray(common::vectorize(x_grad->dims())), 0, x_grad);
+    return;
+  }
   // x_grad.size() == x.size()
   // x.size() == mask.size(), no broadcast, expand_mask = false, expand_x =
   // false x.size() < mask.size(), x broadcast to mask, expand_mask = false,
diff --git a/test/legacy_test/test_masked_select_op.py b/test/legacy_test/test_masked_select_op.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import unittest
 
 import numpy as np
@@ -24,9 +25,10 @@
 def np_masked_select(x, mask):
     result = np.empty(shape=(0), dtype=x.dtype)
     x, mask = np.broadcast_arrays(x, mask)
-    for ele, ma in zip(np.nditer(x), np.nditer(mask)):
-        if ma:
-            result = np.append(result, ele)
+    if x.size != 0:
+        for ele, ma in zip(np.nditer(x), np.nditer(mask)):
+            if ma:
+                result = np.append(result, ele)
     return result.flatten()
 
 
@@ -280,6 +282,46 @@ def init(self):
         self.mask_shape = 40
 
 
+class TestMaskedSelectOpBroadcast_ZeroSize(TestMaskedSelectOp):
+    def init(self):
+        self.shape = (0, 40)
+        self.mask_shape = 40
+
+
+class TestMaskedSelectOpBroadcast_ZeroSize2(TestMaskedSelectOp):
+    def init(self):
+        self.shape = (0, 0)
+        self.mask_shape = 0
+
+
+class TestMaskedSelectOp_ZeroSize3(unittest.TestCase):
+    def setUp(self):
+        self.place = []
+        if (
+            os.environ.get('FLAGS_CI_both_cpu_and_gpu', 'False').lower()
+            in ['1', 'true', 'on']
+            or not core.is_compiled_with_cuda()
+        ):
+            self.place.append(paddle.CPUPlace())
+        if core.is_compiled_with_cuda():
+            self.place.append(paddle.CUDAPlace(0))
+
+    def _test_out_0size(self, place):
+        paddle.disable_static(place)
+        x = paddle.to_tensor([1, 2], dtype='float32')
+        x.stop_gradient = False
+        y = paddle.to_tensor([False, False], dtype='bool')
+        z = x.masked_select(y)
+        np.testing.assert_allclose(z.shape, [0])
+        z.sum().backward()
+        np.testing.assert_allclose(x.grad.numpy(), [0, 0])
+        paddle.enable_static()
+
+    def test_out_0size(self):
+        for place in self.place:
+            self._test_out_0size(place)
+
+
 if __name__ == '__main__':
     paddle.enable_static()
     unittest.main()
diff --git a/test/legacy_test/test_parameter.py b/test/legacy_test/test_parameter.py
@@ -136,6 +136,19 @@ def test_parambase_to_vector(self):
             self.assertTrue(linear2.weight.is_leaf, True)
             self.assertTrue(linear2.bias.is_leaf, True)
 
+    def test_parambase_to_vector_zero(self):
+        with guard():
+            initializer = paddle.ParamAttr(
+                initializer=paddle.nn.initializer.Constant(3.0)
+            )
+            linear1 = paddle.nn.Linear(0, 15, initializer)
+
+            vec = paddle.nn.utils.parameters_to_vector(linear1.parameters())
+            self.assertEqual(linear1.weight.shape, [0, 15])
+            self.assertEqual(linear1.bias.shape, [15])
+            self.assertTrue(isinstance(vec, Variable))
+            self.assertEqual(vec.shape, [15])
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/legacy_test/test_pdist.py b/test/legacy_test/test_pdist.py
@@ -117,6 +117,41 @@ def test_error(self):
             )
 
 
+class TestPdistAPI_ZeroSize(unittest.TestCase):
+    def setUp(self):
+        self.init_shape()
+        self.x = np.random.rand(*self.shape).astype('float32')
+        self.p = 2.0
+        self.place = (
+            paddle.CUDAPlace(0)
+            if paddle.is_compiled_with_cuda()
+            else paddle.CPUPlace()
+        )
+
+    def init_shape(self):
+        self.shape = (0, 20)
+
+    def test_dygraph_api(self):
+        paddle.disable_static(self.place)
+        x = paddle.to_tensor(self.x)
+        x.stop_gradient = False
+        out = paddle.pdist(
+            x,
+            self.p,
+        )
+        out_ref = ref_pdist(self.x, self.p)
+        np.testing.assert_allclose(out_ref, out.numpy(), rtol=1e-5, atol=1e-5)
+        loss = paddle.sum(out)
+        loss.backward()
+        np.testing.assert_allclose(x.grad.shape, x.shape)
+        paddle.enable_static()
+
+
+class TestPdistAPI_ZeroSize2(TestPdistAPI_ZeroSize):
+    def init_shape(self):
+        self.shape = (0, 0)
+
+
 if __name__ == '__main__':
     paddle.enable_static()
     unittest.main()
diff --git a/test/legacy_test/test_polar.py b/test/legacy_test/test_polar.py
@@ -106,5 +106,47 @@ def test_empty_input_error(self):
             self.assertRaises(AttributeError, paddle.polar, abs, None)
 
 
+class TestPolarAPI_ZeroSize(unittest.TestCase):
+    def init_input(self):
+        self.abs = np.random.random([0, 2])
+        self.angle = np.array([np.pi / 2, 5 * np.pi / 4]).astype("float64")
+
+    def setUp(self):
+        self.init_input()
+        self.place = []
+        if (
+            os.environ.get('FLAGS_CI_both_cpu_and_gpu', 'False').lower()
+            in ['1', 'true', 'on']
+            or not core.is_compiled_with_cuda()
+        ):
+            self.place.append(paddle.CPUPlace())
+        if core.is_compiled_with_cuda():
+            self.place.append(paddle.CUDAPlace(0))
+
+    def test_api_dygraph(self):
+        def run(place):
+            paddle.disable_static(place)
+            abs = paddle.to_tensor(self.abs)
+            abs.stop_gradient = False
+            angle = paddle.to_tensor(self.angle)
+            out1 = paddle.polar(abs, angle)
+
+            out_ref1 = numpy_polar(self.abs, self.angle)
+            np.testing.assert_allclose(out_ref1, out1.numpy(), rtol=1e-05)
+            loss = paddle.sum(out1)
+            loss.backward()
+            np.testing.assert_allclose(abs.grad.shape, abs.shape)
+            paddle.enable_static()
+
+        for place in self.place:
+            run(place)
+
+
+class TestPolarAPI_ZeroSize2(TestPolarAPI_ZeroSize):
+    def init_input(self):
+        self.abs = np.random.random([0, 0])
+        self.angle = np.random.random([0, 1])
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/legacy_test/test_sinc.py b/test/legacy_test/test_sinc.py
@@ -364,5 +364,43 @@ def run(place):
         run(self.place)
 
 
+class TestSincAPI_ZeroSize(unittest.TestCase):
+    def setUp(self):
+        self.support_dtypes = [
+            'float32',
+            'float64',
+        ]
+        self.place = []
+        if (
+            os.environ.get('FLAGS_CI_both_cpu_and_gpu', 'False').lower()
+            in ['1', 'true', 'on']
+            or not core.is_compiled_with_cuda()
+        ):
+            self.place.append(paddle.CPUPlace())
+        if core.is_compiled_with_cuda():
+            self.place.append(paddle.CUDAPlace(0))
+        self.shapes = [[0], [16, 0]]
+
+    def test_dygraph(self):
+        def run_dygraph(place):
+            paddle.disable_static(place)
+            for dtype in self.support_dtypes:
+                for shape in self.shapes:
+                    x_data = np.random.rand(*shape).astype(dtype)
+                    x = paddle.to_tensor(x_data)
+                    x.stop_gradient = False
+                    out = paddle.sinc(x)
+                    out_expected = np_sinc(x_data)
+                    np.testing.assert_allclose(
+                        out.numpy(), out_expected, rtol=1e-6, atol=1e-6
+                    )
+                    loss = paddle.sum(out)
+                    loss.backward()
+                    np.testing.assert_allclose(x.grad.shape, x.shape)
+
+        for place in self.place:
+            run_dygraph(place)
+
+
 if __name__ == "__main__":
     unittest.main()
