Fix (#73176)

Author: co63oc

test/legacy_test/test_mse_loss.py

@@ -353,6 +353,31 @@ def test_NNFunctionalMseLoss_none(self):
             self.assertEqual(dy_result.shape, tuple(dim))
 
 
+class TestNNFunctionalMseLoss_ZeroSize(unittest.TestCase):
+
+    def test_dygraph_and_grad(self):
+        for dim in [[0, 0], [2, 0, 10]]:
+            input_np = np.random.uniform(0.1, 0.5, dim).astype("float32")
+            target_np = np.random.uniform(0.1, 0.5, dim).astype("float32")
+
+            paddle.disable_static()
+            x = paddle.to_tensor(input_np)
+            x.stop_gradient = False
+            dy_ret = paddle.nn.functional.mse_loss(
+                x, paddle.to_tensor(target_np), 'mean'
+            )
+            dy_result = dy_ret.numpy()
+
+            sub = input_np - target_np
+            expected = np.mean(sub * sub)
+            np.testing.assert_allclose(dy_result, expected, rtol=1e-05)
+            self.assertEqual(dy_result.shape, ())
+
+            loss = paddle.sum(dy_ret)
+            loss.backward()
+            np.testing.assert_allclose(x.grad.shape, x.shape)
+
+
 if __name__ == "__main__":
     paddle.enable_static()
     unittest.main()

test/legacy_test/test_poisson_nll_loss.py

@@ -243,5 +243,67 @@ def test_api(self):
         self.test_dynamic_case(reduction="sum")
 
 
+class TestPoissonNLLLossCase_ZeroSize(unittest.TestCase):
+    def init_shape(self):
+        self.shape = [0, 2]
+
+    def setUp(self, dtype="float32"):
+        self.init_shape()
+        self.dtype = dtype
+        self.input_np = np.random.random(self.shape).astype(self.dtype)
+        self.label_np = np.random.random(self.shape).astype(self.dtype)
+        self.place = (
+            paddle.CUDAPlace(0)
+            if core.is_compiled_with_cuda()
+            else paddle.CPUPlace()
+        )
+
+    def _test_dynamic_case_and_grad(
+        self,
+        dtype="float32",
+        log_input=True,
+        full=False,
+        epsilon=1e-8,
+        reduction="mean",
+    ):
+        self.setUp(dtype)
+        paddle.disable_static(self.place)
+
+        input_x = paddle.to_tensor(self.input_np)
+        input_x.stop_gradient = False
+        label = paddle.to_tensor(self.label_np)
+        out_ref = ref_poisson_nll_loss(
+            self.input_np,
+            self.label_np,
+            log_input=log_input,
+            full=full,
+            epsilon=epsilon,
+            reduction=reduction,
+        )
+        out1 = F.poisson_nll_loss(
+            input_x,
+            label,
+            log_input=log_input,
+            full=full,
+            epsilon=epsilon,
+            reduction=reduction,
+        )
+
+        np.allclose(out_ref, out1.numpy(), rtol=1e-5)
+
+        loss = paddle.sum(out1)
+        loss.backward()
+        np.testing.assert_allclose(input_x.grad.shape, input_x.shape)
+        paddle.enable_static()
+
+    def test_api(self):
+        self._test_dynamic_case_and_grad(reduction="sum")
+
+
+class TestPoissonNLLLossCase_ZeroSize2(TestPoissonNLLLossCase_ZeroSize):
+    def init_shape(self):
+        self.shape = [0, 0]
+
+
 if __name__ == "__main__":
     unittest.main()

test/legacy_test/test_soft_margin_loss.py

@@ -195,5 +195,51 @@ def test_SoftMarginLoss_error(self):
         paddle.enable_static()
 
 
+class TestSoftMarginLoss_ZeroSize(unittest.TestCase):
+    def init_shape(self):
+        self.shape = (0, 5)
+
+    def test_SoftMarginLoss(self):
+        self.init_shape()
+        input_np = np.random.uniform(0.1, 0.8, size=self.shape).astype(
+            np.float64
+        )
+        type = np.float32
+        places = []
+        if (
+            os.environ.get('FLAGS_CI_both_cpu_and_gpu', 'False').lower()
+            in ['1', 'true', 'on']
+            or not paddle.device.is_compiled_with_cuda()
+        ):
+            places.append(paddle.CPUPlace())
+        if paddle.device.is_compiled_with_cuda():
+            places.append(paddle.CUDAPlace(0))
+        reductions = ['sum', 'mean', 'none']
+        for place in places:
+            for reduction in reductions:
+                label_np = np.random.randint(0, 2, size=self.shape).astype(type)
+                label_np[label_np == 0] = -1
+
+                expected = calc_softmarginloss(input_np, label_np, reduction)
+
+                paddle.disable_static(place)
+                input = paddle.to_tensor(input_np)
+                input.stop_gradient = False
+                label = paddle.to_tensor(label_np)
+
+                dy_res = paddle.nn.functional.soft_margin_loss(
+                    input, label, reduction=reduction
+                )
+                np.testing.assert_allclose(dy_res.numpy(), expected, rtol=1e-05)
+                loss = paddle.sum(dy_res)
+                loss.backward()
+                np.testing.assert_allclose(input.grad.shape, input.shape)
+
+
+class TestSoftMarginLoss_ZeroSize2(TestSoftMarginLoss_ZeroSize):
+    def init_shape(self):
+        self.shape = (0, 0)
+
+
 if __name__ == "__main__":
     unittest.main()

test/legacy_test/test_square_error_cost.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
@@ -61,6 +62,8 @@ def test_square_error_cost(self):
 class TestSquareErrorInvalidInput(unittest.TestCase):
 
     def test_error(self):
+        paddle.enable_static()
+
         def test_invalid_input():
             input = [256, 3]
             label = paddle.static.data(
@@ -80,5 +83,46 @@ def test_invalid_label():
         self.assertRaises(TypeError, test_invalid_label)
 
 
+class TestSquareErrorCost_ZeroSize(unittest.TestCase):
+    def init_shape(self):
+        self.shape = [0, 3]
+
+    def test_square_error_cost(self):
+        places = []
+        if (
+            os.environ.get('FLAGS_CI_both_cpu_and_gpu', 'False').lower()
+            in ['1', 'true', 'on']
+            or not paddle.device.is_compiled_with_cuda()
+        ):
+            places.append(paddle.CPUPlace())
+        if paddle.device.is_compiled_with_cuda():
+            places.append(paddle.CUDAPlace(0))
+        self.init_shape()
+        shape = self.shape
+        input_val = np.random.uniform(0.1, 0.5, shape).astype("float32")
+        label_val = np.random.uniform(0.1, 0.5, shape).astype("float32")
+
+        sub = input_val - label_val
+        np_result = sub * sub
+        for place in places:
+            paddle.disable_static(place)
+            input = paddle.to_tensor(input_val)
+            input.stop_gradient = False
+            label = paddle.to_tensor(label_val)
+            output = paddle.nn.functional.square_error_cost(
+                input=input, label=label
+            )
+            np.testing.assert_allclose(np_result, output.numpy(), rtol=1e-05)
+            loss = paddle.sum(output)
+            loss.backward()
+            np.testing.assert_allclose(input.grad.shape, input.shape)
+            paddle.enable_static()
+
+
+class TestSquareErrorCost_ZeroSize2(TestSquareErrorCost_ZeroSize):
+    def init_shape(self):
+        self.shape = [0, 0]
+
+
 if __name__ == "__main__":
     unittest.main()