【Paddle Tensor No.21】：新增 bitwise_invert，复用已有接口 Tenosr.__invert__ (#69197)

MrXnneHang · web-flow · commit b084653daeab · 2024-11-08T13:24:25.000+08:00
* chore:Remove duplicate elements

* chore:Reuse API Tensor.__invert__() as Tensor.bitwise_invert()

* test:add test for Tensor.bitwise_invert()

* fix:paddle/__init__,tensor/__init__.py

* feature:define bitwise_invert

* doc: 修改bitwise_invert使用示例

* docs:remove 'it support broading...'

* refactor:remove bitwise_invert

* feature:add bitwise_invert_

* test:Add inplace test for bitwise_invet_

* test: Add unittest.TestCase for bitwise_invert

* test: remove testcase

* fix:Disable static graph mode in tests to allow numpy() usage

* chore:rename TestBitwiseInvert -&gt; TestBitwiseInvertApi

* typos:bitwis-&gt;bitwise
diff --git a/python/paddle/__init__.py b/python/paddle/__init__.py
@@ -244,6 +244,8 @@
     allclose,
     bitwise_and,
     bitwise_and_,
+    bitwise_invert,
+    bitwise_invert_,
     bitwise_not,
     bitwise_not_,
     bitwise_or,
@@ -899,6 +901,8 @@
     'bitwise_xor_',
     'bitwise_not',
     'bitwise_not_',
+    'bitwise_invert',
+    'bitwise_invert_',
     'mm',
     'flip',
     'rot90',
diff --git a/python/paddle/jit/sot/utils/magic_methods.py b/python/paddle/jit/sot/utils/magic_methods.py
@@ -78,9 +78,7 @@
     operator.abs: "__abs__",
     operator.index: "__index__",
     operator.inv: "__inv__",
-    operator.invert: "__invert__",
     operator.not_: "__not__",
-    operator.pos: "__pos__",
     operator.truth: "__bool__",
     bool: "__bool__",
     abs: "__abs__",
diff --git a/python/paddle/tensor/__init__.py b/python/paddle/tensor/__init__.py
@@ -107,6 +107,8 @@
     allclose,
     bitwise_and,
     bitwise_and_,
+    bitwise_invert,
+    bitwise_invert_,
     bitwise_not,
     bitwise_not_,
     bitwise_or,
@@ -729,6 +731,8 @@
     'bitwise_xor_',
     'bitwise_not',
     'bitwise_not_',
+    'bitwise_invert',
+    'bitwise_invert_',
     'broadcast_tensors',
     'eig',
     'uniform_',
diff --git a/python/paddle/tensor/logic.py b/python/paddle/tensor/logic.py
@@ -1415,6 +1415,54 @@ def bitwise_not_(x: Tensor, name: str | None = None) -> Tensor:
         return _C_ops.bitwise_not_(x)
 
 
+def bitwise_invert(
+    x: Tensor, out: Tensor | None = None, name: str | None = None
+) -> Tensor:
+    r"""
+    Apply ``bitwise_not`` (bitwise inversion) on Tensor ``x``.
+
+    This is an alias to the ``paddle.bitwise_not`` function.
+
+    .. math::
+        Out = \sim X
+
+    Note:
+        ``paddle.bitwise_invert`` is functionally equivalent to ``paddle.bitwise_not``.
+
+    Args:
+        x (Tensor): Input Tensor of ``bitwise_invert``. It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
+        out (Tensor|None, optional): Result of ``bitwise_invert``. It is a N-D Tensor with the same data type as the input Tensor. Default: None.
+        name (str|None, optional): The default value is None. This property is typically not set by the user.
+            For more information, please refer to :ref:`api_guide_Name`.
+
+    Returns:
+        Tensor: Result of ``bitwise_invert``. It is a N-D Tensor with the same data type as the input Tensor.
+
+    Examples:
+        .. code-block:: python
+
+            >>> import paddle
+            >>> x = paddle.to_tensor([-5, -1, 1])
+            >>> res = x.bitwise_invert()
+            >>> print(res)
+            Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True,
+            [ 4,  0, -2])
+
+    """
+    # Directly call bitwise_not for the implementation
+    return bitwise_not(x, out=out, name=name)
+
+
+@inplace_apis_in_dygraph_only
+def bitwise_invert_(x: Tensor, name: str | None = None) -> Tensor:
+    r"""
+    Inplace version of ``bitwise_invert`` API, the output Tensor will be inplaced with input ``x``.
+    Please refer to :ref:`api_paddle_bitwise_invert_`.
+    """
+    # Directly call bitwise_not_ for the implementation
+    return bitwise_not_(x, name=name)
+
+
 def isclose(
     x: Tensor,
     y: Tensor,
diff --git a/test/legacy_test/test_bitwise_op.py b/test/legacy_test/test_bitwise_op.py
@@ -438,5 +438,27 @@ def setUp(self):
         self.outputs = {'Out': out}
 
 
+class TestBitwiseInvertApi(unittest.TestCase):
+    def setUp(self):
+        paddle.disable_static()
+
+        self.dtype = np.int32
+        self.shape = [2, 3, 4, 5]
+        self.low = -100
+        self.high = 100
+        x = np.random.randint(self.low, self.high, self.shape, dtype=self.dtype)
+        self.x = paddle.to_tensor(x)
+        self.expected_out = np.bitwise_not(x)
+
+    def test_bitwise_invert_out_of_place(self):
+        result = paddle.bitwise_invert(self.x)
+        np.testing.assert_array_equal(result.numpy(), self.expected_out)
+
+    def test_bitwise_invert_in_place(self):
+        x_copy = self.x.clone()
+        x_copy.bitwise_invert_()
+        np.testing.assert_array_equal(x_copy.numpy(), self.expected_out)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/legacy_test/test_inplace.py b/test/legacy_test/test_inplace.py
@@ -1500,23 +1500,23 @@ def test_broadcast_error(self):
             self.inplace_api_processing(broadcast_input)
 
 
-class TestDygraphInplacBitwisOr(TestDygraphInplacBitwiseAnd):
+class TestDygraphInplacBitwiseOr(TestDygraphInplacBitwiseAnd):
     def inplace_api_processing(self, var):
         return paddle.bitwise_or_(var, self.y)
 
     def non_inplace_api_processing(self, var):
         return paddle.bitwise_or(var, self.y)
 
 
-class TestDygraphInplacBitwisXor(TestDygraphInplacBitwiseAnd):
+class TestDygraphInplacBitwiseXor(TestDygraphInplacBitwiseAnd):
     def inplace_api_processing(self, var):
         return paddle.bitwise_xor_(var, self.y)
 
     def non_inplace_api_processing(self, var):
         return paddle.bitwise_xor(var, self.y)
 
 
-class TestDygraphInplacBitwisNot(TestDygraphInplacBitwiseAnd):
+class TestDygraphInplacBitwiseNot(TestDygraphInplacBitwiseAnd):
     def inplace_api_processing(self, var):
         return paddle.bitwise_not_(var)
 
@@ -1527,6 +1527,17 @@ def test_broadcast_error(self):
         pass
 
 
+class TestDygraphInplacBitwiseInvert(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        return paddle.bitwise_invert_(var)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_invert(var)
+
+    def test_broadcast_error(self):
+        pass
+
+
 class TestDygraphInplaceDivide(TestDygraphInplace):
     def init_data(self):
         self.input_var_numpy = np.random.uniform(-5, 5, [10, 20, 1])
diff --git a/test/legacy_test/test_math_op_patch_pir.py b/test/legacy_test/test_math_op_patch_pir.py
@@ -168,6 +168,7 @@ def test_bitwise_not(self):
         res_np_b = ~x_np
         res_np_c = paddle.bitwise_not(paddle.to_tensor(x_np))
         res_np_d = x_np.__invert__()
+        res_np_e = res_np_d
         paddle.enable_static()
         with paddle.pir_utils.IrGuard():
             main_program, exe, program_guard = new_program()
@@ -176,14 +177,16 @@ def test_bitwise_not(self):
                 b = ~x
                 c = x.bitwise_not()
                 d = x.__invert__()
-                (b_np, c_np, d_np) = exe.run(
+                e = x.bitwise_invert()
+                (b_np, c_np, d_np, e_np) = exe.run(
                     main_program,
                     feed={"x": x_np},
-                    fetch_list=[b, c, d],
+                    fetch_list=[b, c, d, e],
                 )
                 np.testing.assert_array_equal(res_np_b, b_np)
                 np.testing.assert_array_equal(res_np_c, c_np)
                 np.testing.assert_array_equal(res_np_d, d_np)
+                np.testing.assert_array_equal(res_np_e, e_np)
 
     def test_bitwise_xor(self):
         paddle.disable_static()
