【Paddle Tensor No.13】: 新增paddle.positive,新增Tensor.__pos__ (#69256)

MrXnneHang · web-flow · commit 6c14ff0b51ae · 2024-11-12T14:40:11.000+08:00
* feat: add paddle.positive and Tensor.__pos__ to return self

* test: Add test for paddle.positive

* fix:use np.testing.assert_allclose

* fix: import paddle in example code

* test:test paddle.positive with bool tensor handling

* docs:fix docstring sample code

* docs:remove example code 2

* docs:add math

* fix: remove `return x.clone()` in static mode

* chore: raises type error,fix docstring,add `__pos__` in `tensor.prototype.pyi`

* docs: remove `return a clone in a static mode`

* fix: test raise `ValueError` -&gt; `TypeError`
diff --git a/python/paddle/__init__.py b/python/paddle/__init__.py
@@ -278,6 +278,7 @@
     logical_xor_,  # noqa: F401
     not_equal,
     not_equal_,  # noqa: F401
+    positive,
 )
 from .tensor.manipulation import (
     as_complex,
@@ -1184,4 +1185,5 @@
     'diagonal_scatter',
     'combinations',
     'signbit',
+    'positive',
 ]
diff --git a/python/paddle/tensor/__init__.py b/python/paddle/tensor/__init__.py
@@ -141,6 +141,7 @@
     logical_xor_,
     not_equal,
     not_equal_,
+    positive,
 )
 from .manipulation import (  # noqa: F401
     as_complex,
@@ -860,4 +861,5 @@
     ('__or__', 'bitwise_or'),
     ('__xor__', 'bitwise_xor'),
     ('__invert__', 'bitwise_not'),
+    ('__pos__', 'positive'),
 ]
diff --git a/python/paddle/tensor/logic.py b/python/paddle/tensor/logic.py
@@ -1463,6 +1463,38 @@ def bitwise_invert_(x: Tensor, name: str | None = None) -> Tensor:
     return bitwise_not_(x, name=name)
 
 
