[0-size Tensor No.165、218] Add 0-size Tensor support for paddle.nn.functional.cosine_similarity [fluid_ops]

Author: co63oc

python/paddle/nn/functional/common.py

@@ -2229,6 +2229,8 @@ def cosine_similarity(
             [ 0.97689527,  0.99996042, -0.55138415])
 
     """
+    if x1.shape[axis] == 0 or x2.shape[axis] == 0:
+        return sum(paddle.multiply(x1, x2), axis=axis)
     bs = paddle.broadcast_shape([x1.shape[axis]], [x2.shape[axis]])
     w12 = sum(paddle.multiply(x1, x2), axis=axis)
     w1 = sum(paddle.multiply(x1, x1), axis=axis)

test/legacy_test/test_cosine_similarity_api.py

@@ -163,5 +163,44 @@ def test_dygraph_5(self):
         np.testing.assert_allclose(y.numpy(), np_out, rtol=1e-05)
 
 
+class TestCosineSimilarityAPI_ZeroSize(unittest.TestCase):
+    def setUp(self):
+        self.places = get_places()
+
+    def _get_numpy_out(self, x1, x2, axis=1, eps=1e-8):
+        bs = np.broadcast_shapes([x1.shape[axis]], [x2.shape[axis]])
+        w12 = np.sum(x1 * x2, axis=axis)
+        w1 = np.sum(x1 * x1, axis=axis)
+        w2 = np.sum(x2 * x2, axis=axis)
+        m1, m2 = bs[0] / x1.shape[axis], bs[0] / x2.shape[axis]
+        if m1 != 1:
+            w1 = w1 * m1
+        if m2 != 1:
+            w2 = w2 * m2
+        n12 = np.sqrt(np.clip(w1 * w2, eps * eps, None))
+        cos_sim = w12 / n12
+        return cos_sim
+
+    def test_dygraph_1(self):
+        paddle.disable_static()
+
+        shape = [0, 15]
+        axis = 1
+        eps = 1e-8
+        np.random.seed(1)
+        np_x1 = np.random.rand(*shape).astype(np.float32)
+        np_x2 = np.random.rand(*shape).astype(np.float32)
+        np_out = self._get_numpy_out(np_x1, np_x2, axis=axis, eps=eps)
+
+        tensor_x1 = paddle.to_tensor(np_x1)
+        tensor_x1.stop_gradient = False
+        tensor_x2 = paddle.to_tensor(np_x2)
+        y = F.cosine_similarity(tensor_x1, tensor_x2, axis=axis, eps=eps)
+
+        np.testing.assert_allclose(y.numpy(), np_out, rtol=1e-05)
+        y.sum().backward()
+        np.testing.assert_allclose(tensor_x1.grad.shape, tensor_x1.shape)
+
+
 if __name__ == '__main__':
     unittest.main()

test/legacy_test/test_sigmoid_focal_loss.py

@@ -191,5 +191,71 @@ def test_SigmoidFocalLoss_error(self):
         paddle.enable_static()
 
 
+class TestSigmoidFocalLoss_ZeroSize(unittest.TestCase):
+
+    def _test_dygraph(
+        self,
+        place,
+        logit_np,
+        label_np,
+        normalizer_np,
+        alpha=0.25,
+        gamma=2.0,
+        reduction='sum',
+    ):
+        paddle.disable_static()
+        logit = paddle.to_tensor(logit_np)
+        logit.stop_gradient = False
+        label = paddle.to_tensor(label_np)
+        normalizer = None
+        if normalizer_np is not None:
+            normalizer = paddle.to_tensor(normalizer_np)
+        dy_res = call_sfl_functional(
+            logit, label, normalizer, alpha, gamma, reduction
+        )
+        dy_res.sum().backward()
+        np.testing.assert_allclose(logit.grad.shape, logit.shape)
+        dy_result = dy_res.numpy()
+        paddle.enable_static()
+        return dy_result
+
+    def test_SigmoidFocalLoss(self):
+        logit_np = np.random.uniform(0.1, 0.8, size=(0, 3, 4, 10)).astype(
+            np.float64
+        )
+        label_np = np.random.randint(0, 2, size=(0, 3, 4, 10)).astype(
+            np.float64
+        )
+        normalizer_nps = [
+            np.asarray([np.sum(label_np > 0)], dtype=label_np.dtype),
+            None,
+        ]
+        places = get_places()
+        reductions = ['sum']
+        alpha = 0.25
+        gamma = 3
+        for place in places:
+            for reduction in reductions:
+                for normalizer_np in normalizer_nps:
+                    dy_result = self._test_dygraph(
+                        place,
+                        logit_np,
+                        label_np,
+                        normalizer_np,
+                        alpha,
+                        gamma,
+                        reduction,
+                    )
+                    expected = calc_sigmoid_focal_loss(
+                        logit_np,
+                        label_np,
+                        normalizer_np,
+                        alpha,
+                        gamma,
+                        reduction,
+                    )
+                    np.testing.assert_allclose(dy_result, expected, rtol=1e-05)
+
+
 if __name__ == "__main__":
     unittest.main()