Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
未验证 提交 d8a5f4e9 编写于 作者: S Shibo Tao 提交者： GitHub
浏览文件
操作

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

上级 5e384297
显示空白变更内容
内联 并排
Showing with 165 addition and 128 deletion
doc/fluid/api_cn/layers_cn/logical_and_cn.rst
浏览文件 @ d8a5f4e9
......@@ -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
浏览文件 @ d8a5f4e9
......@@ -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
浏览文件 @ d8a5f4e9
......@@ -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
浏览文件 @ d8a5f4e9
......@@ -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
浏览文件 @ d8a5f4e9
.. _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
浏览文件 @ d8a5f4e9
......@@ -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
浏览文件 @ d8a5f4e9
......@@ -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())
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或