remove complexvariable (#29390) (#29417)

* rm complexvariable

* modify test_var_base unittest

* remove duplicated codes

Author: MingMingShangTian

python/paddle/__init__.py

@@ -32,7 +32,6 @@
 monkey_patch_math_varbase()
 import paddle.framework
 from .framework import VarBase as Tensor
-from .framework import ComplexVariable as ComplexTensor
 import paddle.compat
 import paddle.distributed
 import paddle.sysconfig
@@ -43,7 +42,6 @@
 import paddle.optimizer
 import paddle.metric
 import paddle.device
-import paddle.incubate.complex as complex
 import paddle.regularizer
 
 # TODO: define alias in tensor and framework directory

python/paddle/fluid/dygraph/base.py

@@ -593,12 +593,12 @@ def to_variable(value, name=None, zero_copy=None, dtype=None):
     r"""
     :api_attr: imperative
 
-    The API will create a ``Variable`` or ``ComplexVariable`` object from 
-    tuple, list, numpy\.ndarray, Variable or ComplexVariable object.
+    The API will create a ``Variable`` object from 
+    tuple, list, numpy\.ndarray or Variable object.
 
     Parameters:
-        value(tuple|list|ndarray|Variable|Tensor|ComplexVariable): Initial data. 
-            Can be a list, tuple, NumPy ndarray, Variable, Tensor, ComplexVariable. 
+        value(tuple|list|ndarray|Variable|Tensor): Initial data. 
+            Can be a list, tuple, NumPy ndarray, Variable, Tensor.
             The shape can be multi-dimensional. The data type is one of 
             numpy\.{float16, float32, float64, int16, int32, int64, 
             uint8, uint16, complex64, complex128}.
@@ -613,10 +613,9 @@ def to_variable(value, name=None, zero_copy=None, dtype=None):
             'int32' , 'int64' , 'uint8' . Default: None.
 
     Returns:
-        Variable or ComplexVariable: If ``value`` is a tuple/list/numpy\.ndarray object, 
+        Variable : If ``value`` is a tuple/list/numpy\.ndarray object, 
             return ``Tensor`` created from the corresponding numpy\.ndarray object, which has 
-            same data type and shape with ``value``. If ``value`` is a Variable or ComplexVariable 
-            object, just return ``value``.
+            same data type and shape with ``value``. 
 
 
     Examples:
@@ -647,13 +646,12 @@ def to_variable(value, name=None, zero_copy=None, dtype=None):
 
     """
     support_type = (list, tuple, np.ndarray, core.VarBase, framework.Variable,
-                    framework.ComplexVariable, core.Tensor, core.LoDTensor)
+                    core.Tensor, core.LoDTensor)
     if not isinstance(value, support_type):
         raise TypeError(
             "The type of 'value' in fluid.dygraph.to_variable must be %s, but received %s."
             % (support_type, type(value)))
-    if isinstance(value, (core.VarBase, framework.Variable,
-                          framework.ComplexVariable)):
+    if isinstance(value, (core.VarBase, framework.Variable)):
         return value
     elif isinstance(value, (core.Tensor, core.LoDTensor)):
         return core.VarBase(value)
@@ -682,27 +680,10 @@ def to_variable(value, name=None, zero_copy=None, dtype=None):
             if value.dtype != dtype:
                 value = value.astype(dtype)
 
-        if np.iscomplexobj(value):
-            if not name:
-                name = framework.unique_name.generate('_generated_var')
-            real_var = core.VarBase(
-                value=value.real,
-                place=framework._current_expected_place(),
-                persistable=False,
-                zero_copy=zero_copy,
-                name=name + ".real")
-            imag_var = core.VarBase(
-                value=value.imag,
-                place=framework._current_expected_place(),
-                persistable=False,
-                zero_copy=zero_copy,
-                name=name + ".imag")
-            return framework.ComplexVariable(real_var, imag_var)
-        else:
-            py_var = core.VarBase(
-                value=value,
-                place=framework._current_expected_place(),
-                persistable=False,
-                zero_copy=zero_copy,
-                name=name if name else '')
-            return py_var
+        py_var = core.VarBase(
+            value=value,
+            place=framework._current_expected_place(),
+            persistable=False,
+            zero_copy=zero_copy,
+            name=name if name else '')
+        return py_var

python/paddle/fluid/dygraph/math_op_patch.py

@@ -15,7 +15,7 @@
 from __future__ import print_function
 
 from .. import core
-from ..framework import Variable, convert_np_dtype_to_dtype_, _varbase_creator, ComplexVariable
+from ..framework import Variable, convert_np_dtype_to_dtype_, _varbase_creator
 from ..layers.layer_function_generator import OpProtoHolder
 from . import no_grad
 
