diff --git a/doc/paddle/api/paddle/compat/round_cn.rst b/doc/paddle/api/paddle/compat/round_cn.rst deleted file mode 100644 index 7de4214b7e9a993490a07b76b28b62142f1d72d2..0000000000000000000000000000000000000000 --- a/doc/paddle/api/paddle/compat/round_cn.rst +++ /dev/null @@ -1,54 +0,0 @@ -.. _cn_api_fluid_layers_round: - -round -------------------------------- - -.. py:function:: paddle.fluid.layers.round(x, name=None) - -:alias_main: paddle.round -:alias: paddle.round,paddle.tensor.round,paddle.tensor.math.round -:old_api: paddle.fluid.layers.round - - - - -该OP将输入中的数值四舍五入到最接近的整数数值。 - -.. code-block:: python - - 输入： - x.shape = [4] - x.data = [1.2, -0.9, 3.4, 0.9] - - 输出： - out.shape = [4] - Out.data = [1., -1., 3., 1.] - -参数: - - - **x** (Variable) - 支持任意维度的Tensor。数据类型为float32，float64或float16。 - - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 - -返回：返回类型为Variable(Tensor|LoDTensor)， 数据类型同输入一致。 - -**代码示例**： - -.. code-block:: python - - import numpy as np - import paddle.fluid as fluid - - inputs = fluid.layers.data(name="x", shape = [3], dtype='float32') - output = fluid.layers.round(inputs) - - exe = fluid.Executor(fluid.CPUPlace()) - exe.run(fluid.default_startup_program()) - - img = np.array([1.2, -0.9, 3.4, 0.9]).astype(np.float32) - - res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output]) - print(res) - # [array([ 1., -1., 3., 1.], dtype=float32)] - - - diff --git a/doc/paddle/api/paddle/framework/get_default_dtype_cn.rst b/doc/paddle/api/paddle/framework/get_default_dtype_cn.rst index 2a3de92563fc77e44e372830f03f2405fc05104b..cedfe95fb87a30c2038e33484298affc4439c047 100644 --- a/doc/paddle/api/paddle/framework/get_default_dtype_cn.rst +++ b/doc/paddle/api/paddle/framework/get_default_dtype_cn.rst @@ -1,3 +1,23 @@ -get +.. _cn_api_paddle_framework_get_default_dtype: + +get_default_dtype ------------------------------- -**版本升级，文档正在开发中** + +.. py:function:: paddle.get_default_dtype() + + +得到当前全局的dtype。 该值初始是float32。 + + +参数: + + 无 + +返回: string，这个全局dtype仅支持float16、float32、float64 + +**代码示例**： + +.. code-block:: python + + import paddle + paddle.get_default_dtype() diff --git a/doc/paddle/api/paddle/framework/random/manual_seed_cn.rst b/doc/paddle/api/paddle/framework/random/manual_seed_cn.rst index 7f1078e82095c244b02e3b7bcc0516725fe5ef98..7ddf88f632df1a1c4fd6aea961b9cf30d75c682c 100644 --- a/doc/paddle/api/paddle/framework/random/manual_seed_cn.rst +++ b/doc/paddle/api/paddle/framework/random/manual_seed_cn.rst @@ -5,33 +5,20 @@ manual_seed .. py:function:: paddle.framework.manual_seed(seed) -:alias_main: paddle.manual_seed -:alias: paddle.manual_seed,paddle.framework.random.manual_seed - - - -设置并固定随机种子, manual_seed设置后，会将用户定义的Program中的random_seed参数设置成相同的种子 +设置全局默认generator的随机种子。 参数: - - **seed** (int32|int64) - 设置产生随机数的种子 + - **seed** (int) - 要设置的的随机种子，推荐使用较大的整数。 -返回: 无 +返回: + Generator：全局默认generator对象。 **代码示例**： .. code-block:: python import paddle - from paddle.framework import manual_seed - - default_seed = paddle.fluid.default_startup_program().random_seed #default_seed为0 - - manual_seed(102) - prog = paddle.fluid.Program() - prog_seed = prog.random_seed #prog_seed为102 - update_seed = paddle.fluid.default_startup_program().random_seed #update_seed 为102 - - + paddle.manual_seed(102) diff --git a/doc/paddle/api/paddle/framework/set_default_dtype_cn.rst b/doc/paddle/api/paddle/framework/set_default_dtype_cn.rst index 3d7928489a3288e0865dda6e89804d7e997d0d21..9c6c6fe948acb39b526261c9ef92b8eaf4b59858 100644 --- a/doc/paddle/api/paddle/framework/set_default_dtype_cn.rst +++ b/doc/paddle/api/paddle/framework/set_default_dtype_cn.rst @@ -1,3 +1,23 @@ -set +.. _cn_api_paddle_framework_set_default_dtype: + +set_default_dtype ------------------------------- -**版本升级，文档正在开发中** + +.. py:function:: paddle.set_default_dtype(d) + + +设置默认的全局dtype。 默认的全局dtype最初是float32。 + + +参数: + + - **d** (string|np.dtype) - 设为默认值的dtype。 它仅支持float16，float32和float64。 + +返回: 无 + +**代码示例**： + +.. code-block:: python + + import paddle + paddle.set_default_dtype("float32") diff --git a/doc/paddle/api/paddle/nn/layer/common/BilinearTensorProduct_cn.rst b/doc/paddle/api/paddle/nn/layer/common/BilinearTensorProduct_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..59b18c17a32951135e431ef036a6d32771651399 --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/common/BilinearTensorProduct_cn.rst @@ -0,0 +1,68 @@ +.. _cn_api_fluid_dygraph_BilinearTensorProduct: + +BilinearTensorProduct +------------------------------- + +.. py:class:: paddle.fluid.dygraph.BilinearTensorProduct(input1_dim, input2_dim, output_dim, name=None, act=None, param_attr=None, bias_attr=None, dtype="float32") + +:alias_main: paddle.nn.BilinearTensorProduct +:alias: paddle.nn.BilinearTensorProduct,paddle.nn.layer.BilinearTensorProduct,paddle.nn.layer.common.BilinearTensorProduct +:old_api: paddle.fluid.dygraph.BilinearTensorProduct + + + +该接口用于构建 ``BilinearTensorProduct`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。双线性乘积计算式子如下。 + +.. math:: + + out_{i} = x * W_{i} * {y^\mathrm{T}}, i=0,1,...,size-1 + +式中， + +- :math:`x` ： 第一个输入，分别包含M个元素，维度为 :math:`[batch\_size, M]` +- :math:`y` ：第二个输入，分别包含N个元素，维度为 :math:`[batch\_size, N]` +- :math:`W_i` ：第i个学习到的权重，维度为 :math:`[M,N]` +- :math:`out_i` ：输出的第i个元素 +- :math:`y^T` ： :math:`y` 的转置 + + +参数： + - **input1_dim** (int) – 第一个输入的维度大小。 + - **input1_dim** (int) – 第二个输入的维度大小。 + - **output_dim** (int) – 输出的维度。 + - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + - **act** (str，可选) – 对输出应用的激励函数。默认值为None。 + - **param_attr** (ParamAttr) – 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。 + - **bias_attr** (ParamAttr) – 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr`。 + - **dtype** (str, 可选) - 数据类型，可以为"float32"或"float64"。默认值为"float32"。 + +返回：维度为[batch_size, size]的2D Tensor，数据类型与输入数据类型相同。 + +返回类型： Variable + +**代码示例** + +.. code-block:: python + + import paddle.fluid as fluid + import numpy + + with fluid.dygraph.guard(): + layer1 = numpy.random.random((5, 5)).astype('float32') + layer2 = numpy.random.random((5, 4)).astype('float32') + bilinearTensorProduct = fluid.dygraph.nn.BilinearTensorProduct( + input1_dim=5, input2_dim=4, output_dim=1000) + ret = bilinearTensorProduct(fluid.dygraph.base.to_variable(layer1), + fluid.dygraph.base.to_variable(layer2)) + +属性 +:::::::::::: +.. py:attribute:: weight + +本层的可学习参数，类型为 ``Parameter`` + +.. py:attribute:: bias + +本层的可学习偏置，类型为 ``Parameter`` + + diff --git a/doc/paddle/api/paddle/nn/layer/common/Bilinear_cn.rst b/doc/paddle/api/paddle/nn/layer/common/Bilinear_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..55ccb27c78fdfea567ed8195aa6fd0828ee64cc6 --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/common/Bilinear_cn.rst @@ -0,0 +1,59 @@ +.. _cn_api_nn_Bilinear: + +Bilinear +------------------------------- + +.. py:function:: paddle.nn.Bilinear(in1_features, in2_features, out_features, weight_attr=None, bias_attr=None, name=None) + +该层对两个输入执行双线性张量积。 + +例如: + +.. math:: + + out_{i} = x1 * W_{i} * {x2^\mathrm{T}}, i=0,1,...,size-1 + + out = out + b + +在这个公式中： + - :math:`x1`: 第一个输入，包含 :in1_features个元素，形状为 [batch_size, in1_features]。 + - :math:`x2`: 第二个输入，包含 :in2_features个元素，形状为 [batch_size, in2_features]。 + - :math:`W_{i}`: 第 :i个被学习的权重，形状是 [in1_features, in2_features]。 + - :math:`out_{i}`: 输出的第 :i个元素，形状是 [batch_size, out_features]。 + - :math:`b`: 被学习的偏置参数，形状是 [1, out_features]。 + - :math:`x2^\mathrm{T}`: :math:`x2` 的转置。 + +参数 +::::::::: + - **in1_features** (int): 每个 **x1** 元素的维度。 + - **in2_features** (int): 每个 **x2** 元素的维度。 + - **out_features** (int): 输出张量的维度。 + - **weight_attr** (ParamAttr，可选) ：指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。 + - **bias_attr** (ParamAttr，可选) : 指定偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性，此时bias的元素会被初始化成0。如果设置成False，则不会有bias加到output结果上。 + - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None。 + +属性 +::::::::: + - **weight** 本层的可学习参数，类型为 Parameter + - **bias** 本层的可学习偏置，类型为 Parameter + +返回 +::::::::: +``Tensor``，一个形为 [batch_size, out_features] 的 2-D 张量。 + +代码示例 +::::::::: + +.. code-block:: python + + import paddle + import numpy + + paddle.disable_static() + layer1 = numpy.random.random((5, 5)).astype('float32') + layer2 = numpy.random.random((5, 4)).astype('float32') + bilinear = paddle.nn.Bilinear( + in1_features=5, in2_features=4, out_features=1000) + result = bilinear(paddle.to_tensor(layer1), + paddle.to_tensor(layer2)) # result shape [5, 1000] + diff --git a/doc/paddle/api/paddle/nn/layer/common/ConstantPad1d_cn.rst b/doc/paddle/api/paddle/nn/layer/common/ConstantPad1d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..d7025d80e873242b892d0e1deda4bcac895b2e37 --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/common/ConstantPad1d_cn.rst @@ -0,0 +1,36 @@ +.. _cn_api_nn_ConstantPad1d: + +ConstantPad1d +------------------------------- +.. py:class:: paddle.nn.ConstantPad1d(padding, value=0.0, data_format="NCL", name=None) + +**ConstantPad1d** + +按照 padding 对输入 以constant模式进行 ``pad``，即填充固定值。 + +参数： + - **padding** (Tensor | List[int32]) - 填充大小。pad的格式为[pad_left, pad_right]。 + - **value** (float32) - 待填充的值，默认值为0.0。 + - **data_format** (str) - 指定input的format，可为 `'NCL'` 或者 `'NLC'`，默认值为`'NCL'`。 + - **name** (str, 可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，缺省值为None。 + +返回：无 + +**代码示例** + +.. code-block:: python + + import paddle + import paddle.nn as nn + import numpy as np + paddle.disable_static() + + input_shape = (1, 2, 3) + pad = [1, 2] + data = np.arange(np.prod(input_shape), dtype=np.float32).reshape(input_shape) + 1 + my_pad = nn.ConstantPad1d(padding=pad) + data = paddle.to_tensor(data) + result = my_pad(data) + print(result.numpy()) + # [[[0. 1. 2. 3. 0. 0.] + # [0. 4. 5. 6. 0. 0.]]] diff --git a/doc/paddle/api/paddle/nn/layer/common/ConstantPad2d_cn.rst b/doc/paddle/api/paddle/nn/layer/common/ConstantPad2d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..3e8f3e14a80fa3b1e8bd78656fb66b2eb38e9f6d --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/common/ConstantPad2d_cn.rst @@ -0,0 +1,39 @@ +.. _cn_api_nn_ConstantPad2d: + +ConstantPad2d +------------------------------- +.. py:class:: paddle.nn.ConstantPad2d(padding, value=0.0, data_format="NCHW", name=None) + +**ConstantPad2d** + +按照 padding 对输入 以constant模式进行 ``pad``，即填充固定值。 + +参数： + - **padding** (Tensor | List[int32]) - 填充大小。pad的格式为[pad_left, pad_right, pad_top, pad_bottom]。 + - **value** (float32) - 待填充的值，默认值为0.0。 + - **data_format** (str) - 指定input的format，可为 `'NCHW'` 或者 `'NHWC'`，默认值为`'NCHW'`。 + - **name** (str, 可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，缺省值为None。 + +返回：无 + +**代码示例** + +.. code-block:: python + + import paddle + import paddle.nn as nn + import numpy as np + paddle.disable_static() + + input_shape = (1, 1, 2, 3) + pad = [1, 0, 1, 2] + data = np.arange(np.prod(input_shape), dtype=np.float32).reshape(input_shape) + 1 + my_pad = nn.ConstantPad2d(padding=pad) + data = paddle.to_tensor(data) + result = my_pad(data) + print(result.numpy()) + # [[[[0. 0. 0. 0.] + # [0. 1. 2. 3.] + # [0. 4. 5. 6.] + # [0. 0. 0. 0.] + # [0. 0. 0. 0.]]]] diff --git a/doc/paddle/api/paddle/nn/layer/common/ConstantPad3d_cn.rst b/doc/paddle/api/paddle/nn/layer/common/ConstantPad3d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..35ad8aa795d3d0704f7dbac79ba06b6cd5223b7c --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/common/ConstantPad3d_cn.rst @@ -0,0 +1,39 @@ +.. _cn_api_nn_ConstantPad3d: + +ConstantPad3d +------------------------------- +.. py:class:: paddle.nn.ConstantPad3d(padding, value=0.0, data_format="NCDHW", name=None) + +**ConstantPad3d** + +按照 padding 对输入 以constant模式进行 ``pad``，即填充固定值。 + +参数： + - **padding** (Tensor | List[int32]) - 填充大小。pad的格式为[pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_back]。 + - **value** (float32) - 待填充的值，默认值为0.0。 + - **data_format** (str) - 指定input的format，可为 `'NCDHW'` 或者 `'NDHWC'`，默认值为`'NCDHW'`。 + - **name** (str, 可选) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，缺省值为None。 + +返回：无 + +**代码示例** + +.. code-block:: python + + import paddle + import paddle.nn as nn + import numpy as np + paddle.disable_static() + + input_shape = (1, 1, 1, 2, 3) + pad = [1, 0, 1, 2, 0, 0] + data = np.arange(np.prod(input_shape), dtype=np.float32).reshape(input_shape) + 1 + my_pad = nn.ConstantPad3d(padding=pad) + data = paddle.to_tensor(data) + result = my_pad(data) + print(result.numpy()) + # [[[[[0. 0. 0. 0.] + # [0. 1. 2. 3.] + # [0. 4. 5. 6.] + # [0. 0. 0. 0.] + # [0. 0. 0. 0.]]]]] diff --git a/doc/paddle/api/paddle/nn/layer/norm/BatchNorm1d_cn.rst b/doc/paddle/api/paddle/nn/layer/norm/BatchNorm1d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..3d62b0d1fb74c0e091a5e9259e5131291a26a477 --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/norm/BatchNorm1d_cn.rst @@ -0,0 +1,74 @@ +.. _cn_api_nn_BatchNorm1d: + +BatchNorm1d +------------------------------- + +.. py:class:: paddle.nn.BatchNorm1d(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCL', track_running_stats=True, name=None): + + +该接口用于构建 ``BatchNorm1d`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。可以处理2D或者3D的Tensor, 实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考 : `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift `_ + +当训练时 :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是minibatch的统计数据。计算公式如下： + +.. math:: + \mu_{\beta} &\gets \frac{1}{m} \sum_{i=1}^{m} x_i \quad &// mini-batch-mean \\ + \sigma_{\beta}^{2} &\gets \frac{1}{m} \sum_{i=1}^{m}(x_i - \mu_{\beta})^2 \quad &// mini-batch-variance \\ + +- :math:`x` : 批输入数据 +- :math:`m` : 当前批次数据的大小 + +当预测时，track_running_stats = True :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是全局（或运行）统计数据（moving_mean和moving_variance），通常来自预先训练好的模型。计算公式如下： + +.. math:: + + moving\_mean = moving\_mean * momentum + \mu_{\beta} * (1. - momentum) \quad &// global mean \\ + moving\_variance = moving\_variance * momentum + \sigma_{\beta}^{2} * (1. - momentum) \quad &// global variance \\ + +归一化函数公式如下： + +.. math:: + + \hat{x_i} &\gets \frac{x_i - \mu_\beta} {\sqrt{\sigma_{\beta}^{2} + \epsilon}} \quad &// normalize \\ + y_i &\gets \gamma \hat{x_i} + \beta \quad &// scale-and-shift \\ + +- :math:`\epsilon` : 添加较小的值到方差中以防止除零 +- :math:`\gamma` : 可训练的比例参数 +- :math:`\beta` : 可训练的偏差参数 + +参数： + - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。 + - **epsilon** (float, 可选) - 为了数值稳定加在分母上的值。默认值：1e-05。 + - **momentum** (float, 可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var`` 。默认值：0.9。更新公式如上所示。 + - **weight_attr** (ParamAttr|bool, 可选) - 指定权重参数属性的对象。如果为False, 则表示每个通道的伸缩固定为1，不可改变。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_ParamAttr` 。 + - **bias_attr** (ParamAttr, 可选) - 指定偏置参数属性的对象。如果为False, 则表示每一个通道的偏移固定为0，不可改变。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_ParamAttr` 。 + - **data_format** (string, 可选) - 指定输入数据格式，数据格式可以为“NC"或者"NCL"。默认值：“NCL”。 + - **track_running_stats** (bool, 可选) – 指示是否使用全局均值和方差。在训练时，设置为True表示在训练期间将保存全局均值和方差用于推理。推理时此属性只能设置为True。默认值：True。 + - **name** (string, 可选) – BatchNorm的名称, 默认值为None。更多信息请参见 :ref:`api_guide_Name` 。 + + +返回：无 + +形状： + - input: 形状为（批大小，通道数）的2-D Tensor 或（批大小, 通道数，长度）的3-D Tensor。 + - output: 和输入形状一样。 + +.. note:: +目前训练时设置track_running_stats为False是无效的，实际还是会按照True的方案保存全局均值和方差。之后的版本会修复此问题。 + + +**代码示例** + +.. code-block:: python + + import paddle + import numpy as np + + paddle.disable_static() + np.random.seed(123) + x_data = np.random.random(size=(2, 1, 3)).astype('float32') + x = paddle.to_tensor(x_data) + batch_norm = paddle.nn.BatchNorm1d(1) + batch_norm_out = batch_norm(x) + + print(batch_norm_out.numpy) + diff --git a/doc/paddle/api/paddle/nn/layer/norm/BatchNorm2d_cn.rst b/doc/paddle/api/paddle/nn/layer/norm/BatchNorm2d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..38fad62b9505bb0631776fb57372a0b303f0c16c --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/norm/BatchNorm2d_cn.rst @@ -0,0 +1,74 @@ +.. _cn_api_nn_BatchNorm2d: + +BatchNorm2d +------------------------------- + +.. py:class:: paddle.nn.BatchNorm2d(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCHW', track_running_stats=True, name=None): + + +该接口用于构建 ``BatchNorm2d`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。可以处理4D的Tensor, 实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考 : `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift `_ + +当训练时 :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是minibatch的统计数据。计算公式如下： + +.. math:: + \mu_{\beta} &\gets \frac{1}{m} \sum_{i=1}^{m} x_i \quad &// mini-batch-mean \\ + \sigma_{\beta}^{2} &\gets \frac{1}{m} \sum_{i=1}^{m}(x_i - \mu_{\beta})^2 \quad &// mini-batch-variance \\ + +- :math:`x` : 批输入数据 +- :math:`m` : 当前批次数据的大小 + +当预测时，track_running_stats = True :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是全局（或运行）统计数据（moving_mean和moving_variance），通常来自预先训练好的模型。计算公式如下： + +.. math:: + + moving\_mean = moving\_mean * momentum + \mu_{\beta} * (1. - momentum) \quad &// global mean \\ + moving\_variance = moving\_variance * momentum + \sigma_{\beta}^{2} * (1. - momentum) \quad &// global variance \\ + +归一化函数公式如下： + +.. math:: + + \hat{x_i} &\gets \frac{x_i - \mu_\beta} {\sqrt{\sigma_{\beta}^{2} + \epsilon}} \quad &// normalize \\ + y_i &\gets \gamma \hat{x_i} + \beta \quad &// scale-and-shift \\ + +- :math:`\epsilon` : 添加较小的值到方差中以防止除零 +- :math:`\gamma` : 可训练的比例参数 +- :math:`\beta` : 可训练的偏差参数 + +参数： + - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。 + - **epsilon** (float, 可选) - 为了数值稳定加在分母上的值。默认值：1e-05。 + - **momentum** (float, 可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var`` 。默认值：0.9。更新公式如上所示。 + - **weight_attr** (ParamAttr|bool, 可选) - 指定权重参数属性的对象。如果为False, 则表示每个通道的伸缩固定为1，不可改变。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_ParamAttr` 。 + - **bias_attr** (ParamAttr, 可选) - 指定偏置参数属性的对象。如果为False, 则表示每一个通道的偏移固定为0，不可改变。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_ParamAttr` 。 + - **data_format** (string, 可选) - 指定输入数据格式，数据格式可以为“NCWH"或者"NCHW"。默认值：“NCHW”。 + - **track_running_stats** (bool, 可选) – 指示是否使用全局均值和方差。在训练时，设置为True表示在训练期间将保存全局均值和方差用于推理。推理时此属性只能设置为True。默认值：True。 + - **name** (string, 可选) – BatchNorm的名称, 默认值为None。更多信息请参见 :ref:`api_guide_Name` 。 + + +返回：无 + +形状： + - input: 形状为（批大小，通道数, 高度，宽度）的4-D Tensor 或（批大小, 通道数，宽度，高度）的4-D Tensor。 + - output: 和输入形状一样。 + +.. note:: +目前训练时设置track_running_stats为False是无效的，实际还是会按照True的方案保存全局均值和方差。之后的版本会修复此问题。 + + +**代码示例** + +.. code-block:: python + + import paddle + import numpy as np + + paddle.disable_static() + np.random.seed(123) + x_data = np.random.random(size=(2, 1, 2, 3)).astype('float32') + x = paddle.to_tensor(x_data) + batch_norm = paddle.nn.BatchNorm2d(1) + batch_norm_out = batch_norm(x) + + print(batch_norm_out.numpy) + diff --git a/doc/paddle/api/paddle/nn/layer/norm/BatchNorm3d_cn.rst b/doc/paddle/api/paddle/nn/layer/norm/BatchNorm3d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..9121aa9d9a445f07da9d38637c7574b749bbcadf --- /dev/null +++ b/doc/paddle/api/paddle/nn/layer/norm/BatchNorm3d_cn.rst @@ -0,0 +1,74 @@ +.. _cn_api_nn_BatchNorm3d: + +BatchNorm3d +------------------------------- + +.. py:class:: paddle.nn.BatchNorm3d(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCDHW', track_running_stats=True, name=None): + + +该接口用于构建 ``BatchNorm3d`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。可以处理4D的Tensor, 实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考 : `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift `_ + +当训练时 :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是minibatch的统计数据。计算公式如下： + +.. math:: + \mu_{\beta} &\gets \frac{1}{m} \sum_{i=1}^{m} x_i \quad &// mini-batch-mean \\ + \sigma_{\beta}^{2} &\gets \frac{1}{m} \sum_{i=1}^{m}(x_i - \mu_{\beta})^2 \quad &// mini-batch-variance \\ + +- :math:`x` : 批输入数据 +- :math:`m` : 当前批次数据的大小 + +当预测时，track_running_stats = True :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是全局（或运行）统计数据（moving_mean和moving_variance），通常来自预先训练好的模型。计算公式如下： + +.. math:: + + moving\_mean = moving\_mean * momentum + \mu_{\beta} * (1. - momentum) \quad &// global mean \\ + moving\_variance = moving\_variance * momentum + \sigma_{\beta}^{2} * (1. - momentum) \quad &// global variance \\ + +归一化函数公式如下： + +.. math:: + + \hat{x_i} &\gets \frac{x_i - \mu_\beta} {\sqrt{\sigma_{\beta}^{2} + \epsilon}} \quad &// normalize \\ + y_i &\gets \gamma \hat{x_i} + \beta \quad &// scale-and-shift \\ + +- :math:`\epsilon` : 添加较小的值到方差中以防止除零 +- :math:`\gamma` : 可训练的比例参数 +- :math:`\beta` : 可训练的偏差参数 + +参数： + - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。 + - **epsilon** (float, 可选) - 为了数值稳定加在分母上的值。默认值：1e-05。 + - **momentum** (float, 可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var`` 。默认值：0.9。更新公式如上所示。 + - **weight_attr** (ParamAttr|bool, 可选) - 指定权重参数属性的对象。如果为False, 则表示每个通道的伸缩固定为1，不可改变。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_ParamAttr` 。 + - **bias_attr** (ParamAttr, 可选) - 指定偏置参数属性的对象。如果为False, 则表示每一个通道的偏移固定为0，不可改变。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_ParamAttr` 。 + - **data_format** (string, 可选) - 指定输入数据格式，数据格式可以为“NCDHW"。默认值：“NCDHW”。 + - **track_running_stats** (bool, 可选) – 指示是否使用全局均值和方差。在训练时，设置为True表示在训练期间将保存全局均值和方差用于推理。推理时此属性只能设置为True。默认值：True。 + - **name** (string, 可选) – BatchNorm的名称, 默认值为None。更多信息请参见 :ref:`api_guide_Name` 。 + + +返回：无 + +形状： + - input: 形状为（批大小，通道数, 维度，高度，宽度）的5-D Tensor。 + - output: 和输入形状一样。 + +.. note:: +目前训练时设置track_running_stats为False是无效的，实际还是会按照True的方案保存全局均值和方差。之后的版本会修复此问题。 + + +**代码示例** + +.. code-block:: python + + import paddle + import numpy as np + + paddle.disable_static() + np.random.seed(123) + x_data = np.random.random(size=(2, 1, 2, 2, 3)).astype('float32') + x = paddle.to_tensor(x_data) + batch_norm = paddle.nn.BatchNorm3d(1) + batch_norm_out = batch_norm(x) + + print(batch_norm_out.numpy) + diff --git a/doc/paddle/api/paddle/tensor/creation/eye_cn.rst b/doc/paddle/api/paddle/tensor/creation/eye_cn.rst index b0fb8b5ecb68711e3d196c92beaa87f9bb6e10fc..c105c4b06b517488c1f0100ffb4cd4ee26ac8f89 100644 --- a/doc/paddle/api/paddle/tensor/creation/eye_cn.rst +++ b/doc/paddle/api/paddle/tensor/creation/eye_cn.rst @@ -1,21 +1,19 @@ -.. _cn_api_fluid_layers_eye: +.. _cn_api_paddle_tensor_eye: eye ------------------------------- -.. py:function:: paddle.fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype='float32', name=None) +.. py:function:: paddle.tensor.eye(num_rows, num_columns=None, dtype=None, name=None) - -该OP用来构建二维Tensor，或一个批次的二维Tensor。 +该OP用来构建二维Tensor(主对角线元素为1，其他元素为0)。 参数： - - **num_rows** (int) - 该批次二维Tensor的行数，数据类型为非负int32。 - - **num_columns** (int, 可选) - 该批次二维Tensor的列数，数据类型为非负int32。若为None，则默认等于num_rows。 - - **batch_shape** (list(int), 可选) - 如若提供，则返回Tensor的主批次维度将为batch_shape。 - - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) - 返回Tensor的数据类型，可为int32，int64，float16，float32，float64，默认数据类型为float32。 - - **name** (str) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。 - -返回： ``shape`` 为batch_shape + [num_rows, num_columns]的Tensor。 + - **num_rows** (int) - 生成2-D Tensor的行数，数据类型为非负int32。 + - **num_columns** (int，可选) - 生成2-D Tensor的列数，数据类型为非负int32。若为None，则默认等于num_rows。 + - **dtype** (np.dtype|str， 可选) - 返回Tensor的数据类型，可为float16，float32，float64， int32， int64。若为None, 则默认等于float32。 + - **name** （str， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + +返回： ``shape`` 为 [num_rows, num_columns]的Tensor。 抛出异常： @@ -26,21 +24,15 @@ eye .. code-block:: python - import paddle.fluid as fluid - data = fluid.layers.eye(3, dtype='int32') - # [[1, 0, 0] - # [0, 1, 0] - # [0, 0, 1]] - - data = fluid.layers.eye(2, 3, dtype='int32') - # [[1, 0, 0] - # [0, 1, 0]] - - data = fluid.layers.eye(2, batch_shape=[3]) - # Construct a batch of 3 identity tensors, each 2 x 2. - # data[i, :, :] is a 2 x 2 identity tensor, i = 0, 1, 2. - - + import paddle + paddle.disable_static() # Now we are in imperative mode + data = paddle.eye(3, dtype='int32') + # [[1 0 0] + # [0 1 0] + # [0 0 1]] + data = paddle.eye(2, 3, dtype='int32') + # [[1 0 0] + # [0 1 0]] diff --git a/doc/paddle/api/paddle/tensor/creation/ones_cn.rst b/doc/paddle/api/paddle/tensor/creation/ones_cn.rst index 32a6b2a57cc35d8715ed0d5278d2acaeb2dcce45..05e9ded48eab47f1a2530e8f45f11a727fd71796 100644 --- a/doc/paddle/api/paddle/tensor/creation/ones_cn.rst +++ b/doc/paddle/api/paddle/tensor/creation/ones_cn.rst @@ -1,26 +1,46 @@ -.. _cn_api_fluid_layers_ones: +.. _cn_api_tensor_ones: ones ------------------------------- -.. py:function:: paddle.fluid.layers.ones(shape,dtype,force_cpu=False) +.. py:function:: paddle.ones(shape, dtype=None) + + 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor。 参数： - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。 - - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。 - - **force_cpu** (bool， 可选) – 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。 + - **dtype** (np.dtype|str， 可选) - 输出Tensor的数据类型，数据类型必须为bool、 float16、float32、float64、int32或int64。如果 ``dtype`` 为None，默认数据类型为float32。 + - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 返回：值全为1的Tensor，数据类型和 ``dtype`` 定义的类型一致。 + 抛出异常： - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。 - - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时， 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。 + - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor的时， 当 ``shape`` 为Tensor时，其数据类型不是int32或者int64。 **代码示例**： .. code-block:: python - import paddle.fluid as fluid - data = fluid.layers.ones(shape=[2, 4], dtype='float32') # [[1., 1., 1., 1.], [1., 1., 1., 1.]] + import paddle + + paddle.disable_static() + + #default dtype for ones OP + data1 = paddle.ones(shape=[3, 2]) + # [[1. 1.] + # [1. 1.] + # [1. 1.]] + data2 = paddle.ones(shape=[2, 2], dtype='int32') + # [[1 1] + # [1 1]] + + #attr shape is a Variable Tensor + shape = paddle.fill_constant(shape=[2], dtype='int32', value=2) + data3 = paddle.ones(shape=shape, dtype='int32') + # [[1 1] + # [1 1]] + diff --git a/doc/paddle/api/paddle/tensor/creation/ones_like_cn.rst b/doc/paddle/api/paddle/tensor/creation/ones_like_cn.rst index 5d1e6a89788690d771f0d1cb986e4bcf425e5968..33b189c7aaeebf5cc9f54f9f3d4fca38cb5de752 100644 --- a/doc/paddle/api/paddle/tensor/creation/ones_like_cn.rst +++ b/doc/paddle/api/paddle/tensor/creation/ones_like_cn.rst @@ -1,34 +1,39 @@ -.. _cn_api_fluid_layers_ones_like: +.. _cn_api_tensor_ones_like: ones_like ------------------------------- -.. py:function:: paddle.fluid.layers.ones_like(x, out=None) +.. py:function:: paddle.ones_like(x, dtype=None, name=None) +:alias_main: paddle.ones_like +:alias: paddle.tensor.ones_like, paddle.tensor.creation.ones_like +该OP返回一个和 ``x`` 具有相同形状的数值都为1的Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。 +参数 +:::::::::: + - **x** (Tensor) – 输入的Tensor，数据类型可以是bool，float16, float32，float64，int32，int64。输出Tensor的形状和 ``x`` 相同。如果 ``dtype`` 为None，则输出Tensor的数据类型与 ``x`` 相同。 + - **dtype** (str|np.dtype|core.VarDesc.VarType, 可选) - 输出Tensor的数据类型，支持bool，float16, float32，float64，int32，int64。当该参数值为None时， 输出Tensor的数据类型与 ``x`` 相同。默认值为None. + - **name** (str, 可选) - 输出的名字。一般无需设置，默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。 + +返回 +:::::::::: + Tensor：和 ``x`` 具有相同形状的数值都为1的Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。 -ones_like - -该功能创建一个形状与类型与x相似的张量，初始值为1。 - - -参数： - - **x** (Variable) - 指定形状与数据类型的输入张量 - - **out** (Variable)-输出张量 +抛出异常 +:::::::::: + - ``TypeError`` - 如果 ``dtype`` 不是bool、float16、float32、float64、int32、int64。 -返回：输出张量 - -返回类型：变量（Variable） - -**代码示例**： +代码示例 +:::::::::: .. code-block:: python - import paddle.fluid as fluid - - x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False) - data = fluid.layers.ones_like(x) # [1.0, 1.0, 1.0] - + import paddle + import numpy as np + paddle.enable_imperative() + x = paddle.imperative.to_variable(np.array([1,2,3], dtype='float32')) + out1 = paddle.ones_like(x) # [1., 1., 1.] + out2 = paddle.ones_like(x, dtype='int32') # [1, 1, 1] diff --git a/doc/paddle/api/paddle/tensor/creation/zeros_cn.rst b/doc/paddle/api/paddle/tensor/creation/zeros_cn.rst index 7206c16aceb53b047f301d720a1c3ff61147e946..40e54e0daaeb91e9bf2d15b4f32ce65a987748e7 100644 --- a/doc/paddle/api/paddle/tensor/creation/zeros_cn.rst +++ b/doc/paddle/api/paddle/tensor/creation/zeros_cn.rst @@ -1,26 +1,43 @@ -.. _cn_api_fluid_layers_zeros: +.. _cn_api_tensor_zeros: zeros ------------------------------- -.. py:function:: paddle.fluid.layers.zeros(shape,dtype,force_cpu=False) +.. py:function:: paddle.zeros(shape, dtype=None, name=None) + + 该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor。 参数： - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。 - - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。 - - **force_cpu** (bool， 可选) - 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。 + - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) - 输出Tensor的数据类型，数据类型必须为bool、float16、float32、float64、int32或int64。若为None，数据类型为float32， 默认为None。 + - **name** (str, 可选) - 输出的名字。一般无需设置，默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。 返回：值全为0的Tensor，数据类型和 ``dtype`` 定义的类型一致。 抛出异常： - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。 - - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时。 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。 + - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时， 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。 **代码示例**： .. code-block:: python - import paddle.fluid as fluid - data = fluid.layers.zeros(shape=[3, 2], dtype='float32') # [[0., 0.], [0., 0.], [0., 0.]] + import paddle + paddle.disable_static() # Now we are in imperative mode + data = paddle.zeros(shape=[3, 2], dtype='float32') + # [[0. 0.] + # [0. 0.] + # [0. 0.]] + + data = paddle.zeros(shape=[2, 2]) + # [[0. 0.] + # [0. 0.]] + + # shape is a Tensor + shape = paddle.fill_constant(shape=[2], dtype='int32', value=2) + data3 = paddle.zeros(shape=shape, dtype='int32') + # [[0 0] + # [0 0]] + diff --git a/doc/paddle/api/paddle/tensor/creation/zeros_like_cn.rst b/doc/paddle/api/paddle/tensor/creation/zeros_like_cn.rst index d75dc7cd1029a8bacaa2e69b28304305c68b5602..7cdacfeb44ff8553cc98230f10e309340dab5cd7 100644 --- a/doc/paddle/api/paddle/tensor/creation/zeros_like_cn.rst +++ b/doc/paddle/api/paddle/tensor/creation/zeros_like_cn.rst @@ -1,29 +1,40 @@ -.. _cn_api_fluid_layers_zeros_like: +.. _cn_api_tensor_zeros_like: zeros_like ------------------------------- -.. py:function:: paddle.fluid.layers.zeros_like(x, out=None) +.. py:function:: paddle.zeros_like(x, dtype=None, name=None) +:alias_main: paddle.zeros_like +:alias: paddle.tensor.zeros_like, paddle.tensor.creation.zeros_like +:update_api: paddle.fluid.layers.zeros_like +该OP返回一个和 ``x`` 具有相同的形状的全零Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。 - - -该OP创建一个和x具有相同的形状和数据类型的全零Tensor。 - -参数： - - **x** (Variable) – 指定输入为一个多维的Tensor，数据类型可以是bool，float32，float64，int32，int64。 - - **out** (Variable|可选) – 如果为None，则创建一个Variable作为输出，创建后的Variable的数据类型，shape大小和输入变量x一致。如果是输入的一个Tensor，数据类型和数据shape大小需要和输入变量x一致。默认值为None。 +参数 +:::::::::: + - **x** (Tensor) – 输入的多维Tensor，数据类型可以是bool，float16, float32，float64，int32，int64。输出Tensor的形状和 ``x`` 相同。如果 ``dtype`` 为None，则输出Tensor的数据类型与 ``x`` 相同。 + - **dtype** (str|np.dtype|core.VarDesc.VarType, 可选) - 输出Tensor的数据类型，支持bool，float16, float32，float64，int32，int64。当该参数值为None时， 输出Tensor的数据类型与 ``x`` 相同。默认值为None. + - **name** (str, 可选) - 输出的名字。一般无需设置，默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。 -返回：返回一个多维的Tensor，具体的元素值和输入的数据类型相关，如果是bool类型的，则全False，其它均为0。数据shape大小和输入x一致。 +返回 +:::::::::: + Tensor：和 ``x`` 具有相同的形状全零Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。 -返回类型：Variable +抛出异常 +:::::::::: + - ``TypeError`` - 如果 ``dtype`` 不是bool、float16、float32、float64、int32、int64。 -**代码示例**： +代码示例 +:::::::::: .. code-block:: python - import paddle.fluid as fluid - x = fluid.data(name='x', dtype='float32', shape=[3]) - data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0] + import paddle + import numpy as np + + paddle.enable_imperative() + x = paddle.imperative.to_variable(np.array([1,2,3], dtype='float32')) + out1 = paddle.zeros_like(x) # [0., 0., 0.] + out2 = paddle.zeros_like(x, dtype='int32') # [0, 0, 0] diff --git a/doc/paddle/api/paddle/tensor/linalg/matmul_cn.rst b/doc/paddle/api/paddle/tensor/linalg/matmul_cn.rst index 8514a410c290fe9de6004751329d2439772bcd99..c12ac055bb88cb94f32f91554f72684a3852da70 100644 --- a/doc/paddle/api/paddle/tensor/linalg/matmul_cn.rst +++ b/doc/paddle/api/paddle/tensor/linalg/matmul_cn.rst @@ -1,104 +1,93 @@ -.. _cn_api_fluid_layers_matmul: +.. _cn_api_tensor_matmul: matmul ------------------------------- -.. py:function:: paddle.fluid.layers.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None) +.. py:function:: paddle.matmul(x, y, transpose_x=False, transpose_y=False, name=None) +该op是计算两个Tensor的乘积，遵循完整的广播规则，关于广播规则，请参考 :ref:`use_guide_broadcasting` 。 +并且其行为与 ``numpy.matmul`` 一致。目前，输入张量的维数可以是任意数量， ``matmul`` 可以用于 +实现 ``dot`` ， ``matmul`` 和 ``batchmatmul`` 。实际行为取决于输入 ``x`` 、输入 ``y`` 、 ``transpose_x`` ， +``transpose_y`` 。具体如下： +- 如果 ``transpose`` 为真，则对应 Tensor 的后两维会转置。如果Tensor的一维，则转置无效。假定 ``x`` 是一个 shape=[D] 的一维 Tensor，则 ``x`` 视为 [1, D]。然而， ``y`` 是一个shape=[D]的一维Tensor，则视为[D, 1]。 +乘法行为取决于 ``x`` 和 ``y`` 的尺寸。 具体如下： -输入 ``x`` 和输入 ``y`` 矩阵相乘。 +- 如果两个张量均为一维，则获得点积结果。 -两个输入的形状可为任意维度，但当任一输入维度大于3时，两个输入的维度必须相等。 -实际的操作取决于 ``x`` 、 ``y`` 的维度和 ``transpose_x`` 、 ``transpose_y`` 的布尔值。具体如下： +- 如果两个张量都是二维的，则获得矩阵与矩阵的乘积。 -- 如果 ``transpose`` 为真，则对应 Tensor 的后两维会转置。假定 ``x`` 是一个 shape=[D] 的一维 Tensor，则 ``x`` 非转置形状为 [1, D]，转置形状为 [D, 1]。转置之后的输入形状需满足矩阵乘法要求，即 `x_width` 与 `y_height` 相等。 +- 如果 ``x`` 是1维的，而 ``y`` 是2维的，则将1放在 ``x`` 维度之前，以进行矩阵乘法。矩阵相乘后，将删除前置尺寸。 -- 转置后，输入的两个 Tensor 维度将为 2-D 或 n-D，将根据下列规则矩阵相乘： - - 如果两个矩阵都是 2-D，则同普通矩阵一样进行矩阵相乘。 - - 如果任意一个矩阵是 n-D，则将其视为带 batch 的二维矩阵乘法。 +- 如果 ``x`` 是2维的，而 ``y`` 是1维的，获得矩阵与向量的乘积。 -- 如果原始 Tensor x 或 y 的秩为 1 且未转置，则矩阵相乘后的前置或附加维度 1 将移除。 +- 如果两个输入至少为一维，且至少一个输入为N维（其中N> 2），则将获得批矩阵乘法。 如果第一个自变量是一维的，则将1放在其维度的前面，以便进行批量矩阵的乘法运算，然后将其删除。 如果第二个参数为一维，则将1附加到其维度后面，以实现成批矩阵倍数的目的，然后将其删除。 根据广播规则广播非矩阵维度（不包括最后两个维度）。 例如，如果输入 ``x`` 是（j，1，n，m）Tensor，另一个 ``y`` 是（k，m，p）Tensor，则out将是（j，k，n，p）张量。 -参数： - - **x** (Variable) : 输入变量，类型为 Tensor 或 LoDTensor。 - - **y** (Variable) : 输入变量，类型为 Tensor 或 LoDTensor。 - - **transpose_x** (bool) : 相乘前是否转置 x。 - - **transpose_y** (bool) : 相乘前是否转置 y。 - - **alpha** (float) : 输出比例，默认为 1.0。 - - **name** (str|None) : 该层名称（可选），如果设置为空，则自动为该层命名。 +参数 +::::::::: + - **x** (Tensor) : 输入变量，类型为 Tensor，数据类型为float32， float64。 + - **y** (Tensor) : 输入变量，类型为 Tensor，数据类型为float32， float64。 + - **transpose_x** (bool，可选) : 相乘前是否转置 x，默认值为False。 + - **transpose_y** (bool，可选) : 相乘前是否转置 y，默认值为False。 + - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 返回： - - Variable (Tensor / LoDTensor)，矩阵相乘后的结果。 +::::::::: -返回类型： - - Variable（变量）。 + - Tensor，矩阵相乘后的结果，数据类型和输入数据类型一致。 -:: - - * 例 1: - - x: [B, ..., M, K], y: [B, ..., K, N] - out: [B, ..., M, N] - - * 例 2: - - x: [B, M, K], y: [B, K, N] - out: [B, M, N] - - * 例 3: - - x: [B, M, K], y: [K, N] - out: [B, M, N] - - * 例 4: - - x: [M, K], y: [K, N] - out: [M, N] - - * 例 5: - - x: [B, M, K], y: [K] - out: [B, M] - - * 例 6: - - x: [K], y: [K] - out: [1] - - * 例 7: - - x: [M], y: [N] - out: [M, N] - - -**代码示例**： +代码示例 +:::::::::: .. code-block:: python - import paddle.fluid as fluid - import numpy - - # Graph Organizing - x = fluid.layers.data(name='x', shape=[2, 3], dtype='float32') - y = fluid.layers.data(name='y', shape=[3, 2], dtype='float32') - output = fluid.layers.matmul(x, y, True, True) - - # Create an executor using CPU as an example - exe = fluid.Executor(fluid.CPUPlace()) - exe.run(fluid.default_startup_program()) - - # Execute - input_x = numpy.ones([2, 3]).astype(numpy.float32) - input_y = numpy.ones([3, 2]).astype(numpy.float32) - res, = exe.run(fluid.default_main_program(), - feed={'x':input_x, 'y':input_y}, - fetch_list=[output]) - print(res) - ''' - Output Value: - [[2. 2. 2.] - [2. 2. 2.] - [2. 2. 2.]] - ''' + import paddle + import numpy as np + paddle.disable_static() + + # vector * vector + x_data = np.random.random([10]).astype(np.float32) + y_data = np.random.random([10]).astype(np.float32) + x = paddle.to_tensor(x_data) + y = paddle.to_tensor(y_data) + z = paddle.matmul(x, y) + print(z.numpy().shape) + # [1] + + # matrix * vector + x_data = np.random.random([10, 5]).astype(np.float32) + y_data = np.random.random([5]).astype(np.float32) + x = paddle.to_tensor(x_data) + y = paddle.to_tensor(y_data) + z = paddle.matmul(x, y) + print(z.numpy().shape) + # [10] + + # batched matrix * broadcasted vector + x_data = np.random.random([10, 5, 2]).astype(np.float32) + y_data = np.random.random([2]).astype(np.float32) + x = paddle.to_tensor(x_data) + y = paddle.to_tensor(y_data) + z = paddle.matmul(x, y) + print(z.numpy().shape) + # [10, 5] + + # batched matrix * batched matrix + x_data = np.random.random([10, 5, 2]).astype(np.float32) + y_data = np.random.random([10, 2, 5]).astype(np.float32) + x = paddle.to_tensor(x_data) + y = paddle.to_tensor(y_data) + z = paddle.matmul(x, y) + print(z.numpy().shape) + # [10, 5, 5] + + # batched matrix * broadcasted matrix + x_data = np.random.random([10, 1, 5, 2]).astype(np.float32) + y_data = np.random.random([1, 3, 2, 5]).astype(np.float32) + x = paddle.to_tensor(x_data) + y = paddle.to_tensor(y_data) + z = paddle.matmul(x, y) + print(z.numpy().shape) + # [10, 3, 5, 5] + diff --git a/doc/paddle/api/paddle/tensor/logic/equal_cn.rst b/doc/paddle/api/paddle/tensor/logic/equal_cn.rst index 9a66e76cedc7d3997fe8e6cbfefca91232f5734b..e8b1dff6087609b56b406dc5680e176a48faca22 100644 --- a/doc/paddle/api/paddle/tensor/logic/equal_cn.rst +++ b/doc/paddle/api/paddle/tensor/logic/equal_cn.rst @@ -1,39 +1,36 @@ -.. _cn_api_fluid_layers_equal: +.. _cn_api_tensor_equal: equal ------------------------------- +.. py:function:: paddle.equal(x, y, name=None) -.. py:function:: paddle.fluid.layers.equal(x, y, cond=None, name=None) +:alias_main: paddle.equal +:alias: paddle.equal,paddle.tensor.equal,paddle.tensor.logic.equal +该OP返回 :math:`x==y` 逐元素比较x和y是否相等，相同位置的元素相同则返回True，否则返回False。使用重载算子 `==` 可以有相同的计算函数效果 -该OP返回 :math:`x==y` 逐元素比较x和y是否相等，x和y的维度应该相同。 +**注：该OP输出的结果不返回梯度。** 参数： - - **x** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 - - **y** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 + - **x** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 + - **y** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + 返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。 -返回类型：变量（Variable） +返回类型：变量（Tensor） **代码示例**: .. code-block:: python - import paddle.fluid as fluid - import numpy as np - - out_cond =fluid.data(name="input1", shape=[2], dtype='bool') - label = fluid.layers.assign(np.array([3, 3], dtype="int32")) - limit = fluid.layers.assign(np.array([3, 2], dtype="int32")) - label_cond = fluid.layers.assign(np.array([1, 2], dtype="int32")) - - out1 = fluid.layers.equal(x=label,y=limit) #out1=[True, False] - out2 = fluid.layers.equal(x=label_cond,y=limit, cond=out_cond) #out2=[False, True] out_cond=[False, True] - - - - + import numpy as np + import paddle + import paddle.imperative as imperative + paddle.enable_imperative() + x = imperative.to_variable(np.array([1, 2, 3])) + y = imperative.to_variable(np.array([1, 3, 2])) + result1 = paddle.equal(x, y) + print(result1.numpy()) # result1 = [True False False] diff --git a/doc/paddle/api/paddle/tensor/logic/greater_equal_cn.rst b/doc/paddle/api/paddle/tensor/logic/greater_equal_cn.rst index 7141718419cc55b0fdb4546dcd16bc89c92a2e35..6eedd6c3bdcfd5fe971dad36fea0452eea45b10b 100644 --- a/doc/paddle/api/paddle/tensor/logic/greater_equal_cn.rst +++ b/doc/paddle/api/paddle/tensor/logic/greater_equal_cn.rst @@ -1,41 +1,37 @@ -.. _cn_api_fluid_layers_greater_equal: +.. _cn_api_tensor_cn_greater_equal: greater_equal ------------------------------- - -.. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=None, name=None) +.. py:function:: paddle.greater_equal(x, y, name=None) :alias_main: paddle.greater_equal :alias: paddle.greater_equal,paddle.tensor.greater_equal,paddle.tensor.logic.greater_equal -:old_api: paddle.fluid.layers.greater_equal - - -该OP逐元素地返回 :math:`x >= y` 的逻辑值，使用重载算子 `>=` 可以有相同的计算函数效果。 +该OP逐元素地返回 :math:`x >= y` 的逻辑值，相同位置前者输入大于等于后者输入则返回True，否则返回False。使用重载算子 `>=` 可以有相同的计算函数效果。 +**注：该OP输出的结果不返回梯度。** 参数： - - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape，数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据shape和数据类型需要和输入x一致。默认值为None。 + - **x** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 + - **y** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + -返回：输出结果的Tensor，数据的shape和输入x一致。 +返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。 -返回类型：Variable，数据类型为bool类型。 +返回类型：变量（Tensor） **代码示例**: .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers import numpy as np - label = layers.assign(np.array([2, 2], dtype='int32')) - limit = layers.assign(np.array([2, 3], dtype='int32')) - out = fluid.layers.greater_equal(x=label, y=limit) #out=[True, False] - out_1 = label >= limit #out1=[True, False] - - + import paddle + import paddle.imperative as imperative + paddle.enable_imperative() + x = imperative.to_variable(np.array([1, 2, 3])) + y = imperative.to_variable(np.array([1, 3, 2])) + result1 = paddle.greater_equal(x, y) + print(result1.numpy()) # result1 = [True False True] diff --git a/doc/paddle/api/paddle/tensor/logic/greater_than_cn.rst b/doc/paddle/api/paddle/tensor/logic/greater_than_cn.rst index 3f208e21ad5433125b3c22fa76ee06968a7c8153..33df3e31c019f4b0ce943f40d5f838cd3d22b19a 100644 --- a/doc/paddle/api/paddle/tensor/logic/greater_than_cn.rst +++ b/doc/paddle/api/paddle/tensor/logic/greater_than_cn.rst @@ -1,40 +1,35 @@ -.. _cn_api_fluid_layers_greater_than: +.. _cn_api_tensor_cn_greater_than: greater_than ------------------------------- - -.. py:function:: paddle.fluid.layers.greater_than(x, y, cond=None, name=None) +.. py:function:: paddle.greater_than(x, y, name=None) :alias_main: paddle.greater_than :alias: paddle.greater_than,paddle.tensor.greater_than,paddle.tensor.logic.greater_than -:old_api: paddle.fluid.layers.greater_than - +该OP返回 :math:`x>y` 逐元素比较x和y是否相等，相同位置前者输入大于等于后者输入则返回True，否则返回False。使用重载算子 `>` 可以有相同的计算函数效果 -该OP逐元素地返回 :math:`x > y` 的逻辑值，使用重载算子 `>` 可以有相同的计算函数效果。 +**注：该OP输出的结果不返回梯度。** 参数： - - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 + - **x** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 + - **y** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + -返回：输出结果的Tensor，数据的shape和输入x一致。 +返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。 -返回类型：Variable，数据类型为bool类型。 +返回类型：变量（Tensor） **代码示例**: .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers import numpy as np - label = layers.assign(np.array([2, 3], dtype='int32')) - limit = layers.assign(np.array([3, 2], dtype='int32')) - out = fluid.layers.greater_than(x=label, y=limit) #out=[False, True] - out1 = label > limit #out1=[False, True] - - - - + import paddle + import paddle.imperative as imperative + paddle.enable_imperative() + x = imperative.to_variable(np.array([1, 2, 3])) + y = imperative.to_variable(np.array([1, 3, 2])) + result1 = paddle.greater_than(x, y) + print(result1.numpy()) # result1 = [False False True] diff --git a/doc/paddle/api/paddle/tensor/logic/less_equal_cn.rst b/doc/paddle/api/paddle/tensor/logic/less_equal_cn.rst index da8b1b83343ec06b21738177555c79855efbdb2f..63427b1442ca0cab965045eff3b7bde02fee137e 100644 --- a/doc/paddle/api/paddle/tensor/logic/less_equal_cn.rst +++ b/doc/paddle/api/paddle/tensor/logic/less_equal_cn.rst @@ -1,40 +1,37 @@ -.. _cn_api_fluid_layers_less_equal: +.. _cn_api_tensor_cn_less_equal: less_equal ------------------------------- - -.. py:function:: paddle.fluid.layers.less_equal(x, y, cond=None, name=None) +.. py:function:: paddle.less_equal(x, y, name=None) :alias_main: paddle.less_equal :alias: paddle.less_equal,paddle.tensor.less_equal,paddle.tensor.logic.less_equal -:old_api: paddle.fluid.layers.less_equal - +该OP逐元素地返回 :math:`x <= y` 的逻辑值，相同位置前者输入小于等于后者输入则返回True，否则返回False。使用重载算子 `<=` 可以有相同的计算函数效果。 -该OP逐元素地返回 :math:`x <= y` 的逻辑值，使用重载算子 `<=` 可以有相同的计算函数效果。 +**注：该OP输出的结果不返回梯度。** 参数： - - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 + - **x** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 + - **y** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + -返回：输出结果的Tensor，数据的shape和输入x一致。 +返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。 -返回类型：Variable，数据类型为bool类型。 +返回类型：变量（Tensor） **代码示例**: .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers import numpy as np - label = layers.assign(np.array([1, 3], dtype='int32')) - limit = layers.assign(np.array([1, 2], dtype='int32')) - out = fluid.layers.less_equal(x=label, y=limit) #out=[True, False] - out1 = label<= limit #out1=[True, False] - - + import paddle + import paddle.imperative as imperative + paddle.enable_imperative() + x = imperative.to_variable(np.array([1, 2, 3])) + y = imperative.to_variable(np.array([1, 3, 2])) + result1 = paddle.less_equal(x, y) + print(result1.numpy()) # result1 = [True True False] diff --git a/doc/paddle/api/paddle/tensor/logic/less_than_cn.rst b/doc/paddle/api/paddle/tensor/logic/less_than_cn.rst index 6ad37577315a293779e5b1da1a9e449179c9b52f..e49b092cc2d5ce062cfac8551026c616d7befca2 100644 --- a/doc/paddle/api/paddle/tensor/logic/less_than_cn.rst +++ b/doc/paddle/api/paddle/tensor/logic/less_than_cn.rst @@ -1,54 +1,37 @@ -.. _cn_api_fluid_layers_less_than: +.. _cn_api_tensor_cn_less_than: less_than ------------------------------- - -.. py:function:: paddle.fluid.layers.less_than(x, y, force_cpu=None, cond=None, name=None) +.. py:function:: paddle.less_than(x, y, name=None) :alias_main: paddle.less_than :alias: paddle.less_than,paddle.tensor.less_than,paddle.tensor.logic.less_than -:old_api: paddle.fluid.layers.less_than - - - -该OP逐元素地返回 :math:`x < y` 的逻辑值，使用重载算子 `<` 可以有相同的计算函数效果 +该OP逐元素地返回 :math:`x < y` 的逻辑值，相同位置前者输入小于后者输入则返回True，否则返回False。使用重载算子 `<` 可以有相同的计算函数效果。 +**注：该OP输出的结果不返回梯度。** 参数： - - **x** (Variable) - 进行比较的第一个输入，是一个多维的LoDTensor/Tensor，数据类型可以是float32，float64，int32，int64。 - - **y** (Variable) - 进行比较的第二个输入，是一个多维的LoDTensor/Tensor，数据类型可以是float32，float64，int32，int64。 - - **force_cpu** (bool) – 如果为True则强制将输出变量写入CPU内存中，否则将其写入目前所在的运算设备上。默认值为False。注意：该属性已弃用，其值始终是False。 - - **cond** (Variable，可选) – 指定算子输出结果的LoDTensor/Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。 + - **x** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 + - **y** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + +返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。 -返回：输出结果的LoDTensor/Tensor，数据的shape和输入x一致。 - -返回类型： Variable，数据类型为bool。 +返回类型：变量（Tensor） **代码示例**: .. code-block:: python - import paddle.fluid as fluid - import numpy as np + import numpy as np + import paddle + import paddle.imperative as imperative + paddle.enable_imperative() + x = imperative.to_variable(np.array([1, 2, 3])) + y = imperative.to_variable(np.array([1, 3, 2])) + result1 = paddle.less_than(x, y) + print(result1.numpy()) # result1 = [False True False] - # Graph Organizing - x = fluid.layers.data(name='x', shape=[2], dtype='float64') - y = fluid.layers.data(name='y', shape=[2], dtype='float64') - result = fluid.layers.less_than(x=x, y=y) - # The comment lists another available method. - # result = fluid.layers.fill_constant(shape=[2], dtype='float64', value=0) - # fluid.layers.less_than(x=x, y=y, cond=result) - - # Create an executor using CPU as example - exe = fluid.Executor(fluid.CPUPlace()) - exe.run(fluid.default_startup_program()) - - # Execute - x_i = np.array([[1, 2], [3, 4]]).astype(np.float64) - y_i = np.array([[2, 2], [1, 3]]).astype(np.float64) - result_value, = exe.run(fluid.default_main_program(), feed={'x':x_i, 'y':y_i}, fetch_list=[result]) - print(result_value) # [[True, False], [False, False]] diff --git a/doc/paddle/api/paddle/tensor/logic/not_equal_cn.rst b/doc/paddle/api/paddle/tensor/logic/not_equal_cn.rst index 5a9cedf60cc03d67d8571424cffc2af62a583184..8a81f4f08ff2b31d4f434c169be51d3ca3703103 100644 --- a/doc/paddle/api/paddle/tensor/logic/not_equal_cn.rst +++ b/doc/paddle/api/paddle/tensor/logic/not_equal_cn.rst @@ -1,41 +1,37 @@ -.. _cn_api_fluid_layers_not_equal: +.. _cn_api_tensor_not_equal: not_equal ------------------------------- - -.. py:function:: paddle.fluid.layers.not_equal(x, y, cond=None, name=None) +.. py:function:: paddle.not_equal(x, y, name=None) :alias_main: paddle.not_equal :alias: paddle.not_equal,paddle.tensor.not_equal,paddle.tensor.logic.not_equal -:old_api: paddle.fluid.layers.not_equal - +该OP返回 :math:`x!=y` 逐元素比较x和y是否相等，相同位置的元素不相同则返回True，否则返回False。使用重载算子 `!=` 可以有相同的计算函数效果 -该OP逐元素地返回 :math:`x != y` 的逻辑值，使用重载算子 `!=` 可以有相同的计算函数效果。 +**注：该OP输出的结果不返回梯度。** 参数： - - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 - - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 + - **x** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。 + - **y** (Tensor) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。 - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回：输出结果的Tensor，数据的shape和输入x一致。 + -返回类型：变量（Variable），数据类型为bool类型。 +返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。 + +返回类型：变量（Tensor） **代码示例**: .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers import numpy as np - label = layers.assign(np.array([2, 3], dtype='int32')) - limit = layers.assign(np.array([3, 2], dtype='int32')) - out = fluid.layers.not_equal(x=label, y=limit) #out=[True, True] - out1 = label != limit #out1=[True, True] - - - - + import paddle + import paddle.imperative as imperative + paddle.enable_imperative() + x = imperative.to_variable(np.array([1, 2, 3])) + y = imperative.to_variable(np.array([1, 3, 2])) + result1 = paddle.not_equal(x, y) + print(result1.numpy()) # result1 = [False True True] diff --git a/doc/paddle/api/paddle/tensor/manipulation/concat_cn.rst b/doc/paddle/api/paddle/tensor/manipulation/concat_cn.rst index 46b1b3c3d6b17cdd9eebd5959372756499ede8ff..b66f67025f4171fa452534d173b3b63d86795b05 100644 --- a/doc/paddle/api/paddle/tensor/manipulation/concat_cn.rst +++ b/doc/paddle/api/paddle/tensor/manipulation/concat_cn.rst @@ -1,51 +1,54 @@ -.. _cn_api_fluid_layers_concat: +.. _cn_api_tensor_concat: concat ------------------------------- -.. py:function:: paddle.fluid.layers.concat(input, axis=0, name=None) +.. py:function:: paddle.tensor.concat(x, axis=0, name=None) 该OP对输入沿 ``axis`` 轴进行联结，返回一个新的Tensor。 参数： - - **input** (list|tuple|Tensor) - 待联结的Tensor list，Tensor tuple或者Tensor，支持的数据类型为：bool、float16、 float32、float64、int32、int64。 ``input`` 中所有Tensor的数据类型必须一致。 - - **axis** (int|Tensor，可选) - 指定对输入Tensor进行运算的轴，可以是整数或者形状为[1]的Tensor，数据类型为int32或者int64。 ``axis`` 的有效范围是[-R, R)，R是输入 ``input`` 中Tensor 的维度， ``axis`` 为负值时与 :math:`axis + R` 等价。默认值为0。 + - **x** (list|tuple) - 待联结的Tensor list或者Tensor tuple ，支持的数据类型为：bool, float16, float32、float64、int32、int64， ``x`` 中所有Tensor的数据类型应该一致。 + - **axis** (int|Tensor，可选) - 指定对输入 ``x`` 进行运算的轴，可以是整数或者形状为[1]的Tensor，数据类型为int32或者int64。 ``axis`` 的有效范围是[-R, R)，R是输入 ``x`` 中Tensor的维度， ``axis`` 为负值时与 :math:`axis + R` 等价。默认值为0。 - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回：联结后的 ``Tensor`` ，数据类型和 ``input`` 中的Tensor相同。 - +返回：联结后的Tensor ，数据类型和 ``x`` 中的Tensor相同。 抛出异常： - - ``TypeError``: - 当输入 ``input`` 的类型不是list、tuple或者Tensor的时候。 - - ``TypeError``: - 当输入 ``input`` 的数据类型不是 bool，float16， float32， float64， int32， int64时。 - - ``TypeError``: - 当 ``axis`` 的类型不是int或者Tensor时。当 ``axis`` 是Tensor的时候其数据类型不是int32或者int64时。 - - ``TypeError``: - 当输入 ``input`` 中的Tensor存在数据类型不一致时。 + - ``TypeError``: - 当输入 ``x`` 的类型不是list或者tuple时。 + - ``TypeError``: - 当输入 ``x`` 的数据类型不是 bool，float16， float32， float64， int32， int64时。 + - ``TypeError``: - 当 ``axis`` 的类型不是int或者Tensor时。 当 ``axis`` 是Tensor的时候其数据类型不是int32或者int64时。 + - ``TypeError``: - 当输入 ``x`` 中的Tensor存在数据类型不一致时。 **代码示例**： .. code-block:: python - - import paddle.fluid as fluid + + import paddle import numpy as np - + + paddle.disable_static() # Now we are in imperative mode in1 = np.array([[1, 2, 3], [4, 5, 6]]) in2 = np.array([[11, 12, 13], [14, 15, 16]]) in3 = np.array([[21, 22], [23, 24]]) - with fluid.dygraph.guard(): - x1 = fluid.dygraph.to_variable(in1) - x2 = fluid.dygraph.to_variable(in2) - x3 = fluid.dygraph.to_variable(in3) - out1 = fluid.layers.concat(input=[x1, x2, x3], axis=-1) - out2 = fluid.layers.concat(input=[x1, x2], axis=0) - print(out1.numpy()) - # [[ 1 2 3 11 12 13 21 22] - # [ 4 5 6 14 15 16 23 24]] - print(out2.numpy()) - # [[ 1 2 3] - # [ 4 5 6] - # [11 12 13] - # [14 15 16]] + x1 = paddle.to_tensor(in1) + x2 = paddle.to_tensor(in2) + x3 = paddle.to_tensor(in3) + zero = paddle.full(shape=[1], dtype='int32', fill_value=0) + # When the axis is negative, the real axis is (axis + Rank(x)) + # As follow, axis is -1, Rank(x) is 2, the real axis is 1 + out1 = paddle.concat(x=[x1, x2, x3], axis=-1) + out2 = paddle.concat(x=[x1, x2], axis=0) + out3 = paddle.concat(x=[x1, x2], axis=zero) + # out1 + # [[ 1 2 3 11 12 13 21 22] + # [ 4 5 6 14 15 16 23 24]] + # out2 out3 + # [[ 1 2 3] + # [ 4 5 6] + # [11 12 13] + # [14 15 16]] diff --git a/doc/paddle/api/paddle/tensor/manipulation/gather_cn.rst b/doc/paddle/api/paddle/tensor/manipulation/gather_cn.rst index 7e1f85a6c8ed9f727c6a3d60a457c434f4321cbd..79a40cd49b9c33f7247e8b7cad69d88991cc7eb4 100644 --- a/doc/paddle/api/paddle/tensor/manipulation/gather_cn.rst +++ b/doc/paddle/api/paddle/tensor/manipulation/gather_cn.rst @@ -1,18 +1,10 @@ -.. _cn_api_fluid_layers_gather: - +.. _cn_api_paddle_tensor_gather gather ------------------------------- -.. py:function:: paddle.fluid.layers.gather(input, index, overwrite=True) - - - +.. py:function:: paddle.gather(x, index, axis=None, name=None) -根据索引 ``index`` 获取输入（input）的最外层维度的条目，并将它们拼接在一起。 - -.. math:: - - Out=X[Index] +根据索引 index 获取输入 ``x`` 的指定 ``aixs`` 维度的条目，并将它们拼接在一起。 .. code-block:: text @@ -22,35 +14,38 @@ gather Index = [1, 2] + axis = 0 + Then: Out = [[3, 4], [5, 6]] +**参数**: + - **x** (Tensor) - 输入 Tensor, 秩 ``rank >= 1`` , 支持的数据类型包括 int32、int64、float32、float64 和 uint8 (CPU)、float16（GPU） 。 + - **index** (Tensor) - 索引 Tensor，秩 ``rank = 1``, 数据类型为 int32 或 int64。 + - **axis** (Tensor) - 指定index 获取输入的维度， ``axis`` 的类型可以是int或者Tensor，当 ``axis`` 为Tensor的时候其数据类型为int32 或者int64。 + - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -参数: - - **input** (Variable) - 输入, 秩 ``rank >= 1`` , 支持的数据类型包括 int32、int64、float32、float64 和 uint8 (CPU)、float16（GPU） 。 - - **index** (Variable) - 索引，秩 ``rank = 1``, 数据类型为 int32 或 int64。 - - **overwrite** (bool) - 具有相同索引时在反向更新梯度的模式。如果为 ``True`` ，则使用覆盖模式更新相同索引的梯度；如果为 ``False`` ，则使用累积模式更新相同索引的梯度。默认值为 ``True`` 。 - -返回：和输入的秩相同的输出张量。 +**返回**：和输入的秩相同的输出Tensor。 -返回类型：Variable +抛出异常： + - ``TypeError``: - ``x`` 必须是Tensor 并且 ``x`` 的数据类型必须是uint8、float16、float32、float64、int32或者int64。 + - ``TypeError``: - ``index`` 必须是Tensor并且数据类型必须是int32或者int64。 + - ``TypeError``: - ``axis`` 必须是Tensor或者int, 当 ``axis`` 是Tensor的时候数据类型必须是int32或者int64。 -**代码示例** +**代码示例**： .. code-block:: python - - import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[-1, 5], dtype='float32') - index = fluid.layers.data(name='index', shape=[-1, 1], dtype='int32') - output = fluid.layers.gather(x, index) - - - - - - - - + + import numpy as np + import paddle + + paddle.disable_static() + input_1 = np.array([[1,2],[3,4],[5,6]]) + index_1 = np.array([0,1]) + input = paddle.to_tensor(input_1) + index = paddle.to_tensor(index_1) + output = paddle.gather(input, index, axis=0) + # expected output: [[1,2],[3,4]] diff --git a/doc/paddle/api/paddle/tensor/manipulation/gather_nd_cn.rst b/doc/paddle/api/paddle/tensor/manipulation/gather_nd_cn.rst index 6c810ad73aa1edff045883f98cd80ffcb2365762..8aa603b1e614d02f64900271827991a5a3edd6cd 100644 --- a/doc/paddle/api/paddle/tensor/manipulation/gather_nd_cn.rst +++ b/doc/paddle/api/paddle/tensor/manipulation/gather_nd_cn.rst @@ -1,41 +1,35 @@ -.. _cn_api_fluid_layers_gather_nd: +.. _cn_api_tensor_cn_gather_nd: gather_nd ------------------------------- +.. py:function:: paddle.gather_nd(x, index, name=None) -.. py:function:: paddle.fluid.layers.gather_nd(input, index, name=None) -:alias_main: paddle.gather_nd -:alias: paddle.gather_nd,paddle.tensor.gather_nd,paddle.tensor.manipulation.gather_nd -:old_api: paddle.fluid.layers.gather_nd - - - -该OP是 :code:`gather` 的高维推广，并且支持多轴同时索引。 :code:`index` 是一个K维度的张量，它可以认为是从 :code:`input` 中取K-1维张量，每一个元素是一个切片： +该OP是 :code:`gather` 的高维推广，并且支持多轴同时索引。 :code:`index` 是一个K维度的张量，它可以认为是从 :code:`x` 中取K-1维张量，每一个元素是一个切片： .. math:: - output[(i_0, ..., i_{K-2})] = input[index[(i_0, ..., i_{K-2})]] + output[(i_0, ..., i_{K-2})] = x[index[(i_0, ..., i_{K-2})]] -显然， :code:`index.shape[-1] <= input.rank` 并且输出张量的维度是 :code:`index.shape[:-1] + input.shape[index.shape[-1]:]` 。 +显然， :code:`index.shape[-1] <= x.rank` 并且输出张量的维度是 :code:`index.shape[:-1] + x.shape[index.shape[-1]:]` 。 示例： :: 给定: - input = [[[ 0, 1, 2, 3], + x = [[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]] - input.shape = (2, 3, 4) + x.shape = (2, 3, 4) - 案例 1: index = [[1]] - gather_nd(input, index) - = [input[1, :, :]] + gather_nd(x, index) + = [x[1, :, :]] = [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]] @@ -43,37 +37,40 @@ gather_nd - 案例 2: index = [[0,2]] - gather_nd(input, index) - = [input[0, 2, :]] + gather_nd(x, index) + = [x[0, 2, :]] = [8, 9, 10, 11] - 案例 3: index = [[1, 2, 3]] - gather_nd(input, index) - = [input[1, 2, 3]] + gather_nd(x, index) + = [x[1, 2, 3]] = [23] 参数： - - **input** (Variable) - 输入张量，数据类型可以是int32，int64，float32，float64, bool。 - - **index** (Variable) - 输入的索引张量，数据类型为非负int32或非负int64。它的维度 :code:`index.rank` 必须大于1，并且 :code:`index.shape[-1] <= input.rank` 。 - - **name** (string) - 该层的名字，默认值为None，表示会自动命名。 + - **x** (Tensor) - 输入Tensor，数据类型可以是int32，int64，float32，float64, bool。 + - **index** (Tensor) - 输入的索引Tensor，其数据类型int32或者int64。它的维度 :code:`index.rank` 必须大于1，并且 :code:`index.shape[-1] <= x.rank` 。 + - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回：shape为index.shape[:-1] + input.shape[index.shape[-1]:]的Tensor|LoDTensor，数据类型与 :code:`input` 一致。 +返回：shape为index.shape[:-1] + x.shape[index.shape[-1]:]的Tensor，数据类型与 :code:`x` 一致。 -返回类型：Variable **代码示例**： .. code-block:: python - import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[3, 4, 5], dtype='float32') - index = fluid.layers.data(name='index', shape=[2, 2], dtype='int32') - output = fluid.layers.gather_nd(x, index) - - - + import paddle + import numpy as np + + paddle.disable_static() + np_x = np.array([[[1, 2], [3, 4], [5, 6]], + [[7, 8], [9, 10], [11, 12]]]) + np_index = [[0, 1]] + x = paddle.to_tensor(np_x) + index = paddle.to_tensor(np_index) + + output = paddle.gather_nd(x, index) #[[3, 4]] diff --git a/doc/paddle/api/paddle/tensor/manipulation/split_cn.rst b/doc/paddle/api/paddle/tensor/manipulation/split_cn.rst index ca1607ee55c07488cd3a343ec72bf5c216ae2614..9c1293baf3fb9793ff079a38d18459d24bef7cf8 100644 --- a/doc/paddle/api/paddle/tensor/manipulation/split_cn.rst +++ b/doc/paddle/api/paddle/tensor/manipulation/split_cn.rst @@ -1,65 +1,56 @@ -.. _cn_api_fluid_layers_split: - +.. _cn_api_paddle_tensor_split split ------------------------------- -.. py:function:: paddle.fluid.layers.split(input, num_or_sections, dim=-1, name=None) - +.. py:function:: paddle.tensor.split(x, num_or_sections, axis=0, name=None) 该OP将输入Tensor分割成多个子Tensor。 -参数： - - **input** (Tensor) - 输入变量，数据类型为bool， float16，float32，float64，int32，int64的多维Tensor。 - - **num_or_sections** (int|list|tuple) - 如果 ``num_or_sections`` 是一个整数，则表示Tensor平均划分为相同大小子Tensor的数量。如果 ``num_or_sections`` 是一个list或tuple，那么它的长度代表子Tensor的数量，它的元素可以是整数或者形状为[1]的Tensor，依次代表子Tensor需要分割成的维度的大小。list或tuple的长度不能超过输入Tensor待分割的维度的大小。至多有一个元素值为-1，-1表示该值是由 ``input`` 待分割的维度值和 ``num_or_sections`` 的剩余元素推断出来的。 - - **dim** (int|Tenspr，可选) - 整数或者形状为[1]的Tensor，数据类型为int32或int64。表示需要分割的维度。如果 ``dim < 0`` ，则划分的维度为 ``rank(input) + dim`` 。默认值为-1。 - - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 +**参数**： + - **x** (Tensor) - 输入变量，数据类型为bool, float16, float32，float64，int32，int64的多维Tensor。 + - **num_or_sections** (int|list|tuple) - 如果 ``num_or_sections`` 是一个整数，则表示Tensor平均划分为相同大小子Tensor的数量。如果 ``num_or_sections`` 是一个list或tuple，那么它的长度代表子Tensor的数量，它的元素可以是整数或者形状为[1]的Tensor，依次代表子Tensor需要分割成的维度的大小。list或tuple的长度不能超过输入Tensor待分割的维度的大小。在list或tuple中，至多有一个元素值为-1，表示该值是由 ``x`` 的维度和其他 ``num_or_sections`` 中元素推断出来的。例如对一个维度为[4,6,6]Tensor的第三维进行分割时，指定 ``num_or_sections=[2,-1,1]`` ，输出的三个Tensor维度分别为：[4,6,2]，[4,6,3]，[4,6,1]。 + - **axis** (int|Tensor，可选) - 整数或者形状为[1]的Tensor，数据类型为int32或int64。表示需要分割的维度。如果 ``axis < 0`` ，则划分的维度为 ``rank(x) + axis`` 。默认值为0。 + - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 返回：分割后的Tensor列表。 - 抛出异常： - - :code:`TypeError`：``input`` 的数据类型不是bool、float16、float32、float64、int32或int64时 。 + - :code:`TypeError`：``x`` 的数据类型不是bool、float16、float32、float64、int32或int64时 。 - :code:`TypeError`：``num_or_sections`` 不是int、list 或 tuple时。 - - :code:`TypeError`：``dim`` 不是 int 或 Tensor时。当 ``dim`` 为Tensor，其数据类型不是int32或int64时。 + - :code:`TypeError`：``axis`` 不是 int 或 Tensor时。当 ``axis`` 为Tensor，其数据类型不是int32或int64时。 **代码示例**： .. code-block:: python - import paddle.fluid as fluid - - # input is a Tensor which shape is [3, 9, 5] - input = fluid.data( - name="input", shape=[3, 9, 5], dtype="float32") + import numpy as np + import paddle + + paddle.disable_static() + # x is a Tensor which shape is [3, 9, 5] + x_np = np.random.random([3, 9, 5]).astype("int32") + x = paddle.to_tensor(x_np) - out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=1) + out0, out1, out22 = paddle.split(x, num_or_sections=3, axis=1) # out0.shape [3, 3, 5] # out1.shape [3, 3, 5] # out2.shape [3, 3, 5] - out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, 4], dim=1) + out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, 4], axis=1) # out0.shape [3, 2, 5] # out1.shape [3, 3, 5] # out2.shape [3, 4, 5] - out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, -1], dim=1) + out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, -1], axis=1) # out0.shape [3, 2, 5] # out1.shape [3, 3, 5] # out2.shape [3, 4, 5] - # dim is negative, the real dim is (rank(input) + axis) which real + # axis is negative, the real axis is (rank(x) + axis) which real # value is 1. - out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=-2) + out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=-2) # out0.shape [3, 3, 5] # out1.shape [3, 3, 5] # out2.shape [3, 3, 5] - - - - - - - - diff --git a/doc/paddle/api/paddle/tensor/manipulation/stack_cn.rst b/doc/paddle/api/paddle/tensor/manipulation/stack_cn.rst index 2c2a88e6845d7d507f2b8274cf0b6247eb79aaef..38fd8c0cc524a901e69d73c0da9f6a302b6e9327 100644 --- a/doc/paddle/api/paddle/tensor/manipulation/stack_cn.rst +++ b/doc/paddle/api/paddle/tensor/manipulation/stack_cn.rst @@ -1,21 +1,19 @@ -.. _cn_api_fluid_layers_stack: - +.. _cn_api_paddle_tensor_arange stack ------------------------------- -.. py:function:: paddle.fluid.layers.stack(x, axis=0) - +.. py:function:: paddle.tensor.stack(x, axis=0, name=None) +该OP沿 axis 轴对输入 x 进行堆叠操作。要求所有输入Tensor有相同的Shape和数据类型。 +例如，输入 x 为 N 个 Shape 为 [A, B]的 Tensor, 如果 ``axis==0`` , 则输出 Tensor 的 Shape 为 [N, A, B]; 如果 ``axis==1`` , 则输出 Tensor 的 Shape 为 [A, N, B]; 以此类推。 -该OP沿 ``axis`` 轴对输入 ``x`` 进行堆叠操作。 +.. code-block:: text -- 例1: + Case 1: -.. code-block:: python - - 输入: + Input: x[0].shape = [1, 2] x[0].data = [ [1.0 , 2.0 ] ] x[1].shape = [1, 2] @@ -23,21 +21,19 @@ stack x[2].shape = [1, 2] x[2].data = [ [5.0 , 6.0 ] ] - 参数: - axis = 0 #沿着第0维对输入x进行堆叠操作。 + Attrs: + axis = 0 - 输出: - Out.shape = [3, 1, 2] - Out.data = [ [ [1.0, 2.0] ], + Output: + Out.dims = [3, 1, 2] + Out.data =[ [ [1.0, 2.0] ], [ [3.0, 4.0] ], [ [5.0, 6.0] ] ] -- 例2: + Case 2: -.. code-block:: python - - 输入: + Input: x[0].shape = [1, 2] x[0].data = [ [1.0 , 2.0 ] ] x[1].shape = [1, 2] @@ -45,42 +41,46 @@ stack x[2].shape = [1, 2] x[2].data = [ [5.0 , 6.0 ] ] - 参数: - axis = 1 or axis = -2 #沿着第1维对输入进行堆叠操作。 - - 输出: - Out.shape = [1, 3, 2] - Out.data = [ [ [1.0, 2.0] - [3.0, 4.0] - [5.0, 6.0] ] ] - -参数: - - **x** (Variable|list(Variable)) – 输入 x 可以是单个Tensor，或是多个Tensor组成的列表。如果 x 是一个列表，那么这些Tensor的维度必须相同。 假设输入是N维Tensor :math:`[d_0,d_1,...,d_{n−1}]`，则输出变量的维度为N+1维 :math:`[d_0,d_1,...d_{axis-1},len(x),d_{axis}...,d_{n−1}]` 。支持的数据类型: float32，float64，int32，int64。 - - **axis** (int, 可选) – 指定对输入Tensor进行堆叠运算的轴，有效 ``axis`` 的范围是: :math:`[-(R+1), R+1)`，R是输入中第一个Tensor的rank。如果 ``axis`` < 0，则 :math:`axis=axis+rank(x[0])+1` 。axis默认值为0。 -返回: 堆叠运算后的Tensor，数据类型与输入Tensor相同。输出维度等于 :math:`rank(x[0])+1` 维。 + Attrs: + axis = 1 or axis = -2 # If axis = -2, axis = axis+ndim(x[0])+1 = -2+2+1 = 1. -返回类型: Variable - -**代码示例**： - -.. code-block:: python - - import paddle.fluid as fluid - import paddle.fluid.layers as layers - x1 = layers.data(name='x1', shape=[1, 2], dtype='int32') - x2 = layers.data(name='x2', shape=[1, 2], dtype='int32') - #对Tensor List进行堆叠 - data = layers.stack([x1,x2]) # 沿着第0轴进行堆叠，data.shape=[2, 1, 2] - - data = layers.stack([x1,x2], axis=1) # 沿着第1轴进行堆叠，data.shape=[1, 2, 2] - - #单个Tensor的堆叠 - data = layers.stack(x1) # 沿着第0轴进行堆叠，data.shape=[1, 1, 2] + Output: + Out.shape = [1, 3, 2] + Out.data =[ [ [1.0, 2.0] + [3.0, 4.0] + [5.0, 6.0] ] ] +**参数**： + - **x** (Tensor|list[Tensor]) – 输入 x 可以是单个Tensor，或是多个Tensor组成的列表。如果 x 是一个列表，那么这些Tensor的维度必须相同。支持的数据类型: float32，float64，int32，int64。 + - **axis** (int, 可选) – 指定对输入Tensor进行堆叠运算的轴，有效 axis 的范围是: [−(R+1),R+1)]，R是输入中第一个Tensor的维数。如果 axis < 0，则 axis=axis+R+1 。默认值为0。 + - **name** (str, 可选) - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。 +**返回**：堆叠运算后的Tensor，数据类型与输入Tensor相同。 +**返回类型**：Variable +**代码示例**: +.. code-block:: python + + import paddle + import numpy as np + + data1 = np.array([[1.0, 2.0]]) + data2 = np.array([[3.0, 4.0]]) + data3 = np.array([[5.0, 6.0]]) + + paddle.disable_static() + x1 = paddle.to_variable(data1) + x2 = paddle.to_variable(data2) + x3 = paddle.to_variable(data3) + + out = paddle.stack([x1, x2, x3], axis=0) + print(out.shape) # [3, 1, 2] + print(out.numpy()) + # [[[1., 2.]], + # [[3., 4.]], + # [[5., 6.]]] diff --git a/doc/paddle/api/paddle/tensor/manipulation/unsqueeze_cn.rst b/doc/paddle/api/paddle/tensor/manipulation/unsqueeze_cn.rst index 3290bebea17c0e989232238b6f5c6c79639467fd..e8dbe24681b39af44735fa7a651bc85f09c8f9dc 100644 --- a/doc/paddle/api/paddle/tensor/manipulation/unsqueeze_cn.rst +++ b/doc/paddle/api/paddle/tensor/manipulation/unsqueeze_cn.rst @@ -1,43 +1,36 @@ -.. _cn_api_fluid_layers_unsqueeze: - +.. _cn_api_paddle_tensor_unsqueeze unsqueeze ------------------------------- -.. py:function:: paddle.fluid.layers.unsqueeze(input, axes, name=None) - - +.. py:function:: paddle.tensor.unsqueeze(x, axis, name=None) +该OP向输入Tensor的Shape中一个或多个位置（axis）插入尺寸为1的维度。 -该OP向输入（input）的shape中一个或多个位置（axes）插入维度。 +**参数**： + - **x** (Variable)- 输入的 `Tensor` ，数据类型为：float32、float64、bool、int8、int32、int64。 + - **axis** (int|list|tuple|Tensor) - 表示要插入维度的位置。数据类型是 int32 。如果 axis 的类型是 list 或 tuple，它的元素可以是整数或者形状为[1]的 Tensor 。如果 axes 的类型是 Tensor，则是1-D Tensor。如果 axis 是负数，则 axis=axis+ndim(x)+1 。 + - **name** （str，可选）- 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。 -- 示例： - -.. code-block:: python +**返回**：扩展维度后的多维Tensor，数据类型与输入Tensor一致。 - 输入： - X.shape = [2, 3] - X.data = [[1, 2, 3], - [4，5，6]] - axes = [0, 2] - 输出（在X的第0维和第2维插入新维度）： - Out.shape = [1, 2, 1, 3] - Out.data = [[[[1, 2, 3]], - [[4, 5, 6]]]] - -参数： - - **input** (Variable)- 多维 ``Tensor``，数据类型为 ``float32``， ``float64``， ``int8``， ``int32``，或 ``int64``。 - - **axes** (int|list|tuple|Variable) - 表示要插入维度的位置。数据类型是 ``int32`` 。如果 ``axes`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[1]的 ``Tensor`` 。如果 ``axes`` 的类型是 ``Variable``，则是1-D ``Tensor``。 - - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置。默认值： ``None``。 - -返回：扩展维度后的多维Tensor - -返回类型：Variable +**返回类型**：Tensor **代码示例**： .. code-block:: python - import paddle.fluid as fluid - x = fluid.data(name='x', shape=[5, 10]) - y = fluid.layers.unsqueeze(input=x, axes=[1]) - # y.shape is [5, 1, 10] + import paddle + + paddle.disable_static() + x = paddle.rand([5, 10]) + print(x.shape) # [5, 10] + + out1 = paddle.unsqueeze(x, axis=0) + print(out1.shape) # [1, 5, 10] + + out2 = paddle.unsqueeze(x, axis=[0, 2]) + print(out2.shape) # [1, 5, 1, 10] + + axis = paddle.fluid.dygraph.to_variable([0, 1, 2]) + out3 = paddle.unsqueeze(x, axis=axis) + print(out3.shape) # [1, 1, 1, 5, 10] diff --git a/doc/paddle/api/paddle/tensor/math/cumsum_cn.rst b/doc/paddle/api/paddle/tensor/math/cumsum_cn.rst index fd9238e64bd85b90f4a54ced20b6dda1266b4e60..71896b1bc17808d6b70873ef45a5587d1ad6cce1 100644 --- a/doc/paddle/api/paddle/tensor/math/cumsum_cn.rst +++ b/doc/paddle/api/paddle/tensor/math/cumsum_cn.rst @@ -1,41 +1,54 @@ -.. _cn_api_fluid_layers_cumsum: +.. _cn_api_tensor_cn_cumsum: cumsum ------------------------------- -.. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=None) +.. py:function:: paddle.cumsum(x, axis=None, dtype=None, name=None) -:alias_main: paddle.cumsum -:alias: paddle.cumsum,paddle.tensor.cumsum,paddle.tensor.math.cumsum -:old_api: paddle.fluid.layers.cumsum - -沿给定轴(axis)的元素的累加和。默认结果的第一个元素和输入的第一个元素一致。如果exlusive为True，结果的第一个元素则为0。 +沿给定 ``axis`` 计算张量 ``x`` 的累加和。结果的第一个元素和输入的第一个元素相同。 参数： - - **x** (Variable) - 累加的输入，需要进行累加操作的变量Tensor/LoDTensor。 - - **axis** (int，可选) - 指明需要累加的维。-1代表最后一维。默认为：-1。 - - **exclusive** (bool，可选) - 是否执行exclusive累加。默认为：False。 - - **reverse** (bool，可选) - 若为True，则以相反顺序执行累加。默认为：False。 + - **x** (Tensor) - 累加的输入，需要进行累加操作的Tensor. + - **axis** (int，可选) - 指明需要累加的维度。-1代表最后一维。默认：None，将输入展开为一维变量再进行累加计算。 + - **dtype** (str，可选) - 输出Tensor的数据类型，支持int32、int64、float32、float64. 如果指定了，那么在执行操作之前，输入张量将被转换为dtype. 这对于防止数据类型溢出非常有用。默认为：None. + - **name** （str，可选）- 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。 -返回：Variable(Tensor)。是累加的结果，即累加器的输出。 +返回：累加的结果，即累加器的输出。 -返回类型：变量(Variable)。 +返回类型：Tensor **代码示例**： .. code-block:: python - import paddle.fluid as fluid - data = fluid.layers.data(name="input", shape=[32, 784]) - result = fluid.layers.cumsum(data, axis=0) - - - - - - - + import paddle + from paddle.imperative import to_variable + import numpy as np + + paddle.enable_imperative() + data_np = np.arange(12).reshape(3, 4) + data = to_variable(data_np) + + y = paddle.cumsum(data) + print(y.numpy()) + # [ 0 1 3 6 10 15 21 28 36 45 55 66] + + y = paddle.cumsum(data, axis=0) + print(y.numpy()) + # [[ 0 1 2 3] + # [ 4 6 8 10] + # [12 15 18 21]] + + y = paddle.cumsum(data, axis=-1) + print(y.numpy()) + # [[ 0 1 3 6] + # [ 4 9 15 22] + # [ 8 17 27 38]] + + y = paddle.cumsum(data, dtype='float64') + print(y.dtype) + # VarType.FP64 diff --git a/doc/paddle/api/paddle/tensor/math/maximum_cn.rst b/doc/paddle/api/paddle/tensor/math/maximum_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..3db694f291098d8ed4c8d2bd08bd4a56adb49f81 --- /dev/null +++ b/doc/paddle/api/paddle/tensor/math/maximum_cn.rst @@ -0,0 +1,96 @@ +.. _cn_api_paddle_tensor_maximum: + +maximum +------------------------------- + +.. py:function:: paddle.tensor.maximum(x, y, axis=-1, name=None) + +:alias_main: paddle.maximum +:alias: paddle.maximum,paddle.tensor.maximum,paddle.tensor.math.maximum + +该OP逐元素对比输入的两个多维Tensor，并且把各个位置更大的元素保存到返回结果中。 + +等式是： + +.. math:: + Out = max(X, Y) + +- :math:`X` ：多维Tensor。 +- :math:`Y` ：多维Tensor。 + +此运算算子有两种情况： + 1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。 + 2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。 + +对于情况2： + 1. 用 :math:`Y` 的 ``shape`` 匹配 :math:`X` 的 ``shape``，其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。 + 2. 如果 ``axis`` < 0（默认值为-1），则 :math:`axis = abs(X.ndim - Y.ndim) - axis - 1` 。 + 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 + +具体的飞桨的广播（broadcasting）机制可以参考 `<> `_ 。 + +参数 +::::::::: + - **x** （Tensor）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。 + - **y** （Tensor）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。 + - **axis** （int32, 可选）- Y的维度对应到X维度上时的索引。默认值为 -1。 + - **name** （string, 可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。 + +返回 +::::::::: + Tensor，维度和数据类型与 ``x`` 相同的多维Tensor。 + +代码示例 +:::::::::: + +.. code-block:: python + + import paddle + import numpy as np + + paddle.disable_static() + + x_data = np.array([[1, 2], [3, 4]], dtype=np.float32) + y_data = np.array([[5, 6], [7, 8]], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.maximum(x, y) + print(res.numpy()) + #[[5. 6.] + # [7. 8.]] + + x_data = np.array([[[1, 2, 3], [1, 2, 3]]], dtype=np.float32) + y_data = np.array([1, 2], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.maximum(x, y, axis=1) + print(res.numpy()) + #[[[1. 2. 3.] + # [2. 2. 3.]]] + + x_data = np.array([2, 3, 5], dtype=np.float32) + y_data = np.array([1, 4, np.nan], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.maximum(x, y) + print(res.numpy()) + #[ 2. 4. nan] + + x_data = np.array([5, 3, np.inf], dtype=np.float32) + y_data = np.array([1, 4, 5], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.maximum(x, y) + print(res.numpy()) + #[ 5. 4. inf] diff --git a/doc/paddle/api/paddle/tensor/math/minimum_cn.rst b/doc/paddle/api/paddle/tensor/math/minimum_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..1d04313385ff36c3104ec9fd173939bcae8e5c6f --- /dev/null +++ b/doc/paddle/api/paddle/tensor/math/minimum_cn.rst @@ -0,0 +1,96 @@ +.. _cn_api_paddle_tensor_minimum: + +minimum +------------------------------- + +.. py:function:: paddle.tensor.minimum(x, y, axis=-1, name=None) + +:alias_main: paddle.minimum +:alias: paddle.minimum,paddle.tensor.minimum,paddle.tensor.math.minimum + +该OP逐元素对比输入的两个多维Tensor，并且把各个位置更小的元素保存到返回结果中。 + +等式是： + +.. math:: + Out = min(X, Y) + +- :math:`X` ：多维Tensor。 +- :math:`Y` ：多维Tensor。 + +此运算算子有两种情况： + 1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。 + 2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。 + +对于情况2： + 1. 用 :math:`Y` 的 ``shape`` 匹配 :math:`X` 的 ``shape``，其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。 + 2. 如果 ``axis`` < 0（默认值为-1），则 :math:`axis = abs(X.ndim - Y.ndim) - axis - 1` 。 + 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 + +具体的飞桨的广播（broadcasting）机制可以参考 `<> `_ 。 + +参数 +::::::::: + - **x** （Tensor）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。 + - **y** （Tensor）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。 + - **axis** （int32, 可选）- Y的维度对应到X维度上时的索引。默认值为 -1。 + - **name** （string, 可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。 + +返回 +::::::::: + Tensor，维度和数据类型与 ``x`` 相同的多维Tensor。 + + +代码示例 +:::::::::: + +.. code-block:: python + + import paddle + import numpy as np + paddle.disable_static() + + x_data = np.array([[1, 2], [3, 4]], dtype=np.float32) + y_data = np.array([[5, 6], [7, 8]], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.minimum(x, y) + print(res.numpy()) + #[[1. 2.] + # [3. 4.]] + + x_data = np.array([[[1, 2, 3], [1, 2, 3]]], dtype=np.float32) + y_data = np.array([1, 2], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.minimum(x, y, axis=1) + print(res.numpy()) + #[[[1. 1. 1.] + # [2. 2. 2.]]] + + x_data = np.array([2, 3, 5], dtype=np.float32) + y_data = np.array([1, 4, np.nan], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.minimum(x, y) + print(res.numpy()) + #[ 1. 3. nan] + + x_data = np.array([5, 3, np.inf], dtype=np.float32) + y_data = np.array([1, 4, 5], dtype=np.float32) + x = paddle.to_variable(x_data) + y = paddle.to_variable(y_data) + res = paddle.minimum(x, y) + print(res.numpy()) + #[1. 3. 5.] diff --git a/doc/paddle/api/paddle/tensor/math/sum_cn.rst b/doc/paddle/api/paddle/tensor/math/sum_cn.rst index 0dc93e01cf6a6f44293843654f20a6214009e559..47afc379c37747e1c87c2e53d0eea7276899818b 100755 --- a/doc/paddle/api/paddle/tensor/math/sum_cn.rst +++ b/doc/paddle/api/paddle/tensor/math/sum_cn.rst @@ -1,81 +1,47 @@ -.. _cn_api_fluid_layers_sum: +.. _cn_api_tensor_sum: sum ------------------------------- -.. py:function:: paddle.fluid.layers.sum(x) +.. py:function:: paddle.sum(x, axis=None, dtype=None, keepdim=False, name=None) - - - -该OP用于对输入的一至多个Tensor或LoDTensor求和。如果输入的是LoDTensor，输出仅与第一个输入共享LoD信息（序列信息）。 - -例1： -:: - 输入： - input.shape = [2, 3] - input = [[1, 2, 3], - [4, 5, 6]] - - 输出： - output.shape = [2, 3] - output = [[1, 2, 3], - [4, 5, 6]] - -例2： -:: - 输入： - 第一个输入： - input1.shape = [2, 3] - input1 = [[1, 2, 3], - [4, 5, 6]] - - 第二个输入： - input2.shape = [2, 3] - input2 = [[7, 8, 9], - [10, 11, 12]] - - 输出： - output.shape = [2, 3] - output = [[8, 10, 12], - [14, 16, 18]] +该OP是对指定维度上的Tensor元素进行求和运算，并输出相应的计算结果。 参数： - **x** (Variable|list(Variable)) - 输入的一至多个Variable。如果输入了多个Variable，则不同Variable间的shape和数据类型应保持一致。Variable为多维Tensor或LoDTensor，数据类型支持：float32，float64，int32，int64 - -返回：对输入 ``x`` 中的Variable求和后的结果，shape和数据类型与 ``x`` 一致 - -返回类型：Variable - - -**代码示例：** - -.. code-block:: python - - import paddle.fluid as fluid - input0 = fluid.layers.fill_constant(shape=[2, 3], dtype='int64', value=5) - input1 = fluid.layers.fill_constant(shape=[2, 3], dtype='int64', value=3) - sum = fluid.layers.sum([input0, input1]) - - #用户可以通过executor打印出求和的结果 - out = fluid.layers.Print(sum, message="the sum of input0 and input1: ") - exe = fluid.Executor(fluid.CPUPlace()) - exe.run(fluid.default_main_program()) - - #打印出的数据为： - 1570701754 the sum of input0 and input1: The place is:CPUPlace - Tensor[sum_0.tmp_0] - shape: [2,3,] - dtype: l - data: 8,8,8,8,8,8, - - #输出了shape为[2,3]的Tensor，与输入的shape一致 - #dtype为对应C++数据类型，在不同环境下可能显示值不同，但本质相同 - #例如：如果Tensor中数据类型是int64，则对应的C++数据类型为int64_t，所以dtype值为typeid(int64_t).name()， - # 其在MacOS下为'x'，linux下为'l'，Windows下为'__int64'，都表示64位整型变量 - - - - - - + - **x** （Tensor）- 输入变量为多维Tensor，支持数据类型为float32，float64，int32，int64。 + - **axis** （int | list | tuple ，可选）- 求和运算的维度。如果为None，则计算所有元素的和并返回包含单个元素的Tensor变量，否则必须在 :math:`[−rank(x),rank(x)]` 范围内。如果 :math:`axis [i] <0` ，则维度将变为 :math:`rank+axis[i]` ，默认值为None。 + - **dtype** （str ， 可选）- 输出变量的数据类型。若参数为空，则输出变量的数据类型和输入变量相同，默认值为None。 + - **keepdim** （bool）- 是否在输出Tensor中保留减小的维度。如 keepdim 为true，否则结果张量的维度将比输入张量小，默认值为False。 + - **name** （str ， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 + +返回： + ``Tensor``，在指定维度上进行求和运算的Tensor，数据类型和输入数据类型一致。 + + +**代码示例** + +.. code-block:: python + + import numpy as np + import paddle + paddle.disable_static() + + # x is a Tensor variable with following elements: + # [[0.2, 0.3, 0.5, 0.9] + # [0.1, 0.2, 0.6, 0.7]] + # Each example is followed by the corresponding output tensor. + x_data = np.array([[0.2, 0.3, 0.5, 0.9],[0.1, 0.2, 0.6, 0.7]]).astype('float32') + x = paddle.to_tensor(x_data) + out1 = paddle.sum(x) # [3.5] + out2 = paddle.sum(x, axis=0) # [0.3, 0.5, 1.1, 1.6] + out3 = paddle.sum(x, axis=-1) # [1.9, 1.6] + out4 = paddle.sum(x, axis=1, keepdim=True) # [[1.9], [1.6]] + + # y is a Tensor variable with shape [2, 2, 2] and elements as below: + # [[[1, 2], [3, 4]], + # [[5, 6], [7, 8]]] + # Each example is followed by the corresponding output tensor. + y_data = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]).astype('float32') + y = paddle.to_tensor(y_data) + out5 = paddle.sum(y, axis=[1, 2]) # [10, 26] + out6 = paddle.sum(y, axis=[0, 1]) # [16, 20] diff --git a/doc/paddle/api/paddle/tensor/search/argmax_cn.rst b/doc/paddle/api/paddle/tensor/search/argmax_cn.rst index d165ce8d6997f060e53c2754239be83b6298ef2c..157806c38000bd4ae1866e55e4ecbe5bd90e7882 100644 --- a/doc/paddle/api/paddle/tensor/search/argmax_cn.rst +++ b/doc/paddle/api/paddle/tensor/search/argmax_cn.rst @@ -1,54 +1,44 @@ -.. _cn_api_fluid_layers_argmax: +.. _cn_api_tensor_argmax: argmax ------------------------------- -.. py:function:: paddle.fluid.layers.argmax(x, axis=0) +.. py:function:: paddle.argmax(x, axis=None, dtype=None, keepdim=False, name=None) - - -**argmax** - 该OP沿 ``axis`` 计算输入 ``x`` 的最大元素的索引。 -参数： - - **x** (Variable) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int8、int16、int32、int64。 - - **axis** (int，可选) - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R)，R是输入 ``x`` 的Rank， ``axis`` 为负时与 ``axis`` +R 等价。默认值为0。 +参数 +:::::::: + - **x** （Tensor） - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int16、int32、int64、uint8。 + - **axis** （int，可选） - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R），R是输入 ``x`` 的维度个数， ``axis`` 为负数时，进行计算的 ``axis`` 与 ``axis`` + R 一致。默认值为None, 将会对输入的 `x` 进行平铺展开，返回最大值的索引。 + - **dtype** （np.dtype|str）- 输出Tensor的数据类型，可选值为int32，int64，默认值为None，将返回int64类型的结果。 + - **keepdim** （bool，可选）- 是否保留进行最大值索引操作的轴，默认值为False。 + - **name** （str，可选） – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回： ``Tensor`` ，数据类型int64 +返回 +:::::::: +``Tensor``, 如果设置 :attr:`dtype` 为 `int32` 时，返回的tensor的数据类型为 `int32` ，其它情况将返回的tensor的数据类型为 `int64` 。 -返回类型：Variable -**代码示例**： +示例代码 +:::::::: .. code-block:: python - import paddle.fluid as fluid - import numpy as np - - in1 = np.array([[[5,8,9,5], - [0,0,1,7], - [6,9,2,4]], - [[5,2,4,2], - [4,7,7,9], - [1,7,0,6]]]) - with fluid.dygraph.guard(): - x = fluid.dygraph.to_variable(in1) - out1 = fluid.layers.argmax(x=x, axis=-1) - out2 = fluid.layers.argmax(x=x, axis=0) - out3 = fluid.layers.argmax(x=x, axis=1) - out4 = fluid.layers.argmax(x=x, axis=2) - print(out1.numpy()) - # [[2 3 1] - # [0 3 1]] - print(out2.numpy()) - # [[0 0 0 0] - # [1 1 1 1] - # [0 0 0 1]] - print(out3.numpy()) - # [[2 2 0 1] - # [0 1 1 1]] - print(out4.numpy()) - # [[2 3 1] - # [0 3 1]] + import numpy as np + import paddle + + paddle.disable_static() + data = [[5,8,9,5], + [0,0,1,7], + [6,9,2,4]] + x = paddle.to_tensor(data) + out1 = paddle.argmax(x) + print(out1.numpy()) # 2 + out2 = paddle.argmax(x, axis=1) + print(out2.numpy()) + # [2 3 1] + out3 = paddle.argmax(x, axis=-1) + print(out3.numpy()) + # [2 3 1] diff --git a/doc/paddle/api/paddle/tensor/search/argmin_cn.rst b/doc/paddle/api/paddle/tensor/search/argmin_cn.rst index 74ba5fbc52a2cc285cd9d1a370246e028ec0b14c..14082c452382ba2e7c17eb11306e190b087e0c70 100644 --- a/doc/paddle/api/paddle/tensor/search/argmin_cn.rst +++ b/doc/paddle/api/paddle/tensor/search/argmin_cn.rst @@ -1,57 +1,43 @@ -.. _cn_api_fluid_layers_argmin: +.. _cn_api_tensor_argmin: argmin ------------------------------- -.. py:function:: paddle.fluid.layers.argmin(x, axis=0) +.. py:function:: paddle.argmin(x, axis=None, dtype=None, keepdim=False, name=None) -:alias_main: paddle.argmin -:alias: paddle.argmin,paddle.tensor.argmin,paddle.tensor.search.argmin -:old_api: paddle.fluid.layers.argmin - - - -**argmin** 该OP沿 ``axis`` 计算输入 ``x`` 的最小元素的索引。 -参数： - - **x** (Variable) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int8、int16、int32、int64。 - - **axis** (int，可选) - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R)，R是输入 ``x`` 的Rank， ``axis`` 为负时与 ``axis`` +R 等价。默认值为0。 - -返回： ``Tensor`` ，数据类型int64 +参数 +:::::::: + - **x** （Tensor） - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int16、int32、int64、uint8。 + - **axis** （int，可选） - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R），R是输入 ``x`` 的维度个数， ``axis`` 为负数时，进行计算的 ``axis`` 与 ``axis`` + R 一致。默认值为None, 将会对输入的 `x` 进行平铺展开，返回最小值的索引。 + - **dtype** （np.dtype|str）- 输出Tensor的数据类型，可选值为int32，int64，默认值为None，将返回int64类型的结果。 + - **keepdim** （bool，可选）- 是否保留进行最小值索引操作的轴，默认值为False。 + - **name** （str，可选） – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回类型：Variable +返回 +:::::::: +``Tensor``, 如果设置 :attr:`dtype` 为 `int32` 时，返回的tensor的数据类型为 `int32` ，其它情况将返回的tensor的数据类型为 `int64` 。 -**代码示例**： +示例代码 +:::::::: .. code-block:: python - import paddle.fluid as fluid - import numpy as np - - in1 = np.array([[[5,8,9,5], - [0,0,1,7], - [6,9,2,4]], - [[5,2,4,2], - [4,7,7,9], - [1,7,0,6]]]) - with fluid.dygraph.guard(): - x = fluid.dygraph.to_variable(in1) - out1 = fluid.layers.argmin(x=x, axis=-1) - out2 = fluid.layers.argmin(x=x, axis=0) - out3 = fluid.layers.argmin(x=x, axis=1) - out4 = fluid.layers.argmin(x=x, axis=2) - print(out1.numpy()) - # [[0 0 2] - # [1 0 2]] - print(out2.numpy()) - # [[0 1 1 1] - # [0 0 0 0] - # [1 1 1 0]] - print(out3.numpy()) - # [[1 1 1 2] - # [2 0 2 0]] - print(out4.numpy()) - # [[0 0 2] - # [1 0 2]] + import numpy as np + import paddle + + paddle.disable_static() + data = [[5,8,9,5], + [0,0,1,7], + [6,9,2,4]] + x = paddle.to_tensor(data) + out1 = paddle.argmin(x) + print(out1.numpy()) # 4 + out2 = paddle.argmin(x, axis=1) + print(out2.numpy()) + # [0 0 2] + out3 = paddle.argmin(x, axis=-1) + print(out3.numpy()) + # [0 0 2] diff --git a/doc/paddle/api/paddle/tensor/search/argsort_cn.rst b/doc/paddle/api/paddle/tensor/search/argsort_cn.rst index a681b3beefadc7c601a42a23a958792b5bac9939..43d2dd420eb8fa255e35ff229272f7b3aeb50df0 100644 --- a/doc/paddle/api/paddle/tensor/search/argsort_cn.rst +++ b/doc/paddle/api/paddle/tensor/search/argsort_cn.rst @@ -1,72 +1,62 @@ -.. _cn_api_fluid_layers_argsort: +.. _cn_api_tensor_cn_argsort: argsort ------------------------------- -.. py:function:: paddle.fluid.layers.argsort(input,axis=-1,descending=False,name=None) +.. py:function:: paddle.argsort(x, axis=-1, descending=False, name=None) :alias_main: paddle.argsort :alias: paddle.argsort,paddle.tensor.argsort,paddle.tensor.search.argsort -:old_api: paddle.fluid.layers.argsort - - -对输入变量沿给定轴进行排序，输出排序好的数据和相应的索引，其维度和输入相同。**默认升序排列，如果需要降序排列设置** ``descending=True`` 。 +对输入变量沿给定轴进行排序，输出排序好的数据的相应索引，其维度和输入相同。默认升序排列，如果需要降序排列设置 ``descending=True`` 。 参数： - - **input** (Variable) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int16、int32、int64、uint8。 + - **x** (Tensor) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int16、int32、int64、uint8。 - **axis** (int，可选) - 指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R)，R是输入 ``x`` 的Rank， ``axis`` 为负时与 ``axis`` +R 等价。默认值为0。 - **descending** (bool，可选) - 指定算法排序的方向。如果设置为True，算法按照降序排序。如果设置为False或者不设置，按照升序排序。默认值为False。 - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回：一组已排序的输出（与 ``input`` 维度相同、数据类型相同）和索引（数据类型为int64）。 +返回：Tensor, 排序后索引信息（与 ``x`` 维度信息一致），数据类型为int64。 -返回类型：tuple[Variable] **代码示例**： .. code-block:: python - import paddle.fluid as fluid - import numpy as np - - in1 = np.array([[[5,8,9,5], - [0,0,1,7], - [6,9,2,4]], + import paddle + import paddle.imperative as imperative + import numpy as np + + paddle.enable_imperative() + input_array = np.array([[[5,8,9,5], + [0,0,1,7], + [6,9,2,4]], [[5,2,4,2], - [4,7,7,9], - [1,7,0,6]]]).astype(np.float32) - with fluid.dygraph.guard(): - x = fluid.dygraph.to_variable(in1) - out1 = fluid.layers.argsort(input=x, axis=-1) # same as axis==2 - out2 = fluid.layers.argsort(input=x, axis=0) - out3 = fluid.layers.argsort(input=x, axis=1) - print(out1[0].numpy()) - # [[[5. 5. 8. 9.] - # [0. 0. 1. 7.] - # [2. 4. 6. 9.]] - # [[2. 2. 4. 5.] - # [4. 7. 7. 9.] - # [0. 1. 6. 7.]]] - print(out1[1].numpy()) - # [[[0 3 1 2] - # [0 1 2 3] - # [2 3 0 1]] - # [[1 3 2 0] - # [0 1 2 3] - # [2 0 3 1]]] - print(out2[0].numpy()) - # [[[5. 2. 4. 2.] - # [0. 0. 1. 7.] - # [1. 7. 0. 4.]] - # [[5. 8. 9. 5.] - # [4. 7. 7. 9.] - # [6. 9. 2. 6.]]] - print(out3[0].numpy()) - # [[[0. 0. 1. 4.] - # [5. 8. 2. 5.] - # [6. 9. 9. 7.]] - # [[1. 2. 0. 2.] - # [4. 7. 4. 6.] - # [5. 7. 7. 9.]]] + [4,7,7,9], + [1,7,0,6]]]).astype(np.float32) + x = imperative.to_variable(input_array) + out1 = paddle.argsort(x=x, axis=-1) + out2 = paddle.argsort(x=x, axis=0) + out3 = paddle.argsort(x=x, axis=1) + print(out1.numpy()) + #[[[0 3 1 2] + # [0 1 2 3] + # [2 3 0 1]] + # [[1 3 2 0] + # [0 1 2 3] + # [2 0 3 1]]] + print(out2.numpy()) + #[[[0 1 1 1] + # [0 0 0 0] + # [1 1 1 0]] + # [[1 0 0 0] + # [1 1 1 1] + # [0 0 0 1]]] + print(out3.numpy()) + #[[[1 1 1 2] + # [0 0 2 0] + # [2 2 0 1]] + # [[2 0 2 0] + # [1 1 0 2] + # [0 2 1 1]]] diff --git a/doc/paddle/api/paddle/tensor/search/where_cn.rst b/doc/paddle/api/paddle/tensor/search/where_cn.rst index d483b8fa905522125f7abecdf922ba9fd647fcbd..bcfabfab33a23f1e56e23bc922c59b965564155e 100644 --- a/doc/paddle/api/paddle/tensor/search/where_cn.rst +++ b/doc/paddle/api/paddle/tensor/search/where_cn.rst @@ -1,42 +1,53 @@ -.. _cn_api_fluid_layers_where: +.. _cn_api_tensor_where: where ------------------------------- -.. py:function:: paddle.fluid.layers.where(condition) +.. py:function:: paddle.where(condition, x, y, name=None) +:alias_main: paddle.where +:alias: paddle.where,paddle.tensor.where,paddle.tensor.search.where +:update_api: paddle.fluid.layers.cond -该OP计算输入元素中为True的元素在输入中的坐标（index）。 - +该OP返回一个根据输入 ``condition``, 选择 ``x`` 或 ``y`` 的元素组成的多维 ``Tensor`` ： + +.. math:: + Out_i = + \left\{ + \begin{aligned} + &X_i, & & if \ cond_i \ is \ True \\ + &Y_i, & & if \ cond_i \ is \ False \\ + \end{aligned} + \right. + 参数： - - **condition** （Variable）– 输入秩至少为1的多维Tensor，数据类型是bool类型。 + - **condition** （Variable）- 选择 ``x`` 或 ``y`` 元素的条件 。 + - **x** （Variable）- 多维 ``Tensor`` ，数据类型为 ``float32`` 或 ``float64`` 或 ``int32`` 或 ``int64`` 。 + - **y** （Variable）- 多维 ``Tensor`` ，数据类型为 ``float32`` 或 ``float64`` 或 ``int32`` 或 ``int64`` 。 + - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。 -返回：输出condition元素为True的坐标（index），将所有的坐标（index）组成一个2-D的Tensor。 +返回：数据类型与 ``x`` 相同的 ``Tensor`` 。 -返回类型：Variable，数据类型是int64。 - -**代码示例**： +返回类型：Variable。 -.. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers - import numpy as np - # tensor 为 [True, False, True] - condition = layers.assign(np.array([1, 0, 1], dtype='int32')) - condition = layers.cast(condition, 'bool') - out = layers.where(condition) # [[0], [2]] +**代码示例：** + +.. code-block:: python - # tensor 为 [[True, False], [False, True]] - condition = layers.assign(np.array([[1, 0], [0, 1]], dtype='int32')) - condition = layers.cast(condition, 'bool') - out = layers.where(condition) # [[0, 0], [1, 1]] + import paddle + import numpy as np + import paddle.fluid as fluid - # tensor 为 [False, False, False] - condition = layers.assign(np.array([0, 0, 0], dtype='int32')) - condition = layers.cast(condition, 'bool') - out = layers.where(condition) # [[]] + x_i = np.array([0.9383, 0.1983, 3.2, 1.2]).astype("float32") + y_i = np.array([1.0, 1.0, 1.0, 1.0]).astype("float32") + with fluid.dygraph.guard(): + x = fluid.dygraph.to_variable(x_i) + y = fluid.dygraph.to_variable(y_i) + out = paddle.where(x>1, x, y) + print(out.numpy()) + #out: [1.0, 1.0, 3.2, 1.2] diff --git a/doc/paddle/api/paddle/tensor/stat/mean_cn.rst b/doc/paddle/api/paddle/tensor/stat/mean_cn.rst index 69363e1c6ba3934a5ea1f5622d5233552b47fc84..8ac774a6b4471daca40ba4ab7ee8308fe3539b84 100644 --- a/doc/paddle/api/paddle/tensor/stat/mean_cn.rst +++ b/doc/paddle/api/paddle/tensor/stat/mean_cn.rst @@ -1,52 +1,53 @@ -.. _cn_api_fluid_layers_mean: +.. _cn_api_tensor_cn_mean: mean ------------------------------- -.. py:function:: paddle.fluid.layers.mean(x, name=None) +.. py:function:: paddle.mean(x, axis=None, keepdim=False, name=None) -:alias_main: paddle.mean -:alias: paddle.mean,paddle.tensor.mean,paddle.tensor.stat.mean -:old_api: paddle.fluid.layers.mean +该OP沿 ``axis`` 计算 ``x`` 的平均值。 -计算 ``x`` 所有元素的平均值。 +参数 +:::::::::: + - x (Tensor) - 输入的Tensor，数据类型为：float32、float64。 + - axis (int|list|tuple, 可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是int、list(int)、tuple(int)。如果 ``axis`` 包含多个维度，则沿着 ``axis`` 中的所有轴进行计算。``axis`` 或者其中的元素值应该在范围[-D, D)内，D是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于0，则等价于 :math:`axis + D` 。如果 ``axis`` 是None，则对 ``x`` 的全部元素计算平均值。默认值为None。 + - keepdim (bool, 可选) - 是否在输出Tensor中保留减小的维度。如果 ``keepdim`` 为True，则输出Tensor和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为1)。否则，输出Tensor的形状会在 ``axis`` 上进行squeeze操作。默认值为False。 + - name (str, 可选) - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。 -参数： - - **x** (Variable) : Tensor 或 LoDTensor。均值运算的输入。 - - **name** (basestring | None) : 输出变量的名称。 +返回 +:::::::::: + ``Tensor`` ，沿着 ``axis`` 进行平均值计算的结果，数据类型和 ``x`` 相同。 -返回： - - Variable: 包含输出均值的 Tensor / LoDTensor。 - -返回类型： - - Variable（变量）。 - -**代码示例**： +代码示例 +:::::::::: .. code-block:: python - import paddle.fluid as fluid - import numpy - - # Graph Organizing - input = fluid.layers.data( - name='data', shape=[2, 3], dtype='float32') - output = fluid.layers.mean(input) - - # Create an executor using CPU as an example - place = fluid.CPUPlace() - exe = fluid.Executor(place) - exe.run(fluid.default_startup_program()) - - # Execute - x_ndarray = numpy.ones([2, 3]).astype(numpy.float32) - res, = exe.run(fluid.default_main_program(), - feed={'data':x_ndarray}, - fetch_list=[output]) - print(res) - ''' - Output Value: - [1.] - ''' + import paddle + import numpy as np + + paddle.disable_static() + + x = np.array([[[1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12]], + [[13, 14, 15, 16], + [17, 18, 19, 20], + [21, 22, 23, 24]]], 'float32') + x = paddle.to_tensor(x) + out1 = paddle.mean(x) + # [12.5] + out2 = paddle.mean(x, axis=-1) + # [[ 2.5 6.5 10.5] + # [14.5 18.5 22.5]] + out3 = paddle.mean(x, axis=-1, keepdim=True) + # [[[ 2.5] + # [ 6.5] + # [10.5]] + # [[14.5] + # [18.5] + # [22.5]]] + out4 = paddle.mean(x, axis=[0, 2]) + # [ 8.5 12.5 16.5]