Paddle-2.0 fix pow, reciprocal, logical_*, multiply chinese doc (#2286)

doc/fluid/api_cn/layers_cn/logical_and_cn.rst

@@ -3,26 +3,26 @@
 logical_and
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.logical_and(x, y, out=None, name=None)
+.. py:function:: paddle.logical_and(x, y, out=None, name=None)
 
 :alias_main: paddle.logical_and
-:alias: paddle.logical_and,paddle.tensor.logical_and,paddle.tensor.logic.logical_and
+:alias: paddle.logical_and, paddle.tensor.logical_and, paddle.tensor.logic.logical_and
 :old_api: paddle.fluid.layers.logical_and
 
 
 
-该OP逐元素的对 ``X`` 和 ``Y`` 两LoDTensor/Tensor进行逻辑与运算。
+该OP逐元素的对 ``x`` 和 ``y`` 进行逻辑与运算。
 
 .. math::
        Out = X \&\& Y
 
 参数：
-        - **x** （Variable）- 逻辑与运算的第一个输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **y** （Variable）- 逻辑与运算的第二个输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **out** （Variable，可选）- 指定算子输出结果的LoDTensor/Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。 
+        - **x** （Variable）- 逻辑与运算的第一个输入，是一个 Variable，数据类型只能是bool。
+        - **y** （Variable）- 逻辑与运算的第二个输入，是一个 Variable，数据类型只能是bool。
+        - **out** （Variable，可选）- 指定算子输出结果的 Variable，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。 
         - **name** （str，可选）- 该参数供开发人员打印调试信息时使用，具体用法参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回：与 ``x`` 维度相同，数据类型相同的LoDTensor/Tensor。
+返回：与 ``x`` 维度相同，数据类型相同的 Variable。
 
 返回类型：Variable
 
@@ -31,24 +31,13 @@ logical_and
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle
     import numpy as np
     
-    # Graph organizing
-    x = fluid.layers.data(name='x', shape=[2], dtype='bool')
-    y = fluid.layers.data(name='y', shape=[2], dtype='bool')
-    res = fluid.layers.logical_and(x=x, y=y)
-    # The comment lists another available method.
-    # res = fluid.layers.fill_constant(shape=[2], dtype='bool', value=0)
-    # fluid.layers.logical_and(x=x, y=y, out=res)
-
-    # Create an executor using CPU as an example
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-
-    # Execute
-    x_i = np.array([[1, 0], [0, 1]]).astype(np.bool)
-    y_i = np.array([[1, 1], [0, 0]]).astype(np.bool)
-    res_val, = exe.run(fluid.default_main_program(), feed={'x':x_i, 'y':y_i}, fetch_list=[res])
-    print(res_val) # [[True, False], [False, False]] 
-
+    paddle.enable_imperative()
+    x_data = np.array([True, True, False, False], dtype=np.bool)
+    y_data = np.array([True, False, True, False], dtype=np.bool)
+    x = paddle.imperative.to_variable(x_data)
+    y = paddle.imperative.to_variable(y_data)
+    res = paddle.logical_and(x, y)
+    print(res.numpy()) # [True False False False]

doc/fluid/api_cn/layers_cn/logical_not_cn.rst

@@ -3,25 +3,25 @@
 logical_not
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.logical_not(x, out=None, name=None)
+.. py:function:: paddle.logical_not(x, out=None, name=None)
 
 :alias_main: paddle.logical_not
-:alias: paddle.logical_not,paddle.tensor.logical_not,paddle.tensor.logic.logical_not
+:alias: paddle.logical_not, paddle.tensor.logical_not, paddle.tensor.logic.logical_not
 :old_api: paddle.fluid.layers.logical_not
 
 
 
-该OP逐元素的对 ``X`` LoDTensor/Tensor进行逻辑非运算
+该OP逐元素的对 ``X``  Variable进行逻辑非运算
 
 .. math::
         Out = !X
 
 参数：
-        - **x** （Variable）- 逻辑非运算的输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **out** （Variable，可选）- 指定算子输出结果的LoDTensor/Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
+        - **x** （Variable）- 逻辑非运算的输入，是一个 Variable，数据类型只能是bool。
+        - **out** （Variable，可选）- 指定算子输出结果的 Variable，可以是程序中已经创建的任何 Variable。默认值为None，此时将创建新的Variable来保存输出结果。
         - **name** （str，可选）- 该参数供开发人员打印调试信息时使用，具体用法参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回：与 ``x`` 维度相同，数据类型相同的LoDTensor/Tensor。
+返回：与 ``x`` 维度相同，数据类型相同的 Variable。
 
 返回类型：Variable
 
@@ -29,22 +29,11 @@ logical_not
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle
     import numpy as np
 
-    # Graph organizing
-    x = fluid.layers.data(name='x', shape=[2], dtype='bool')
-    res = fluid.layers.logical_not(x)
-    # The comment lists another availble method.
-    # res = fluid.layers.fill_constant(shape=[2], dtype='bool', value=0)
-    # fluid.layers.logical_not(x, out=res)
-
-    # Create an executor using CPU as an example
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-
-    # Execute
-    x_i = np.array([[1, 0]]).astype(np.bool)
-    res_val, = exe.run(fluid.default_main_program(), feed={'x':x_i}, fetch_list=[res])
-    print(res_val) # [[False, True]]
-
+    paddle.enable_imperative()
+    x_data = np.array([True, False, True, False], dtype=np.bool)
+    x = paddle.imperative.to_variable(x_data)
+    res = paddle.logical_not(x)
+    print(res.numpy()) # [False  True False  True]

doc/fluid/api_cn/layers_cn/logical_or_cn.rst

@@ -3,26 +3,26 @@
 logical_or
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.logical_or(x, y, out=None, name=None)
+.. py:function:: paddle.logical_or(x, y, out=None, name=None)
 
 :alias_main: paddle.logical_or
-:alias: paddle.logical_or,paddle.tensor.logical_or,paddle.tensor.logic.logical_or
+:alias: paddle.logical_or, paddle.tensor.logical_or, paddle.tensor.logic.logical_or
 :old_api: paddle.fluid.layers.logical_or
 
 
 
-该OP逐元素的对 ``X`` 和 ``Y`` 两LoDTensor/Tensor进行逻辑或运算。
+该OP逐元素的对 ``X`` 和 ``Y`` 进行逻辑或运算。
 
 .. math::
         Out = X || Y
 
 参数：
-        - **x** （Variable）- 逻辑或运算的第一个输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **y** （Variable）- 逻辑或运算的第二个输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **out** （Variable，可选）- 指定算子输出结果的LoDTensor/Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
+        - **x** （Variable）- 逻辑或运算的第一个输入，是一个 Variable，数据类型只能是bool。
+        - **y** （Variable）- 逻辑或运算的第二个输入，是一个 Variable，数据类型只能是bool。
+        - **out** （Variable，可选）- 指定算子输出结果的 Variable，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
         - **name** （str，可选）- 该参数供开发人员打印调试信息时使用，具体用法参见 :ref:`api_guide_Name` ，默认值为None。
 
-返回：与 ``x`` 维度相同，数据类型相同的LoDTensor/Tensor。
+返回：与 ``x`` 维度相同，数据类型相同的 Variable。
 
 返回类型：Variable
 
@@ -31,24 +31,13 @@ logical_or
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle
     import numpy as np
 
-    # Graph organizing
-    x = fluid.layers.data(name='x', shape=[2], dtype='bool')
-    y = fluid.layers.data(name='y', shape=[2], dtype='bool')
-    res = fluid.layers.logical_or(x=x, y=y)
-    # The comment lists another available method.
-    # res = fluid.layers.fill_constant(shape=[2], dtype='bool', value=0)
-    # fluid.layers.logical_or(x=x, y=y, out=res)
-
-    # Create an executor using CPU as an example
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-
-    # Execute
-    x_i = np.array([[1, 0], [0, 1]]).astype(np.bool)
-    y_i = np.array([[1, 1], [0, 0]]).astype(np.bool)
-    res_val, = exe.run(fluid.default_main_program(), feed={'x':x_i, 'y':y_i}, fetch_list=[res])
-    print(res_val) # [[True, True], [False, True]]
-
+    paddle.enable_imperative()
+    x_data = np.array([True, True, False, False], dtype=np.bool)
+    y_data = np.array([True, False, True, False], dtype=np.bool)
+    x = paddle.imperative.to_variable(x_data)
+    y = paddle.imperative.to_variable(y_data)
+    res = paddle.logical_or(x, y)
+    print(res.numpy()) # [True  True  True False]

doc/fluid/api_cn/layers_cn/logical_xor_cn.rst

@@ -3,27 +3,27 @@
 logical_xor
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.logical_xor(x, y, out=None, name=None)
+.. py:function:: paddle.logical_xor(x, y, out=None, name=None)
 
 :alias_main: paddle.logical_xor
-:alias: paddle.logical_xor,paddle.tensor.logical_xor,paddle.tensor.logic.logical_xor
+:alias: paddle.logical_xor, paddle.tensor.logical_xor, paddle.tensor.logic.logical_xor
 :old_api: paddle.fluid.layers.logical_xor
 
 
 
-该OP逐元素的对 ``X`` 和 ``Y`` 两LoDTensor/Tensor进行逻辑异或运算。
+该OP逐元素的对 ``X`` 和 ``Y`` 进行逻辑异或运算。
 
 .. math::
         Out = (X || Y) \&\& !(X \&\& Y)
 
 参数：
-        - **x** （Variable）- 逻辑异或运算的第一个输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **y** （Variable）- 逻辑异或运算的第二个输入，是一个多维的LoDTensor/Tensor，数据类型只能是bool。
-        - **out** （Variable，可选）- 指定算子输出结果的LoDTensor/Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
+        - **x** （Variable）- 逻辑异或运算的第一个输入，是一个 Variable，数据类型只能是bool。
+        - **y** （Variable）- 逻辑异或运算的第二个输入，是一个 Variable，数据类型只能是bool。
+        - **out** （Variable，可选）- 指定算子输出结果的 Variable，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
         - **name** （str，可选）- 该参数供开发人员打印调试信息时使用，具体用法参见 :ref:`api_guide_Name` ，默认值为None。
 
 
-返回：与 ``x`` 维度相同，数据类型相同的LoDTensor/Tensor。
+返回：与 ``x`` 维度相同，数据类型相同的 Variable。
 
 返回类型：Variable
 
@@ -32,24 +32,13 @@ logical_xor
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle
     import numpy as np
 
-    # Graph organizing
-    x = fluid.layers.data(name='x', shape=[2], dtype='bool')
-    y = fluid.layers.data(name='y', shape=[2], dtype='bool')
-    res = fluid.layers.logical_xor(x=x, y=y)
-    # The comment lists another available method.
-    # res = fluid.layers.fill_constant(shape=[2], dtype='bool', value=0)
-    # fluid.layers.logical_xor(x=x, y=y, out=res)
-
-    # Create an executor using CPU as an example
-    exe = fluid.Executor(fluid.CPUPlace())
-    exe.run(fluid.default_startup_program())
-
-    # Execute
-    x_i = np.array([[1, 0], [0, 1]]).astype(np.bool)
-    y_i = np.array([[1, 1], [0, 0]]).astype(np.bool)
-    res_val, = exe.run(fluid.default_main_program(), feed={'x':x_i, 'y':y_i}, fetch_list=[res])
-    print(res_val) # [[False, True], [False, True]]
-
+    paddle.enable_imperative()
+    x_data = np.array([True, True, False, False], dtype=np.bool)
+    y_data = np.array([True, False, True, False], dtype=np.bool)
+    x = paddle.imperative.to_variable(x_data)
+    y = paddle.imperative.to_variable(y_data)
+    res = paddle.logical_xor(x, y)
+    print(res.numpy()) # [False  True  True False]

doc/fluid/api_cn/layers_cn/elementwise_mul_cn.rst → doc/fluid/api_cn/layers_cn/multiply_cn.rst

-.. _cn_api_fluid_layers_elementwise_mul:
+.. _cn_api_fluid_layers_multiply:
 
-elementwise_mul
+multiply
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.elementwise_mul(x, y, axis=-1, act=None, name=None)
+.. py:function:: paddle.multiply(x, y, axis=-1, name=None)
 
-:alias_main: paddle.elementwise_mul
-:alias: paddle.elementwise_mul,paddle.tensor.elementwise_mul,paddle.tensor.math.elementwise_mul
-:old_api: paddle.fluid.layers.elementwise_mul
+:alias_main: paddle.multiply
+:alias: paddle.multiply, paddle.tensor.multiply, paddle.tensor.math.multiply
 
 
 
@@ -45,8 +44,7 @@ elementwise_mul
         - **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64``。
         - **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64``。
         - **axis** （int32，可选）-  ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。
-        - **act** （str，可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
-        - **name** （str，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
+        - **name** （string，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
 
 
 返回：        维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。
@@ -57,64 +55,22 @@ elementwise_mul
 
 ..  code-block:: python
 
-    import paddle.fluid as fluid
+    import paddle
     import numpy as np
-    def gen_data():
-        return {
-            "x": np.array([2, 3, 4]),
-            "y": np.array([1, 5, 2])
-        }
-    x = fluid.layers.data(name="x", shape=[3], dtype='float32')
-    y = fluid.layers.data(name="y", shape=[3], dtype='float32')
-    z = fluid.layers.elementwise_mul(x, y)
-    # z = x * y
-    place = fluid.CPUPlace()
-    exe = fluid.Executor(place)
-    z_value = exe.run(feed=gen_data(),
-                        fetch_list=[z.name])
-    print(z_value) # [2., 15., 8.]
-
-**代码示例 2**
+    paddle.enable_imperative()
+    x_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+    y_data = np.array([[5, 6], [7, 8]], dtype=np.float32)
+    x = paddle.imperative.to_variable(x_data)
+    y = paddle.imperative.to_variable(y_data)
+    res = paddle.multiply(x, y)
+    print(res.numpy()) # [[5, 12], [21, 32]]
+    x_data = np.array([[[1, 2, 3], [1, 2, 3]]], dtype=np.float32)
+    y_data = np.array([1, 2], dtype=np.float32)
+    x = paddle.imperative.to_variable(x_data)
+    y = paddle.imperative.to_variable(y_data)
+    res = paddle.multiply(x, y, axis=1)
+    print(res.numpy()) # [[[1, 2, 3], [2, 4, 6]]]
 
-..  code-block:: python
-
-    import paddle.fluid as fluid
-    import numpy as np
-    def gen_data():
-        return {
-            "x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
-            "y": np.random.randint(1, 5, size=[3, 4]).astype('float32')
-        }
-    x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
-    y = fluid.layers.data(name="y", shape=[3,4], dtype='float32')
-    z = fluid.layers.elementwise_mul(x, y, axis=1)
-    # z = x * y
-    place = fluid.CPUPlace()
-    exe = fluid.Executor(place)
-    z_value = exe.run(feed=gen_data(),
-                        fetch_list=[z.name])
-    print(z_value) # z.shape=[2,3,4,5]
-
-**代码示例 3**
-
-..  code-block:: python
-
-    import paddle.fluid as fluid
-    import numpy as np
-    def gen_data():
-        return {
-            "x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
-            "y": np.random.randint(1, 5, size=[5]).astype('float32')
-        }
-    x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
-    y = fluid.layers.data(name="y", shape=[5], dtype='float32')
-    z = fluid.layers.elementwise_mul(x, y, axis=3)
-    # z = x * y
-    place = fluid.CPUPlace()
-    exe = fluid.Executor(place)
-    z_value = exe.run(feed=gen_data(),
-                        fetch_list=[z.name])
-    print(z_value) # z.shape=[2,3,4,5]
 
 
 

doc/fluid/api_cn/layers_cn/pow_cn.rst

@@ -3,7 +3,7 @@
 pow
 -------------------------------
 
-.. py:function:: paddle.fluid.layers.pow(x, factor=1.0, name=None)
+.. py:function:: paddle.pow(x, exponent, name=None)
 
 
 
@@ -12,16 +12,16 @@ pow
 
 .. math::
 
-    out = x^{factor}
+    out = x^{exponent}
 
 **注意：如果需要对输入进行 elementwise_pow 操作，请查使用** :ref:`cn_api_fluid_layers_elementwise_pow` 。
 
 参数：
-    - **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` ，数据类型为 ``float32`` 或 ``float64`` 。
-    - **factor** （float32|Variable，可选）- ``float32`` 或形状为[1]的 ``Tensor`` 或 ``LoDTensor``，数据类型为 ``float32``。Pow OP的指数因子。默认值：1.0。
+    - **x** （Variable）- 多维 ``Variable``，数据类型为 ``float32`` 或 ``float64`` 。
+    - **exponent** （float32|Variable）- ``float32`` 或形状为[1]的 ``Variable``，数据类型为 ``float32``。
     - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置。默认值： ``None``。
 
-返回：维度与输入 `x` 相同的 ``Tensor`` 或 ``LoDTensor``，数据类型与 ``x`` 相同。
+返回：维度与输入 `x` 相同的 ``Variable``，数据类型与 ``x`` 相同。
 
 返回类型：Variable。
 
@@ -30,18 +30,23 @@ pow
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+            import paddle
+            import numpy as np
+            x = fluid.data(name="x", shape=[32,32], dtype="float32")
+            paddle.enable_imperative()
             
-    x = fluid.layers.data(name="x", shape=[3,10,32,32], dtype="float32")
+            # example 1: exponent is a float
+            x_data = np.array([1, 2, 3])
+            exponent = 2
+            x = paddle.imperative.to_variable(x_data)
+            res = paddle.pow(x, exponent)
+            print(res.numpy()) # [1 4 9]
             
-    # example 1: argument factor is float
-    y_1 = fluid.layers.pow(x, factor=2.0)
-    # y_1 is x^{2.0}
+            # example 2: exponent is a Variable
+            exponent = paddle.fill_constant(shape=[1], value=2, dtype='float32')
+            res = paddle.pow(x, exponent)
+            print(res.numpy()) # [1 4 9]
 
-    # example 2: argument factor is Variable
-    factor_tensor = fluid.layers.fill_constant([1], "float32", 3.0)
-    y_2 = fluid.layers.pow(x, factor=factor_tensor)
-    # y_2 is x^{3.0}
 
 
 

doc/fluid/api_cn/layers_cn/reciprocal_cn.rst

@@ -29,17 +29,14 @@ reciprocal 对输入Tensor取倒数
 
 .. code-block:: python
 
-        import paddle.fluid as fluid
-        data = fluid.layers.fill_constant(shape=[2], value=4, dtype='float32') #data=[4.0, 4.0]
-        result = fluid.layers.reciprocal(data) # result=[0.25, 0.25]
-
-
-
-
-
-
-
-
+        import paddle
+        import numpy as np
+
+        paddle.enable_imperative()
+        x_data = np.array([1, 2, 3, 4]).astype(np.float32)
+        x = paddle.imperative.to_variable(x_data)
+        res = paddle.%s(x)
+        print(res.numpy())