+def positive(x: Tensor) -> Tensor:
+    r"""
+    Returns the input Tensor as it is. This is used in `Tensor.__pos__`, applying the
+    unary `+` operator to the tensor.
+
+    .. math::
+        Out = +X
+
+    Args:
+        x (Tensor): The input tensor. The tensor cannot be of type bool.
+
+    Returns:
+        Tensor: A tensor with the same shape and data type as the input tensor. The returned tensor
+                is the same.
+
+    Examples:
+        .. code-block:: python
+
+            >>> import paddle
+            >>> x = paddle.to_tensor([-1, 0, 1])
+            >>> out = paddle.positive(x)
+            >>> print(out)
+            Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True,
+            [-1,  0,  1])
+    """
+
+    # Check if the input tensor is of bool type and raise an error
+    if x.dtype == paddle.bool:
+        raise TypeError("The `+` operator, on a bool tensor is not supported.")
+    return x
+
+
 def isclose(
     x: Tensor,
     y: Tensor,
diff --git a/python/paddle/tensor/tensor.prototype.pyi b/python/paddle/tensor/tensor.prototype.pyi
@@ -206,6 +206,7 @@ class AbstractTensor:
     # unary arithmetic operations
     def __invert__(self) -> Tensor: ...
     def __neg__(self) -> Tensor: ...
+    def __pos__(self) -> Tensor: ...
 
     # basic
     def __hash__(self) -> int: ...
diff --git a/test/legacy_test/test_math_op_patch_pir.py b/test/legacy_test/test_math_op_patch_pir.py
@@ -275,6 +275,31 @@ def test_bitwise_and(self):
                 np.testing.assert_array_equal(res_np_c, c_np)
                 np.testing.assert_array_equal(res_np_d, d_np)
 
+    def test_positive(self):
+        paddle.disable_static()
+        x_np = np.random.random([10, 1024]).astype('float32')
+        res_np_b = +x_np
+        res_np_c = paddle.positive(paddle.to_tensor(x_np))
+        res_np_d = x_np.__pos__()
+        paddle.enable_static()
+        with paddle.pir_utils.IrGuard():
+            main_program, exe, program_guard = new_program()
+            with program_guard:
+                x = paddle.static.data(
+                    name='x', shape=[10, 1024], dtype='float32'
+                )
+                b = +x
+                c = paddle.positive(x)
+                d = x.__pos__()
+                (b_np, c_np, d_np) = exe.run(
+                    main_program,
+                    feed={"x": x_np},
+                    fetch_list=[b, c, d],
+                )
+                np.testing.assert_allclose(res_np_b, b_np, atol=1e-05)
+                np.testing.assert_allclose(res_np_c, c_np, atol=1e-05)
+                np.testing.assert_allclose(res_np_d, d_np, atol=1e-05)
+
     # for logical compare
     def test_equal_and_nequal(self):
         paddle.disable_static()
diff --git a/test/legacy_test/test_positive.py b/test/legacy_test/test_positive.py
@@ -0,0 +1,87 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import numpy as np
+
+import paddle
+
+
+class TestPositiveApi(unittest.TestCase):
+
+    def setUp(self):
+        paddle.disable_static()
+        self.shape = [2, 3, 4, 5]
+        self.low = -100
+        self.high = 100
+
+    def test_positive_int16(self):
+        x = np.random.randint(self.low, self.high, self.shape, dtype=np.int16)
+        expected_out = np.positive(x)
+        x_tensor = paddle.to_tensor(x)
+        out = paddle.positive(x_tensor).numpy()
+        np.testing.assert_allclose(out, expected_out, atol=1e-5)
+
+    def test_positive_int32(self):
+        x = np.random.randint(self.low, self.high, self.shape, dtype=np.int32)
+        expected_out = np.positive(x)
+        x_tensor = paddle.to_tensor(x)
+        out = paddle.positive(x_tensor).numpy()
+        np.testing.assert_allclose(out, expected_out, atol=1e-5)
+
+    def test_positive_int64(self):
+        x = np.random.randint(self.low, self.high, self.shape, dtype=np.int64)
+        expected_out = np.positive(x)
+        x_tensor = paddle.to_tensor(x)
+        out = paddle.positive(x_tensor).numpy()
+        np.testing.assert_allclose(out, expected_out, atol=1e-5)
+
+    def test_positive_float16(self):
+        x = np.random.uniform(self.low, self.high, self.shape).astype(
+            np.float16
+        )
+        expected_out = np.positive(x)
+        x_tensor = paddle.to_tensor(x)
+        out = paddle.positive(x_tensor).numpy()
+        np.testing.assert_allclose(out, expected_out, atol=1e-3)
+
+    def test_positive_float32(self):
+        x = np.random.uniform(self.low, self.high, self.shape).astype(
+            np.float32
+        )
+        expected_out = np.positive(x)
+        x_tensor = paddle.to_tensor(x)
+        out = paddle.positive(x_tensor).numpy()
+        np.testing.assert_allclose(out, expected_out, atol=1e-3)
+
+    def test_positive_float64(self):
+        x = np.random.uniform(self.low, self.high, self.shape).astype(
+            np.float64
+        )
+        expected_out = np.positive(x)
+        x_tensor = paddle.to_tensor(x)
+        out = paddle.positive(x_tensor).numpy()
+        np.testing.assert_allclose(out, expected_out, atol=1e-3)
+
+    def test_positive_bool(self):
+        x = np.random.choice([True, False], size=self.shape)
+        x_tensor = paddle.to_tensor(x, dtype=paddle.bool)
+
+        with self.assertRaises(TypeError):
+            paddle.positive(x_tensor)
+
+
+if __name__ == '__main__':
+    unittest.main()

Original file line number	Diff line number	Diff line change
`@@ -278,6 +278,7 @@`
`278`	`278`	`logical_xor_, # noqa: F401`
`279`	`279`	`not_equal,`
`280`	`280`	`not_equal_, # noqa: F401`
	`281`	`+ positive,`
`281`	`282`	`)`
`282`	`283`	`from .tensor.manipulation import (`
`283`	`284`	`as_complex,`
`@@ -1184,4 +1185,5 @@`
`1184`	`1185`	`'diagonal_scatter',`
`1185`	`1186`	`'combinations',`
`1186`	`1187`	`'signbit',`
	`1188`	`+ 'positive',`
`1187`	`1189`	`]`
Original file line number	Diff line number	Diff line change
`@@ -141,6 +141,7 @@`
`141`	`141`	`logical_xor_,`
`142`	`142`	`not_equal,`
`143`	`143`	`not_equal_,`
	`144`	`+ positive,`
`144`	`145`	`)`
`145`	`146`	`from .manipulation import ( # noqa: F401`
`146`	`147`	`as_complex,`
`@@ -860,4 +861,5 @@`
`860`	`861`	`('__or__', 'bitwise_or'),`
`861`	`862`	`('__xor__', 'bitwise_xor'),`
`862`	`863`	`('__invert__', 'bitwise_not'),`
	`864`	`+ ('__pos__', 'positive'),`
`863`	`865`	`]`