Fix index (#2522)

* fix index test=develop

* fix some api index test=develop
Co-authored-by: NTC.Long <chenlong@TCLongdeMacBook-Pro.local>

doc/paddle/api/paddle/compat/round_cn.rst

-.. _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)]
-
-
-

doc/paddle/api/paddle/framework/get_default_dtype_cn.rst

-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()

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)

doc/paddle/api/paddle/framework/set_default_dtype_cn.rst

-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")

doc/paddle/api/paddle/nn/layer/common/BilinearTensorProduct_cn.rst

+.. _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``
+
+

doc/paddle/api/paddle/nn/layer/common/Bilinear_cn.rst

+.. _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]
+

doc/paddle/api/paddle/nn/layer/common/ConstantPad1d_cn.rst

+.. _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.]]]

doc/paddle/api/paddle/nn/layer/common/ConstantPad2d_cn.rst

+.. _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.]]]]

doc/paddle/api/paddle/nn/layer/common/ConstantPad3d_cn.rst

+.. _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.]]]]]

doc/paddle/api/paddle/nn/layer/norm/BatchNorm1d_cn.rst

+.. _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 <https://arxiv.org/pdf/1502.03167.pdf>`_
+
+当训练时 :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)
+

doc/paddle/api/paddle/nn/layer/norm/BatchNorm2d_cn.rst

+.. _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 <https://arxiv.org/pdf/1502.03167.pdf>`_
+
+当训练时 :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)
+

doc/paddle/api/paddle/nn/layer/norm/BatchNorm3d_cn.rst

+.. _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 <https://arxiv.org/pdf/1502.03167.pdf>`_
+
+当训练时 :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)
+

doc/paddle/api/paddle/tensor/creation/eye_cn.rst

-.. _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]]
 
 
 

doc/paddle/api/paddle/tensor/creation/ones_cn.rst

-.. _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]]
+

doc/paddle/api/paddle/tensor/creation/ones_like_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/creation/zeros_cn.rst

-.. _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]]
+

doc/paddle/api/paddle/tensor/creation/zeros_like_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/linalg/matmul_cn.rst

-.. _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]
+

doc/paddle/api/paddle/tensor/logic/equal_cn.rst

-.. _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]
 

doc/paddle/api/paddle/tensor/logic/greater_equal_cn.rst

-.. _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]
 
 

doc/paddle/api/paddle/tensor/logic/greater_than_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/logic/less_equal_cn.rst

-.. _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]
 
 

doc/paddle/api/paddle/tensor/logic/less_than_cn.rst

-.. _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]]
 

doc/paddle/api/paddle/tensor/logic/not_equal_cn.rst

-.. _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]
 
 

doc/paddle/api/paddle/tensor/manipulation/concat_cn.rst

-.. _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]]

doc/paddle/api/paddle/tensor/manipulation/gather_cn.rst

-.. _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]]
 

doc/paddle/api/paddle/tensor/manipulation/gather_nd_cn.rst

-.. _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]]
 
 

doc/paddle/api/paddle/tensor/manipulation/split_cn.rst

-.. _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]
-
-
-
-
-
-
-
-

doc/paddle/api/paddle/tensor/manipulation/stack_cn.rst

-.. _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.]]]

doc/paddle/api/paddle/tensor/manipulation/unsqueeze_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/math/cumsum_cn.rst

-.. _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
 
 

doc/paddle/api/paddle/tensor/math/maximum_cn.rst

+.. _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）机制可以参考 `<<PaddlePaddle广播机制文档>> <https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/beginners_guide/basic_concept/broadcasting.rst>`_ 。
+
+参数
+:::::::::
+   - **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]

doc/paddle/api/paddle/tensor/math/minimum_cn.rst

+.. _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）机制可以参考 `<<PaddlePaddle广播机制文档>> <https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/beginners_guide/basic_concept/broadcasting.rst>`_ 。
+
+参数
+:::::::::
+   - **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.]

doc/paddle/api/paddle/tensor/math/sum_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/search/argmax_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/search/argmin_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/search/argsort_cn.rst

-.. _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]]]

doc/paddle/api/paddle/tensor/search/where_cn.rst

-.. _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]

doc/paddle/api/paddle/tensor/stat/mean_cn.rst

-.. _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]