diff --git a/doc/fluid/api_cn/layers_cn/elementwise_mul_cn.rst b/doc/fluid/api_cn/layers_cn/elementwise_mul_cn.rst deleted file mode 100644 index 9966144b9cd21da0af34a0f64d7c813e7fdb24e1..0000000000000000000000000000000000000000 --- a/doc/fluid/api_cn/layers_cn/elementwise_mul_cn.rst +++ /dev/null @@ -1,123 +0,0 @@ -.. _cn_api_fluid_layers_elementwise_mul: - -elementwise_mul -------------------------------- - -.. py:function:: paddle.fluid.layers.elementwise_mul(x, y, axis=-1, act=None, 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 - - - -该OP是逐元素相乘算子，输入 ``x`` 与输入 ``y`` 逐元素相乘，并将各个位置的输出元素保存到返回结果中。 - -等式是： - -.. math:: - Out = X \odot Y - -- :math:`X` ：多维Tensor。 -- :math:`Y` ：维度必须小于等于X维度的Tensor。 - -对于这个运算算子有2种情况： - 1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。 - 2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。 - -对于情况2: - 1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。 - 2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。 - 3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。 - -例如： - -.. code-block:: text - - shape(X) = (2, 3, 4, 5), shape(Y) = (,) - shape(X) = (2, 3, 4, 5), shape(Y) = (5,) - shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2 - shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1 - shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0 - shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0 - -参数： - - **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` 。 - - -返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。 - -返回类型： Variable。 - -**代码示例 1** - -.. code-block:: python - - import paddle.fluid as fluid - 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** - -.. 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] - - - - - - diff --git a/doc/fluid/api_cn/layers_cn/logical_and_cn.rst b/doc/fluid/api_cn/layers_cn/logical_and_cn.rst index ea44c92c01b258c4135eada7cf0a71eb0fc6f96f..a5b0feeee80da6107ff8a0d2846a2008a74755e6 100644 --- a/doc/fluid/api_cn/layers_cn/logical_and_cn.rst +++ b/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] diff --git a/doc/fluid/api_cn/layers_cn/logical_not_cn.rst b/doc/fluid/api_cn/layers_cn/logical_not_cn.rst index a0a3a2dc5a6b84f3134950273dfb86732fd9d921..3eaf0f1719abac0ce3e63ed2867026f349e76fba 100644 --- a/doc/fluid/api_cn/layers_cn/logical_not_cn.rst +++ b/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] diff --git a/doc/fluid/api_cn/layers_cn/logical_or_cn.rst b/doc/fluid/api_cn/layers_cn/logical_or_cn.rst index b012c7ff4384c2e4193d6a91cdf4d82025103633..b95924ba3104aa1308483ee2f87c6bf43d711c25 100644 --- a/doc/fluid/api_cn/layers_cn/logical_or_cn.rst +++ b/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] diff --git a/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst b/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst index 12a8facec23f92d40b353d0942b2ab6f664d0c49..aefb5230c575fb9679d42b7fdafedaaef99c5dd9 100644 --- a/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst +++ b/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] diff --git a/doc/fluid/api_cn/layers_cn/multiply_cn.rst b/doc/fluid/api_cn/layers_cn/multiply_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..4bb5ee012326ad9ae7ded391a124312f5654b769 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/multiply_cn.rst @@ -0,0 +1,79 @@ +.. _cn_api_fluid_layers_multiply: + +multiply +------------------------------- + +.. py:function:: paddle.multiply(x, y, axis=-1, name=None) + +:alias_main: paddle.multiply +:alias: paddle.multiply, paddle.tensor.multiply, paddle.tensor.math.multiply + + + +该OP是逐元素相乘算子，输入 ``x`` 与输入 ``y`` 逐元素相乘，并将各个位置的输出元素保存到返回结果中。 + +等式是： + +.. math:: + Out = X \odot Y + +- :math:`X` ：多维Tensor。 +- :math:`Y` ：维度必须小于等于X维度的Tensor。 + +对于这个运算算子有2种情况： + 1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。 + 2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。 + +对于情况2: + 1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。 + 2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。 + 3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。 + +例如： + +.. code-block:: text + + shape(X) = (2, 3, 4, 5), shape(Y) = (,) + shape(X) = (2, 3, 4, 5), shape(Y) = (5,) + shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2 + shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1 + shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0 + shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0 + +参数： + - **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。 + - **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。 + - **axis** （int32，可选）- ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。 + - **name** （string，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。 + + +返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。 + +返回类型： Variable。 + +**代码示例 1** + +.. code-block:: python + + import paddle + import numpy as np + 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]]] + + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/pow_cn.rst b/doc/fluid/api_cn/layers_cn/pow_cn.rst index f93dc252abae5678ac6149a2100862a3d48c1971..40eaf542138527856d25a002f16a4cf29c891f47 100644 --- a/doc/fluid/api_cn/layers_cn/pow_cn.rst +++ b/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() + + # 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 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] - x = fluid.layers.data(name="x", shape=[3,10,32,32], dtype="float32") - - # example 1: argument factor is float - y_1 = fluid.layers.pow(x, factor=2.0) - # y_1 is x^{2.0} - - # 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} diff --git a/doc/fluid/api_cn/layers_cn/reciprocal_cn.rst b/doc/fluid/api_cn/layers_cn/reciprocal_cn.rst index 966c82cf90ee0423f37eeb6adbe0871c91caa652..a76a495a5112dc3404510b76bc310ad0b0f78e37 100644 --- a/doc/fluid/api_cn/layers_cn/reciprocal_cn.rst +++ b/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())