@@ -170,13 +170,6 @@ def _binary_creator_(method_name,
                          reverse=False,
                          scalar_method=None):
         def __impl__(self, other_var):
-            # 0. check tensor and ComplexVariable opetator
-            if isinstance(other_var, ComplexVariable):
-                # need import paddle in closure
-                import paddle
-                math_op = getattr(paddle.incubate.complex.tensor, op_type)
-                return math_op(self, other_var)
-
             # 1. scalar exists cases
             # we need combine the tensor.dtype and scalar.dtype, cast correct object
             if isinstance(other_var, float):

python/paddle/fluid/framework.py

@@ -51,7 +51,6 @@
     'is_compiled_with_cuda',
     'is_compiled_with_xpu',
     'Variable',
-    'ComplexVariable',
     'load_op_library',
     'require_version',
     'device_guard',
@@ -1783,97 +1782,6 @@ def get_all_op_protos():
     return ret_values
 
 
-class ComplexVariable(object):
-    """
-    The ComplexTensor defined on the complex number domain. It contains two common 
-    real number Tensor as its members, :attr:`real` and :attr:`imag` 
-    holding the real part and imaginary part of complex numbers respectively.
-    
-    **Notes**:
-        **The constructor of ComplexTensor should not be invoked directly.**
-
-    Args:
-        real (Tensor): The Tensor holding real-part data.
-        imag (Tensor): The Tensor holding imaginery-part data.
-    
-    Examples:
-        .. code-block:: python
-
-            import paddle
-            x = paddle.to_tensor([1.0+2.0j, 0.2])
-            print(x.name, x.dtype, x.shape)
-            # ({'real': 'generated_tensor_0.real', 'imag': 'generated_tensor_0.imag'}, complex64, [2])
-            print(x)
-            # ComplexTensor[real](shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
-            #                     [        1., 0.20000000])
-            # ComplexTensor[imag](shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
-            #                     [2., 0.])
-            print(type(x))
-            # <class 'paddle.ComplexTensor'>
-    """
-
-    def __new__(cls, *arg, **kwargs):
-        cls.__module__ = "paddle"
-        cls.__name__ = "ComplexTensor"
-        return super(ComplexVariable, cls).__new__(cls)
-
-    def __init__(self, real, imag):
-        assert real.shape == imag.shape, "The real part and imaginary part " \
-            "of a ComplexVariable should have the same shape!"
-        assert real.dtype == imag.dtype, "The real part and imaginary part " \
-            "of a ComplexVariable should have the same data type!"
-
-        self.real = real
-        self.imag = imag
-        if self.real.dtype in [
-                core.VarDesc.VarType.FP16, core.VarDesc.VarType.FP32
-        ]:
-            self._dtype = "complex64"
-        else:
-            self._dtype = "complex128"
-        self._shape = self.real.shape
-
-    def __getitem__(self, idx):
-        return ComplexVariable(self.real[idx], self.imag[idx])
-
-    @property
-    def dtype(self):
-        return self._dtype
-
-    @property
-    def shape(self):
-        return self._shape
-
-    @property
-    def name(self):
-        return {"real": self.real.name, "imag": self.imag.name}
-
-    @name.setter
-    def name(self, name):
-        # rename
-        if isinstance(name, str):
-            self.real.name = name + ".real"
-            self.imag.name = name + ".imag"
-        elif (isinstance(name, tuple) or isinstance(name,
-                                                    list)) and len(name) == 2:
-            self.real.name, self.imag.name = name[0], name[1]
-        else:
-            raise ValueError(
-                "An invalid name assigned to the ComplexVariable, "
-                "which must be a string, or a tuple or a list with length 2!")
-
-    def numpy(self):
-        return self.real.numpy() + 1j * self.imag.numpy()
-
-    def __str__(self):
-        from paddle.tensor.to_string import to_string
-        return "ComplexTensor containing:\n{real}\n{imag}".format(
-            real=to_string(self.real, "[real part]Tensor"),
-            imag=to_string(self.imag, "[imag part]Tensor"))
-
-    __repr__ = __str__
-
-
 class OpProtoHolder(object):
     """
     A global variable to hold all OpProtos from C++ as a map

python/paddle/fluid/tests/unittests/test_complex_elementwise_layers.py

@@ -19,14 +19,6 @@
 import paddle
 import paddle.fluid as fluid
 import paddle.fluid.dygraph as dg
-from paddle import complex as cpx
-
-layers = {
-    "add": cpx.elementwise_add,
-    "sub": cpx.elementwise_sub,
-    "mul": cpx.elementwise_mul,
-    "div": cpx.elementwise_div,
-}
 
 paddle_apis = {
     "add": paddle.add,
@@ -43,26 +35,10 @@ def setUp(self):
         if fluid.core.is_compiled_with_cuda():
             self._places.append(paddle.CUDAPlace(0))
 
-    def calc(self, x, y, op, place):
-        with dg.guard(place):
-            var_x = dg.to_variable(x)
-            var_y = dg.to_variable(y)
-            return layers[op](var_x, var_y).numpy()
-
     def paddle_calc(self, x, y, op, place):
         with dg.guard(place):
-            x_t = paddle.Tensor(
-                value=x,
-                place=place,
-                persistable=False,
-                zero_copy=False,
-                stop_gradient=True)
-            y_t = paddle.Tensor(
-                value=y,
-                place=place,
-                persistable=False,
-                zero_copy=False,
-                stop_gradient=True)
+            x_t = dg.to_variable(x)
+            y_t = dg.to_variable(y)
             return paddle_apis[op](x_t, y_t).numpy()
 
     def assert_check(self, pd_result, np_result, place):
@@ -72,13 +48,6 @@ def assert_check(self, pd_result, np_result, place):
             format(place, pd_result[~np.isclose(pd_result, np_result)],
                    np_result[~np.isclose(pd_result, np_result)]))
 
-    def compare_by_complex_api(self, x, y):
-        for place in self._places:
-            self.assert_check(self.calc(x, y, "add", place), x + y, place)
-            self.assert_check(self.calc(x, y, "sub", place), x - y, place)
-            self.assert_check(self.calc(x, y, "mul", place), x * y, place)
-            self.assert_check(self.calc(x, y, "div", place), x / y, place)
-
     def compare_by_basic_api(self, x, y):
         for place in self._places:
             self.assert_check(
@@ -90,7 +59,7 @@ def compare_by_basic_api(self, x, y):
             self.assert_check(
                 self.paddle_calc(x, y, "div", place), x / y, place)
 
-    def compare_op_by_complex_api(self, x, y):
+    def compare_op_by_basic_api(self, x, y):
         for place in self._places:
             with dg.guard(place):
                 var_x = dg.to_variable(x)
@@ -100,37 +69,14 @@ def compare_op_by_complex_api(self, x, y):
                 self.assert_check((var_x * var_y).numpy(), x * y, place)
                 self.assert_check((var_x / var_y).numpy(), x / y, place)
 
-    def compare_op_by_basic_api(self, x, y):
-        for place in self._places:
-            with dg.guard(place):
-                x_t = paddle.Tensor(
-                    value=x,
-                    place=place,
-                    persistable=False,
-                    zero_copy=False,
-                    stop_gradient=True)
-                y_t = paddle.Tensor(
-                    value=y,
-                    place=place,
-                    persistable=False,
-                    zero_copy=False,
-                    stop_gradient=True)
-                self.assert_check((x_t + y_t).numpy(), x + y, place)
-                self.assert_check((x_t - y_t).numpy(), x - y, place)
-                self.assert_check((x_t * y_t).numpy(), x * y, place)
-                self.assert_check((x_t / y_t).numpy(), x / y, place)
-
     def test_complex_xy(self):
         for dtype in self._dtypes:
             x = rand([2, 3, 4, 5]).astype(dtype) + 1j * rand(
                 [2, 3, 4, 5]).astype(dtype)
             y = rand([2, 3, 4, 5]).astype(dtype) + 1j * rand(
                 [2, 3, 4, 5]).astype(dtype)
 
-            self.compare_by_complex_api(x, y)
-            self.compare_op_by_complex_api(x, y)
-
-            self.compare_op_by_complex_api(x, y)
+            self.compare_by_basic_api(x, y)
             self.compare_op_by_basic_api(x, y)
 
     def test_complex_x_real_y(self):
@@ -139,9 +85,6 @@ def test_complex_x_real_y(self):
                 [2, 3, 4, 5]).astype(dtype)
             y = rand([4, 5]).astype(dtype)
 
-            self.compare_by_complex_api(x, y)
-            self.compare_op_by_complex_api(x, y)
-
             # promote types cases
             self.compare_by_basic_api(x, y)
             self.compare_op_by_basic_api(x, y)
@@ -151,9 +94,6 @@ def test_real_x_complex_y(self):
             x = rand([2, 3, 4, 5]).astype(dtype)
             y = rand([5]).astype(dtype) + 1j * rand([5]).astype(dtype)
 
-            self.compare_by_complex_api(x, y)
-            self.compare_op_by_complex_api(x, y)
-
             # promote types cases
             self.compare_by_basic_api(x, y)
             self.compare_op_by_basic_api(x, y)